interface GreetingPluginExtension {
    Property<String> getMessage()
}

class GreetingPlugin implements Plugin<Project> {
    void apply(Project project) {
        // Add the 'greeting' extension object
        def extension = project.extensions.create('greeting', GreetingPluginExtension)
        extension.message.convention('Hello from GreetingPlugin')
        // Add a task that uses configuration from the extension object
        project.task('hello') {

        debugInstall.exec().out == app.withFeatureDisabled().expectedOutput
        debugInstall.assertIncludesLibraries("greeting")
        def debugLib = sharedLibrary(producer.file("build/lib/main/debug/shared/greeting"))
        sharedLibrary(consumer.file("build/install/main/debug/lib/greeting")).file.assertIsCopyOf(debugLib.file)

        when:
        executer.inDirectory(consumer)
        run("installRelease")

}

// MODULE: main(lib)
// FILE: main.kt
import org.jetbrains.kotlin.fir.plugin.MyComposable
import p3.setContent

fun test(): Int {
    return setContent {
        Greeting("test")
    }
}

@MyComposable
fun Greeting(name: String) {
    show("hi $name!")
}

        def extension = project.extensions.create('greeting', GreetingPluginExtension)
        project.task('hello') {
            doLast {
                println "${extension.message.get()} from ${extension.greeter.get()}"
            }
        }
    }
}

apply plugin: GreetingPlugin

// Configure the extension using a DSL block
greeting {
    message = 'Hi'
    greeter = 'Gradle'

    public void apply(Project project) {
        GreetingExtension extension = project.getExtensions().create("greeting", GreetingExtension.class);
        extension.getWho().convention("mate");
        TaskProvider<GreetingTask> task = project.getTasks().register("greeting", GreetingTask.class, t -> {
            t.getWho().convention(extension.getWho());
        });
    }

    public void apply(Project project) {
        GreetingExtension extension = project.getExtensions().create("greeting", GreetingExtension.class);
        extension.getWho().convention("mate");
        TaskProvider<GreetingTask> task = project.getTasks().register("greeting", GreetingTask.class, t -> {
            t.getWho().convention(extension.getWho());
        });
    }

}

dependencies {
    // Use JUnit test framework for unit tests
    testImplementation("junit:junit:4.13")
}

gradlePlugin {
    // Define the plugin
    val greeting by plugins.creating {
        id = "com.example.plugin.greeting"
        implementationClass = "com.example.plugin.GreetingPlugin"
    }
}
// end::plugin[]

// Add a source set and a task for a functional test suite

        privateHeader = ofFile(sourceFile("headers", "greeter_consts.h", """
#define GREETING "${HelloWorldApp.HELLO_WORLD}"
"""))

        source = ofFile(sourceFile("cpp", "greeter.cpp", """
#include <iostream>
#include "greeter.h"
#include "logger.h"
#include "greeter_consts.h"

void sayGreeting() {
    Logger logger;
    std::string str(GREETING);
    logger.log(str);
}
"""))
    }

    @Override

#define GREETING "${HelloWorldApp.HELLO_WORLD}"
"""))

    final SourceFileElement source = ofFile(new SourceFile("cpp", "greeter.cpp", """
#include <iostream>
#include <string>
#include "greeter.h"
#include "logger.h"
#include "greeter_consts.h"

void Greeter::sayHello() {
    Logger logger;
    std::string str(GREETING);
    logger.log(str);
}
"""))

        and:
        commonJvmFilesGenerated(scriptDsl)

        when:
        run("build")

        then:
        assertTestPassed("org.example.AppTest", "application has a greeting")

        when:
        run("run")

        then:
        outputContains("Hello World!")

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }