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());
        });
    }

        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
    }

}

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

 * public abstract class MyWorkAction implements WorkAction<WorkParameters.None> {
 *     private final String greeting;
 *
 *     {@literal @}Inject
 *     public MyWorkAction() {
 *         this.greeting = "hello";
 *     }
 *
 *     {@literal @}Override
 *     public void execute() {
 *         System.out.println(greeting);
 *     }
 * }
 * </pre>
 *
 * Implementations of WorkAction are subject to the following constraints:

This sample shows how to build a Gradle plugin in the Java language.

====
include::sample[dir="kotlin",files="greeting-plugin/build.gradle.kts[tags=plugin]"]
include::sample[dir="groovy",files="greeting-plugin/build.gradle[tags=plugin]"]
====

For a more guided tour with plugin development, see link:https://gradle.org/guides/?q=Plugin%20Development[the guides for plugin development].

                objects.named(GradlePluginApiVersion, '7.0'))
        }
    }
}
// end::consume-plugin-variant[]

gradlePlugin {
    plugins.create('greeting') {
        id = 'org.example.greeting'
        implementationClass = 'org.example.GreetingPlugin'
    }
}

publishing {
    repositories {
        maven { url = layout.buildDirectory.dir('local-repo') }
    }

                objects.named("7.0"))
        }
    }
}
// end::consume-plugin-variant[]

gradlePlugin {
    plugins.create("greeting") {
        id = "org.example.greeting"
        implementationClass = "org.example.GreetingPlugin"
    }
}

publishing {
    repositories {
        maven { url = uri(layout.buildDirectory.dir("local-repo")) }
    }

        writeString(new File(projectDir, "settings.gradle"), "");
        writeString(new File(projectDir, "build.gradle"),
            "plugins {" +
                "  id('com.example.plugin.greeting')" +
                "}");

        // Run the build
        BuildResult result = GradleRunner.create()
            .forwardOutput()
            .withPluginClasspath()
            .withArguments("greet")