return this;
    }

    public SuggestRequestBuilder addField(final String field) {
        request.addField(field);
        return this;
    }

    public SuggestRequestBuilder addKind(final String kind) {
        request.addKind(kind);
        return this;
    }

    public SuggestRequestBuilder setSuggestDetail(final boolean suggestDetail) {
        request.setSuggestDetail(suggestDetail);
        return this;
    }

                builder.addTag(key);
            }

            builder.addKind(SuggestItem.Kind.USER.toString());
            if (ComponentUtil.getFessConfig().isSuggestSearchLog()) {
                builder.addKind(SuggestItem.Kind.QUERY.toString());
            }
            if (ComponentUtil.getFessConfig().isSuggestDocuments()) {
                builder.addKind(SuggestItem.Kind.DOCUMENT.toString());
            }

    }

    public void addRole(final String role) {
        this.roles.add(role);
    }

    public void addField(final String field) {
        this.fields.add(field);
    }

    public void addKind(final String kind) {
        this.kinds.add(kind);
    }

    public void setSuggestDetail(final boolean suggestDetail) {
        this.suggestDetail = suggestDetail;
    }

        assertEquals(1, response.getNum());
        assertEquals("全文 検索", response.getWords().get(0));

        response = suggester.suggest().addKind("query").execute().getResponse();
        assertEquals(1, response.getNum());

        SuggestResponse response2 = suggester.suggest().setSuggestDetail(true).execute().getResponse();

    }

    abstract class ReceiverOne {
        @Adding
        abstract fun adding(receiver: ReceiverOne.() -> Unit): ReceiverOne
    }

    abstract class ReceiverTwo {
        @Adding
        abstract fun adding(receiver: ReceiverTwo.() -> Unit)
    }

    abstract class ReceiverThree {
        @Adding
        abstract fun adding(three: Int)
    }

        @Override
        Builder printArguments() {
            return addLine('echo "$*"')
        }

        @Override
        Builder printText(String text) {
            return addLine("echo '$text'")
        }

        @Override
        Builder printEnvironmentVariable(String variableName) {
            return addLine("echo $variableName=\$$variableName")
        }

        @Override

        assertTrue { result.configuredLazy.isInitialized() }
    }

    @Test
    fun `empty adding block ensures that the object is created`() {
        val resolution = schema.resolve(
            """
            adding()
            adding { }
            adding { x = 2 }
            addingWithArg(3)
            addingWithArg(4) { }
            """.trimIndent()
        )

        )
    }


    @Test
    fun `underlay adding blocks appear before overlay ones`() {
        val underlay = resolvedDocument(
            """
            adding(1) {
                a = 1
            }
            """.trimIndent()
        )

        val overlay = resolvedDocument(
            """
            adding(1) {
                b = 2
            }

        buildFile << '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"
                p.afterEvaluate {
                    println "[1] afterEvaluate $p.name"
                }
            }

            project(':a') {
                println "[2] Adding evaluationDependsOn"
                evaluationDependsOn(':b')
            }

            allprojects { p ->

        val addedObjects = mutableListOf<AddedObject>()

        @Adding
        @Suppress("unused")
        fun addSomething(x: Int, configure: AddedObject.() -> Unit): AddedObject =
            AddedObject("addSomething($x) { ... }")
                .also(configure)
                .also(addedObjects::add)

        @Adding
        fun addSomething(x: Int): AddedObject =
            AddedObject("addSomething($x)")