room/compiler/src/test/kotlin/androidx/room/processor/PojoProcessorTest.kt

/*
 * Copyright (C) 2017 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.processor

import COMMON
import androidx.room.Embedded
import androidx.room.parser.SQLTypeAffinity
import androidx.room.compiler.processing.XVariableElement
import androidx.room.processor.ProcessorErrors.CANNOT_FIND_GETTER_FOR_FIELD
import androidx.room.processor.ProcessorErrors.CANNOT_FIND_TYPE
import androidx.room.processor.ProcessorErrors.POJO_FIELD_HAS_DUPLICATE_COLUMN_NAME
import androidx.room.processor.ProcessorErrors.junctionColumnWithoutIndex
import androidx.room.processor.ProcessorErrors.relationCannotFindEntityField
import androidx.room.processor.ProcessorErrors.relationCannotFindJunctionEntityField
import androidx.room.processor.ProcessorErrors.relationCannotFindJunctionParentField
import androidx.room.processor.ProcessorErrors.relationCannotFindParentEntityField
import androidx.room.testing.TestInvocation
import androidx.room.vo.CallType
import androidx.room.vo.Constructor
import androidx.room.vo.EmbeddedField
import androidx.room.vo.Field
import androidx.room.vo.Pojo
import androidx.room.vo.RelationCollector
import com.google.testing.compile.CompileTester
import com.squareup.javapoet.ClassName
import com.squareup.javapoet.TypeName
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.CoreMatchers.instanceOf
import org.hamcrest.CoreMatchers.not
import org.hamcrest.CoreMatchers.notNullValue
import org.hamcrest.CoreMatchers.nullValue
import org.hamcrest.CoreMatchers.sameInstance
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import org.mockito.Mockito.doReturn
import org.mockito.Mockito.mock
import simpleRun
import toJFO
import java.io.File
import javax.tools.JavaFileObject

/**
 * Some of the functionality is tested via TableEntityProcessor.
 */
@RunWith(JUnit4::class)
class PojoProcessorTest {

    companion object {
        val MY_POJO: ClassName = ClassName.get("foo.bar", "MyPojo")
        val HEADER = """
            package foo.bar;
            import androidx.room.*;
            import java.util.*;
            public class MyPojo {
            """
        val FOOTER = "\n}"
    }

    @Test
    fun inheritedPrivate() {
        val parent = """
            package foo.bar.x;
            import androidx.room.*;
            public class BaseClass {
                private String baseField;
                public String getBaseField(){ return baseField; }
                public void setBaseField(String baseField){ }
            }
        """
        simpleRun(
                """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} extends foo.bar.x.BaseClass {
                    public String myField;
                }
                """.toJFO(MY_POJO.toString()),
                parent.toJFO("foo.bar.x.BaseClass")) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null).process()
            assertThat(pojo.fields.find { it.name == "myField" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "baseField" }, notNullValue())
        }.compilesWithoutError()
    }

    @Test
    fun transient_ignore() {
        singleRun("""
            transient int foo;
            int bar;
        """) { pojo ->
            assertThat(pojo.fields.size, `is`(1))
            assertThat(pojo.fields[0].name, `is`("bar"))
        }.compilesWithoutError()
    }

    @Test
    fun transient_withColumnInfo() {
        singleRun("""
            @ColumnInfo
            transient int foo;
            int bar;
        """) { pojo ->
            assertThat(pojo.fields.map { it.name }.toSet(), `is`(setOf("bar", "foo")))
        }.compilesWithoutError()
    }

    @Test
    fun transient_embedded() {
        singleRun("""
            @Embedded
            transient Foo foo;
            int bar;
            static class Foo {
                int x;
            }
        """) { pojo ->
            assertThat(pojo.fields.map { it.name }.toSet(), `is`(setOf("x", "bar")))
        }.compilesWithoutError()
    }

    @Test
    fun transient_insideEmbedded() {
        singleRun("""
            @Embedded
            Foo foo;
            int bar;
            static class Foo {
                transient int x;
                int y;
            }
        """) { pojo ->
            assertThat(pojo.fields.map { it.name }.toSet(), `is`(setOf("bar", "y")))
        }.compilesWithoutError()
    }

    @Test
    fun transient_relation() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public transient List<User> user;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            assertThat(pojo.relations.first().entityField.name, `is`("uid"))
            assertThat(pojo.relations.first().parentField.name, `is`("id"))
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun embedded() {
        singleRun(
                """
                int id;
                @Embedded
                Point myPoint;
                static class Point {
                    int x;
                    int y;
                }
                """
        ) { pojo ->
            assertThat(pojo.fields.size, `is`(3))
            assertThat(pojo.fields[1].name, `is`("x"))
            assertThat(pojo.fields[2].name, `is`("y"))
            assertThat(pojo.fields[0].parent, nullValue())
            assertThat(pojo.fields[1].parent, notNullValue())
            assertThat(pojo.fields[2].parent, notNullValue())
            val parent = pojo.fields[2].parent!!
            assertThat(parent.prefix, `is`(""))
            assertThat(parent.field.name, `is`("myPoint"))
            assertThat(parent.pojo.typeName,
                    `is`(ClassName.get("foo.bar.MyPojo", "Point") as TypeName))
        }.compilesWithoutError()
    }

    @Test
    fun embeddedWithPrefix() {
        singleRun(
                """
                int id;
                @Embedded(prefix = "foo")
                Point myPoint;
                static class Point {
                    int x;
                    @ColumnInfo(name = "y2")
                    int y;
                }
                """
        ) { pojo ->
            assertThat(pojo.fields.size, `is`(3))
            assertThat(pojo.fields[1].name, `is`("x"))
            assertThat(pojo.fields[2].name, `is`("y"))
            assertThat(pojo.fields[1].columnName, `is`("foox"))
            assertThat(pojo.fields[2].columnName, `is`("fooy2"))
            val parent = pojo.fields[2].parent!!
            assertThat(parent.prefix, `is`("foo"))
        }.compilesWithoutError()
    }

    @Test
    fun nestedEmbedded() {
        singleRun(
                """
                int id;
                @Embedded(prefix = "foo")
                Point myPoint;
                static class Point {
                    int x;
                    @ColumnInfo(name = "y2")
                    int y;
                    @Embedded(prefix = "bar")
                    Coordinate coordinate;
                }
                static class Coordinate {
                    double lat;
                    double lng;
                    @Ignore
                    String ignored;
                }
                """
        ) { pojo ->
            assertThat(pojo.fields.size, `is`(5))
            assertThat(pojo.fields.map { it.columnName }, `is`(
                    listOf("id", "foox", "fooy2", "foobarlat", "foobarlng")))
        }.compilesWithoutError()
    }

    @Test
    fun embedded_generic() {
        val point = """
            package foo.bar;
            public class Point {
                public int x;
                public int y;
            }
            """.toJFO("foo.bar.Point")
        val base = """
            package foo.bar;
            import ${Embedded::class.java.canonicalName};
            public class BaseClass<T> {
                @Embedded
                public T genericField;
            }
            """.toJFO("foo.bar.BaseClass")
        singleRunFullClass(
            """
                package foo.bar;
                public class MyPojo extends BaseClass<Point> {
                    public int normalField;
                }
                """,
            point, base
        ) { pojo, _ ->
            assertThat(pojo.fields.size, `is`(3))
            assertThat(pojo.fields.map { it.columnName }.toSet(), `is`(
                setOf("x", "y", "normalField")))
            val pointField = pojo.embeddedFields.first { it.field.name == "genericField" }
            assertThat(pointField.pojo.typeName,
                `is`(ClassName.get("foo.bar", "Point") as TypeName))
        }.compilesWithoutError()
    }

    @Test
    fun duplicateColumnNames() {
        singleRun(
                """
                int id;
                @ColumnInfo(name = "id")
                int another;
                """
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.pojoDuplicateFieldNames("id", listOf("id", "another"))
        ).and().withErrorContaining(
                POJO_FIELD_HAS_DUPLICATE_COLUMN_NAME
        ).and().withErrorCount(3)
    }

    @Test
    fun duplicateColumnNamesFromEmbedded() {
        singleRun(
                """
                int id;
                @Embedded
                Foo foo;
                static class Foo {
                    @ColumnInfo(name = "id")
                    int x;
                }
                """
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.pojoDuplicateFieldNames("id", listOf("id", "foo > x"))
        ).and().withErrorContaining(
                POJO_FIELD_HAS_DUPLICATE_COLUMN_NAME
        ).and().withErrorCount(3)
    }

    @Test
    fun dropSubPrimaryKeyNoWarningForPojo() {
        singleRun(
                """
                @PrimaryKey
                int id;
                @Embedded
                Point myPoint;
                static class Point {
                    @PrimaryKey
                    int x;
                    int y;
                }
                """
        ) { _ ->
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_view() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<UserSummary> user;
                """, COMMON.USER_SUMMARY
        ) { _ ->
        }.compilesWithoutError()
    }

    @Test
    fun relation_notCollection() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public User user;
                """, COMMON.USER
        ) { _ ->
        }.compilesWithoutError()
    }

    @Test
    fun relation_columnInfo() {
        singleRun(
                """
                int id;
                @ColumnInfo
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<User> user;
                """, COMMON.USER
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.CANNOT_USE_MORE_THAN_ONE_POJO_FIELD_ANNOTATION)
    }

    @Test
    fun relation_notEntity() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<NotAnEntity> user;
                """, COMMON.NOT_AN_ENTITY
        ) { _ ->
        }.failsToCompile().withErrorContaining(ProcessorErrors.NOT_ENTITY_OR_VIEW)
    }

    @Test
    fun relation_missingParent() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "idk", entityColumn = "uid")
                public List<User> user;
                """, COMMON.USER
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                relationCannotFindParentEntityField("foo.bar.MyPojo", "idk", listOf("id"))
        )
    }

    @Test
    fun relation_missingEntityField() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "idk")
                public List<User> user;
                """, COMMON.USER
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                relationCannotFindEntityField("foo.bar.User", "idk",
                        listOf("uid", "name", "lastName", "age"))
        )
    }

    @Test
    fun relation_missingType() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<User> user;
                """
        ) { _ ->
        }.failsToCompile().withErrorContaining(CANNOT_FIND_TYPE)
    }

    @Test
    fun relation_nestedField() {
        singleRun(
                """
                static class Nested {
                    @ColumnInfo(name = "foo")
                    public int id;
                }
                @Embedded
                Nested nested;
                @Relation(parentColumn = "foo", entityColumn = "uid")
                public List<User> user;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.first().parentField.columnName, `is`("foo"))
        }.compilesWithoutError()
    }

    @Test
    fun relation_nestedRelation() {
        singleRun(
                """
                static class UserWithNested {
                    @Embedded
                    public User user;
                    @Relation(parentColumn = "uid", entityColumn = "uid")
                    public List<User> selfs;
                }
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid", entity = User.class)
                public List<UserWithNested> user;
                """, COMMON.USER
        ) { pojo, _ ->
            assertThat(pojo.relations.first().parentField.name, `is`("id"))
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_affinityMismatch() {
        singleRun(
                """
                String id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<User> user;
                """, COMMON.USER
        ) { pojo, invocation ->
            // trigger assignment evaluation
            RelationCollector.createCollectors(invocation.context, pojo.relations)
            assertThat(pojo.relations.size, `is`(1))
            assertThat(pojo.relations.first().entityField.name, `is`("uid"))
            assertThat(pojo.relations.first().parentField.name, `is`("id"))
        }.compilesWithoutError().withWarningContaining(
                ProcessorErrors.relationAffinityMismatch(
                        parentAffinity = SQLTypeAffinity.TEXT,
                        childAffinity = SQLTypeAffinity.INTEGER,
                        parentColumn = "id",
                        childColumn = "uid")
        )
    }

    @Test
    fun relation_simple() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<User> user;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            assertThat(pojo.relations.first().entityField.name, `is`("uid"))
            assertThat(pojo.relations.first().parentField.name, `is`("id"))
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_badProjection() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid", projection={"i_dont_exist"})
                public List<User> user;
                """, COMMON.USER
        ) { _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.relationBadProject("foo.bar.User", listOf("i_dont_exist"),
                        listOf("uid", "name", "lastName", "ageColumn"))
        )
    }

    @Test
    fun relation_badReturnTypeInGetter() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                private List<User> user;
                public void setUser(List<User> user){ this.user = user;}
                public User getUser(){return null;}
                """, COMMON.USER
        ) { _ ->
        }.failsToCompile().withErrorContaining(CANNOT_FIND_GETTER_FOR_FIELD)
    }

    @Test
    fun relation_primitiveList() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid",  projection={"uid"},
                        entity = User.class)
                public List<Integer> userIds;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            val rel = pojo.relations.first()
            assertThat(rel.projection, `is`(listOf("uid")))
            assertThat(rel.entity.typeName, `is`(COMMON.USER_TYPE_NAME as TypeName))
        }.compilesWithoutError()
    }

    @Test
    fun relation_stringList() {
        singleRun(
                """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid",  projection={"name"},
                        entity = User.class)
                public List<String> userNames;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            val rel = pojo.relations.first()
            assertThat(rel.projection, `is`(listOf("name")))
            assertThat(rel.entity.typeName, `is`(COMMON.USER_TYPE_NAME as TypeName))
        }.compilesWithoutError()
    }

    @Test
    fun relation_extendsBounds() {
        singleRun(
            """
                int id;
                @Relation(parentColumn = "id", entityColumn = "uid")
                public List<? extends User> user;
                """, COMMON.USER
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            assertThat(pojo.relations.first().entityField.name, `is`("uid"))
            assertThat(pojo.relations.first().parentField.name, `is`("id"))
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_associateBy() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(
                primaryKeys = {"uid","friendId"},
                foreignKeys = {
                    @ForeignKey(
                            entity = User.class,
                            parentColumns = "uid",
                            childColumns = "uid",
                            onDelete = ForeignKey.CASCADE),
                    @ForeignKey(
                            entity = User.class,
                            parentColumns = "uid",
                            childColumns = "friendId",
                            onDelete = ForeignKey.CASCADE),
                },
                indices = { @Index("uid"), @Index("friendId") }
            )
            public class UserFriendsXRef {
                public int uid;
                public int friendId;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int id;
                @Relation(
                    parentColumn = "id", entityColumn = "uid",
                    associateBy = @Junction(
                        value = UserFriendsXRef.class,
                        parentColumn = "uid", entityColumn = "friendId")
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { pojo ->
            assertThat(pojo.relations.size, `is`(1))
            assertThat(pojo.relations.first().junction, notNullValue())
            assertThat(pojo.relations.first().junction!!.parentField.columnName,
                `is`("uid"))
            assertThat(pojo.relations.first().junction!!.entityField.columnName,
                `is`("friendId"))
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_associateBy_withView() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @DatabaseView("SELECT 1, 2, FROM User")
            public class UserFriendsXRefView {
                public int uid;
                public int friendId;
            }
        """.toJFO("foo.bar.UserFriendsXRefView")
        singleRun(
            """
                int id;
                @Relation(
                    parentColumn = "id", entityColumn = "uid",
                    associateBy = @Junction(
                        value = UserFriendsXRefView.class,
                        parentColumn = "uid", entityColumn = "friendId")
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_associateBy_defaultColumns() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(
                primaryKeys = {"uid","friendId"},
                foreignKeys = {
                    @ForeignKey(
                            entity = User.class,
                            parentColumns = "uid",
                            childColumns = "uid",
                            onDelete = ForeignKey.CASCADE),
                    @ForeignKey(
                            entity = User.class,
                            parentColumns = "uid",
                            childColumns = "friendId",
                            onDelete = ForeignKey.CASCADE),
                },
                indices = { @Index("uid"), @Index("friendId") }
            )
            public class UserFriendsXRef {
                public int uid;
                public int friendId;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int friendId;
                @Relation(
                    parentColumn = "friendId", entityColumn = "uid",
                    associateBy = @Junction(UserFriendsXRef.class))
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun relation_associateBy_missingParentColumn() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(primaryKeys = {"friendFrom","uid"})
            public class UserFriendsXRef {
                public int friendFrom;
                public int uid;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int id;
                @Relation(
                    parentColumn = "id", entityColumn = "uid",
                    associateBy = @Junction(UserFriendsXRef.class)
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.failsToCompile().withErrorContaining(relationCannotFindJunctionParentField(
            "foo.bar.UserFriendsXRef", "id", listOf("friendFrom", "uid")))
    }

    @Test
    fun relation_associateBy_missingEntityColumn() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(primaryKeys = {"friendA","friendB"})
            public class UserFriendsXRef {
                public int friendA;
                public int friendB;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int friendA;
                @Relation(
                    parentColumn = "friendA", entityColumn = "uid",
                    associateBy = @Junction(UserFriendsXRef.class)
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.failsToCompile().withErrorContaining(relationCannotFindJunctionEntityField(
            "foo.bar.UserFriendsXRef", "uid", listOf("friendA", "friendB"))
        )
    }

    @Test
    fun relation_associateBy_missingSpecifiedParentColumn() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(primaryKeys = {"friendA","friendB"})
            public class UserFriendsXRef {
                public int friendA;
                public int friendB;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int friendA;
                @Relation(
                    parentColumn = "friendA", entityColumn = "uid",
                    associateBy = @Junction(
                        value = UserFriendsXRef.class,
                        parentColumn = "bad_col")
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.failsToCompile().withErrorContaining(relationCannotFindJunctionParentField(
            "foo.bar.UserFriendsXRef", "bad_col", listOf("friendA", "friendB"))
        )
    }

    @Test
    fun relation_associateBy_missingSpecifiedEntityColumn() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity(primaryKeys = {"friendA","friendB"})
            public class UserFriendsXRef {
                public int friendA;
                public int friendB;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int friendA;
                @Relation(
                    parentColumn = "friendA", entityColumn = "uid",
                    associateBy = @Junction(
                        value = UserFriendsXRef.class,
                        entityColumn = "bad_col")
                )
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.failsToCompile().withErrorContaining(relationCannotFindJunctionEntityField(
            "foo.bar.UserFriendsXRef", "bad_col", listOf("friendA", "friendB"))
        )
    }

    @Test
    fun relation_associateBy_warnIndexOnJunctionColumn() {
        val junctionEntity = """
            package foo.bar;

            import androidx.room.*;

            @Entity
            public class UserFriendsXRef {
                @PrimaryKey(autoGenerate = true)
                public long rowid;
                public int uid;
                public int friendId;
            }
        """.toJFO("foo.bar.UserFriendsXRef")
        singleRun(
            """
                int friendId;
                @Relation(
                    parentColumn = "friendId", entityColumn = "uid",
                    associateBy = @Junction(UserFriendsXRef.class))
                public List<User> user;
                """, COMMON.USER, junctionEntity
        ) { _ ->
        }.compilesWithoutError().withWarningCount(2).withWarningContaining(
                junctionColumnWithoutIndex("foo.bar.UserFriendsXRef", "uid"))
    }

    @Test
    fun cache() {
        val pojo = """
            $HEADER
            int id;
            $FOOTER
            """.toJFO(MY_POJO.toString())
        simpleRun(pojo) { invocation ->
            val element = invocation.processingEnv.requireTypeElement(MY_POJO)
            val pojo1 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.BIND_TO_STMT, null).process()
            assertThat(pojo1, notNullValue())
            val pojo2 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.BIND_TO_STMT, null).process()
            assertThat(pojo2, sameInstance(pojo1))

            val pojo3 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.READ_FROM_CURSOR, null).process()
            assertThat(pojo3, notNullValue())
            assertThat(pojo3, not(sameInstance(pojo1)))

            val pojo4 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.TWO_WAY, null).process()
            assertThat(pojo4, notNullValue())
            assertThat(pojo4, not(sameInstance(pojo1)))
            assertThat(pojo4, not(sameInstance(pojo3)))

            val pojo5 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.TWO_WAY, null).process()
            assertThat(pojo5, sameInstance(pojo4))

            val type = invocation.context.COMMON_TYPES.STRING
            val mockElement = mock(XVariableElement::class.java)
            doReturn(type).`when`(mockElement).type
            val fakeField = Field(
                    element = mockElement,
                    name = "foo",
                    type = type,
                    affinity = SQLTypeAffinity.TEXT,
                    columnName = "foo",
                    parent = null,
                    indexed = false
            )
            val fakeEmbedded = EmbeddedField(fakeField, "", null)

            val pojo6 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.TWO_WAY, fakeEmbedded).process()
            assertThat(pojo6, notNullValue())
            assertThat(pojo6, not(sameInstance(pojo1)))
            assertThat(pojo6, not(sameInstance(pojo3)))
            assertThat(pojo6, not(sameInstance(pojo4)))

            val pojo7 = PojoProcessor.createFor(invocation.context, element,
                    FieldProcessor.BindingScope.TWO_WAY, fakeEmbedded).process()
            assertThat(pojo7, sameInstance(pojo6))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_empty() {
        val pojoCode = """
            public String mName;
            """
        singleRun(pojoCode) { pojo ->
            assertThat(pojo.constructor, notNullValue())
            assertThat(pojo.constructor?.params, `is`(emptyList()))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_ambiguous_twoFieldsExactMatch() {
        val pojoCode = """
            public String mName;
            public String _name;
            public MyPojo(String mName) {
            }
            """
        singleRun(pojoCode) { pojo ->
            val param = pojo.constructor?.params?.first()
            assertThat(param, instanceOf(Constructor.Param.FieldParam::class.java))
            assertThat((param as Constructor.Param.FieldParam).field.name, `is`("mName"))
            assertThat(pojo.fields.find { it.name == "mName" }?.setter?.callType,
                    `is`(CallType.CONSTRUCTOR))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_ambiguous_oneTypeMatches() {
        val pojoCode = """
            public String mName;
            public int _name;
            public MyPojo(String name) {
            }
            """
        singleRun(pojoCode) { pojo ->
            val param = pojo.constructor?.params?.first()
            assertThat(param, instanceOf(Constructor.Param.FieldParam::class.java))
            assertThat((param as Constructor.Param.FieldParam).field.name, `is`("mName"))
            assertThat(pojo.fields.find { it.name == "mName" }?.setter?.callType,
                    `is`(CallType.CONSTRUCTOR))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_ambiguous_twoFields() {
        val pojo = """
            String mName;
            String _name;
            public MyPojo(String name) {
            }
            """
        singleRun(pojo) { _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.ambigiousConstructor(MY_POJO.toString(),
                        "name", listOf("mName", "_name"))
        )
    }

    @Test
    fun constructor_noMatchBadType() {
        singleRun("""
            int foo;
            public MyPojo(String foo) {
            }
        """) { _ ->
        }.failsToCompile().withErrorContaining(ProcessorErrors.MISSING_POJO_CONSTRUCTOR)
    }

    @Test
    fun constructor_noMatch() {
        singleRun("""
            String mName;
            String _name;
            public MyPojo(String foo) {
            }
        """) { _ ->
        }.failsToCompile().withErrorContaining(ProcessorErrors.MISSING_POJO_CONSTRUCTOR)
    }

    @Test
    fun constructor_noMatchMultiArg() {
        singleRun("""
            String mName;
            int bar;
            public MyPojo(String foo, String name) {
            }
        """) { _ ->
        }.failsToCompile().withErrorContaining(ProcessorErrors.MISSING_POJO_CONSTRUCTOR)
    }

    @Test
    fun constructor_multipleMatching() {
        singleRun("""
            String mName;
            String mLastName;
            public MyPojo(String name) {
            }
            public MyPojo(String name, String lastName) {
            }
        """) { _ ->
        }.failsToCompile().withErrorContaining(ProcessorErrors.TOO_MANY_POJO_CONSTRUCTORS)
    }

    @Test
    fun constructor_multipleMatchingWithIgnored() {
        singleRun("""
            String mName;
            String mLastName;
            @Ignore
            public MyPojo(String name) {
            }
            public MyPojo(String name, String lastName) {
            }
        """) { pojo ->
            assertThat(pojo.constructor, notNullValue())
            assertThat(pojo.constructor?.params?.size, `is`(2))
            assertThat(pojo.fields.find { it.name == "mName" }?.setter?.callType,
                    `is`(CallType.CONSTRUCTOR))
            assertThat(pojo.fields.find { it.name == "mLastName" }?.setter?.callType,
                    `is`(CallType.CONSTRUCTOR))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_dontTryForBindToScope() {
        singleRun("""
            String mName;
            String mLastName;
        """) { _, invocation ->
            val process2 = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.BIND_TO_STMT,
                    parent = null).process()
            assertThat(process2.constructor, nullValue())
        }.compilesWithoutError()
    }

    @Test
    fun constructor_bindForTwoWay() {
        singleRun("""
            String mName;
            String mLastName;
        """) { _, invocation ->
            val process2 = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.TWO_WAY,
                    parent = null).process()
            assertThat(process2.constructor, notNullValue())
        }.compilesWithoutError()
    }

    @Test
    fun constructor_multipleMatching_withNoArg() {
        singleRun("""
            String mName;
            String mLastName;
            public MyPojo() {
            }
            public MyPojo(String name, String lastName) {
            }
        """) { pojo ->
            assertThat(pojo.constructor?.params?.size ?: -1, `is`(0))
        }.compilesWithoutError().withWarningContaining(
                ProcessorErrors.TOO_MANY_POJO_CONSTRUCTORS_CHOOSING_NO_ARG)
    }

    @Test // added for b/69562125
    fun constructor_withNullabilityAnnotation() {
        singleRun("""
            String mName;
            public MyPojo(@androidx.annotation.NonNull String name) {}
            """) { pojo ->
            val constructor = pojo.constructor
            assertThat(constructor, notNullValue())
            assertThat(constructor!!.params.size, `is`(1))
        }.compilesWithoutError()
    }

    @Test
    fun constructor_relationParameter() {
        singleRun("""
            @Relation(entity = foo.bar.User.class, parentColumn = "uid", entityColumn="uid",
            projection = "name")
            public List<String> items;
            public String uid;
            public MyPojo(String uid, List<String> items) {
            }
            """, COMMON.USER) { _ ->
        }.compilesWithoutError()
    }

    @Test
    fun recursion_1Level_embedded() {
        singleRun(
                """
                @Embedded
                MyPojo myPojo;
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_1Level_relation() {
        singleRun(
                """
                long id;
                long parentId;
                @Relation(parentColumn = "id", entityColumn = "parentId")
                Set<MyPojo> children;
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_1Level_relation_specifyEntity() {
        singleRun(
                """
                @Embedded
                A a;

                static class A {
                    long id;
                    long parentId;
                    @Relation(entity = A.class, parentColumn = "id", entityColumn = "parentId")
                    Set<AWithB> children;
                }

                static class B {
                   long id;
                }

                static class AWithB {
                    @Embedded
                    A a;
                    @Embedded
                    B b;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo.A -> foo.bar.MyPojo.A"))
    }

    @Test
    fun recursion_2Levels_relationToEmbed() {
        singleRun(
                """
                int pojoId;

                @Relation(parentColumn = "pojoId", entityColumn = "entityId")
                List<MyEntity> myEntity;

                @Entity
                static class MyEntity {
                    int entityId;

                    @Embedded
                    MyPojo myPojo;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.MyEntity -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_2Levels_onlyEmbeds_pojoToEntity() {
        singleRun(
                """
                @Embedded
                A a;

                @Entity
                static class A {
                    @Embedded
                    MyPojo myPojo;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.A -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_2Levels_onlyEmbeds_onlyPojos() {
        singleRun(
                """
                @Embedded
                A a;
                static class A {
                    @Embedded
                    MyPojo myPojo;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.A -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_2Level_relationToEmbed() {
        singleRun(
                """
                @Embedded
                A a;

                static class A {
                    long id;
                    long parentId;
                    @Relation(parentColumn = "id", entityColumn = "parentId")
                    Set<AWithB> children;
                }

                static class B {
                   long id;
                }

                static class AWithB {
                    @Embedded
                    A a;
                    @Embedded
                    B b;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo.A -> foo.bar.MyPojo.AWithB -> foo.bar.MyPojo.A"))
    }

    @Test
    fun recursion_3Levels() {
        singleRun(
                """
                @Embedded
                A a;
                public static class A {
                    @Embedded
                    B b;
                }
                public static class B {
                    @Embedded
                    MyPojo myPojo;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.A -> foo.bar.MyPojo.B -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_1Level_1LevelDown() {
        singleRun(
                """
                @Embedded
                A a;
                static class A {
                    @Embedded
                    B b;
                }
                static class B {
                    @Embedded
                    A a;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo.A -> foo.bar.MyPojo.B -> foo.bar.MyPojo.A"))
    }

    @Test
    fun recursion_branchAtLevel0_afterBackTrack() {
        singleRun(
                """
                @PrimaryKey
                int id;
                @Embedded
                A a;
                @Embedded
                C c;
                static class A {
                    @Embedded
                    B b;
                }
                static class B {
                }
                static class C {
                    @Embedded
                    MyPojo myPojo;
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.C -> foo.bar.MyPojo"))
    }

    @Test
    fun recursion_branchAtLevel1_afterBackTrack() {
        singleRun(
                """
                @PrimaryKey
                int id;
                @Embedded
                A a;
                static class A {
                    @Embedded
                    B b;
                    @Embedded
                    MyPojo myPojo;
                }
                static class B {
                    @Embedded
                    C c;
                }
                static class C {
                }
                """) { _, _ ->
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.RECURSIVE_REFERENCE_DETECTED.format(
                        "foo.bar.MyPojo -> foo.bar.MyPojo.A -> foo.bar.MyPojo"))
    }

    @Test
    fun dataClass_primaryConstructor() {
        listOf(
                TestData.AllDefaultVals::class.java.canonicalName!!,
                TestData.AllDefaultVars::class.java.canonicalName!!,
                TestData.SomeDefaultVals::class.java.canonicalName!!,
                TestData.SomeDefaultVars::class.java.canonicalName!!,
                TestData.WithJvmOverloads::class.java.canonicalName!!
        ).forEach {
            simpleRun { invocation ->
                PojoProcessor.createFor(
                        context = invocation.context,
                        element = invocation.processingEnv.requireTypeElement(it),
                        bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                        parent = null
                ).process()
            }.compilesWithoutError().withWarningCount(0)
        }
    }

    @Test
    fun dataClass_withJvmOverloads_primaryConstructor() {
        simpleRun { invocation ->
            PojoProcessor.createFor(
                    context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(
                            TestData.WithJvmOverloads::class
                    ),
                    bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null
            ).process()
        }.compilesWithoutError().withWarningCount(0)
    }

    @Test
    fun ignoredColumns() {
        simpleRun(
                """
                package foo.bar;
                import androidx.room.*;

                @Entity(ignoredColumns = {"bar"})
                public class ${MY_POJO.simpleName()} {
                    public String foo;
                    public String bar;
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null).process()
            assertThat(pojo.fields.find { it.name == "foo" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "bar" }, nullValue())
        }.compilesWithoutError()
    }

    @Test
    fun ignoredColumns_noConstructor() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;

                @Entity(ignoredColumns = {"bar"})
                public class ${MY_POJO.simpleName()} {
                    private final String foo;
                    private final String bar;

                    public ${MY_POJO.simpleName()}(String foo) {
                      this.foo = foo;
                      this.bar = null;
                    }

                    public String getFoo() {
                      return this.foo;
                    }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null).process()
            assertThat(pojo.fields.find { it.name == "foo" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "bar" }, nullValue())
        }.compilesWithoutError()
    }

    @Test
    fun ignoredColumns_noSetterGetter() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;

                @Entity(ignoredColumns = {"bar"})
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public String getFoo() {
                      return this.foo;
                    }

                    public void setFoo(String foo) {
                      this.foo = foo;
                    }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                parent = null).process()
            assertThat(pojo.fields.find { it.name == "foo" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "bar" }, nullValue())
        }.compilesWithoutError()
    }

    @Test
    fun ignoredColumns_columnInfo() {
        simpleRun(
                """
                package foo.bar;
                import androidx.room.*;

                @Entity(ignoredColumns = {"my_bar"})
                public class ${MY_POJO.simpleName()} {
                    public String foo;
                    @ColumnInfo(name = "my_bar")
                    public String bar;
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null).process()
            assertThat(pojo.fields.find { it.name == "foo" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "bar" }, nullValue())
        }.compilesWithoutError()
    }

    @Test
    fun ignoredColumns_missing() {
        simpleRun(
                """
                package foo.bar;
                import androidx.room.*;

                @Entity(ignoredColumns = {"no_such_column"})
                public class ${MY_POJO.simpleName()} {
                    public String foo;
                    public String bar;
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            val pojo = PojoProcessor.createFor(context = invocation.context,
                    element = invocation.processingEnv.requireTypeElement(MY_POJO),
                    bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                    parent = null).process()
            assertThat(pojo.fields.find { it.name == "foo" }, notNullValue())
            assertThat(pojo.fields.find { it.name == "bar" }, notNullValue())
        }.failsToCompile().withErrorContaining(
                ProcessorErrors.missingIgnoredColumns(listOf("no_such_column")))
    }

    @Test
    fun noSetter_scopeBindStmt() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public String getFoo() { return foo; }
                    public String getBar() { return bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.BIND_TO_STMT,
                parent = null).process()
        }.compilesWithoutError()
    }

    @Test
    fun noSetter_scopeTwoWay() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public String getFoo() { return foo; }
                    public String getBar() { return bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.TWO_WAY,
                parent = null).process()
        }.failsToCompile().withErrorContaining("Cannot find setter for field.")
    }

    @Test
    fun noSetter_scopeReadFromCursor() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public String getFoo() { return foo; }
                    public String getBar() { return bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                parent = null).process()
        }.failsToCompile().withErrorContaining("Cannot find setter for field.")
    }

    @Test
    fun noGetter_scopeBindStmt() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public void setFoo(String foo) { this.foo = foo; }
                    public void setBar(String bar) { this.bar = bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.BIND_TO_STMT,
                parent = null).process()
        }.failsToCompile().withErrorContaining("Cannot find getter for field.")
    }

    @Test
    fun noGetter_scopeTwoWay() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public void setFoo(String foo) { this.foo = foo; }
                    public void setBar(String bar) { this.bar = bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.TWO_WAY,
                parent = null).process()
        }.failsToCompile().withErrorContaining("Cannot find getter for field.")
    }

    @Test
    fun noGetter_scopeReadCursor() {
        simpleRun(
            """
                package foo.bar;
                import androidx.room.*;
                public class ${MY_POJO.simpleName()} {
                    private String foo;
                    private String bar;

                    public void setFoo(String foo) { this.foo = foo; }
                    public void setBar(String bar) { this.bar = bar; }
                }
                """.toJFO(MY_POJO.toString())) { invocation ->
            PojoProcessor.createFor(context = invocation.context,
                element = invocation.processingEnv.requireTypeElement(MY_POJO),
                bindingScope = FieldProcessor.BindingScope.READ_FROM_CURSOR,
                parent = null).process()
        }.compilesWithoutError()
    }

    private fun singleRun(
        code: String,
        vararg jfos: JavaFileObject,
        handler: (Pojo) -> Unit
    ): CompileTester {
        return singleRun(code, *jfos) { pojo, _ ->
            handler(pojo)
        }
    }

    private fun singleRun(
        code: String,
        vararg jfos: JavaFileObject,
        classpathFiles: Set<File> = emptySet(),
        handler: (Pojo, TestInvocation) -> Unit
    ): CompileTester {
        val pojoCode = """
                $HEADER
                $code
                $FOOTER
                """
        return singleRunFullClass(
            code = pojoCode,
            jfos = *jfos,
            classpathFiles = classpathFiles,
            handler = handler
        )
    }

    private fun singleRunFullClass(
        code: String,
        vararg jfos: JavaFileObject,
        classpathFiles: Set<File> = emptySet(),
        handler: (Pojo, TestInvocation) -> Unit
    ): CompileTester {
        val pojoJFO = code.toJFO(MY_POJO.toString())
        val all = (jfos.toList() + pojoJFO).toTypedArray()
        return simpleRun(*all, classpathFiles = classpathFiles) { invocation ->
            handler.invoke(
                PojoProcessor.createFor(context = invocation.context,
                        element = invocation.processingEnv.requireTypeElement(MY_POJO),
                        bindingScope = FieldProcessor.BindingScope.TWO_WAY,
                        parent = null).process(),
                invocation
            )
        }
    }

    // Kotlin data classes to verify the PojoProcessor.
    private class TestData {
        data class AllDefaultVals(
            val name: String = "",
            val number: Int = 0,
            val bit: Boolean = false
        )

        data class AllDefaultVars(
            var name: String = "",
            var number: Int = 0,
            var bit: Boolean = false
        )

        data class SomeDefaultVals(
            val name: String,
            val number: Int = 0,
            val bit: Boolean
        )

        data class SomeDefaultVars(
            var name: String,
            var number: Int = 0,
            var bit: Boolean
        )

        data class WithJvmOverloads @JvmOverloads constructor(
            val name: String,
            val lastName: String = "",
            var number: Int = 0,
            var bit: Boolean
        )
    }
}