void apply(Project project) {
        project.tasks.register("license", LicenseTask) { task ->
            task.setDescription("add a license header to source code")  // Add description
            task.setGroup("from license plugin")                        // Add group
        }
    }
}
----
=====

== Step 2. Add a license.txt file

            args[0].execute(repo3Content)
        }
        1 * repo3Content.excludeVersionByRegex("com.mycompany","core", "1.0")
        0 * _
    }

    def "can include module by group and subgroups exclusively"() {
        given:
        def repo1 = Mock(TestMavenArtifactRepository) { getName() >> "Maven repo 1" }
        def repo2 = Mock(TestMavenArtifactRepository) { getName() >> "Maven repo 2" }

        project.getTasks().register(TASK_RUN_NAME, JavaExec.class, run -> {
            run.setDescription("Runs this project as a JVM application");
            run.setGroup(APPLICATION_GROUP);

            FileCollection runtimeClasspath = project.files().from((Callable<FileCollection>) () -> {
                if (run.getMainModule().isPresent()) {

            // TODO: Replace with native test task
            final TaskProvider<RunTestExecutable> testTask = tasks.register(binary.getNames().getTaskName("run"), RunTestExecutable.class, task -> {
                task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
                task.setDescription("Executes C++ unit tests.");

                final InstallExecutable installTask = binary.getInstallTask().get();

                return;
            }
            TaskInternal binaryLifecycleTask = taskInstantiator.create(binary.getNamingScheme().getTaskName("check"), DefaultTask.class);
            binaryLifecycleTask.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
            binaryLifecycleTask.setDescription("Check " + binary);
            binary.setCheckTask(binaryLifecycleTask);
        }

        @Finalize

	const defaultDistance = 4

	aGroup := uint(regionToGroups[a]) << 1
	bGroup := uint(regionToGroups[b]) << 1
	for _, ri := range matchRegion {
		if language.Language(ri.lang) == lang && (ri.script == 0 || language.Script(ri.script) == script) {
			group := uint(1 << (ri.group &^ 0x80))
			if 0x80&ri.group == 0 {
				if aGroup&bGroup&group != 0 { // Both regions are in the group.

    Arg<TF_Int32Tensor, [{An int32 tensor with shape
[num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
replica ids in the ith subgroup.}]>:$group_assignment,

    I64Attr:$concat_dimension,
    I64Attr:$split_dimension,
    I64Attr:$split_count
  );

  let results = (outs

    override fun relativeProjectPath(path: String): String =
        delegate.relativeProjectPath(path)

    override fun getPluginManager(): PluginManager =
        delegate.pluginManager

    override fun setGroup(group: Any) {
        delegate.group = group
    }

    override fun fileTree(baseDir: Any): ConfigurableFileTree =
        delegate.fileTree(baseDir)

            // Create test suite test task
            TaskProvider<XCTest> testingTask = project.getTasks().register("xcTest", XCTest.class, task -> {
                task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
                task.setDescription("Executes XCTest suites");
                task.getTestInstallDirectory().set(binary.getInstallDirectory());

            return tasks.register(jarTaskName, Jar.class, jar -> {
                jar.setDescription("Assembles a jar archive containing the classes of the '" + name + "' feature.");
                jar.setGroup(BasePlugin.BUILD_GROUP);
                jar.from(sourceSet.getOutput());
                if (!capabilities.isEmpty()) {
                    jar.getArchiveClassifier().set(TextUtil.camelToKebabCase(name));
                }