}

    private static class HelpAction implements Action<Help> {
        @Override
        public void execute(Help task) {
            task.setDescription("Displays a help message.");
            task.setGroup(HELP_GROUP);
            task.setImpliesSubProjects(true);
        }
    }

    private static class ProjectReportTaskAction implements Action<ProjectReportTask> {
        private final String project;

import javax.inject.Inject

apply plugin: CustomPlugin

class CustomModel implements Serializable {
    String getValue() { 'greetings' }
    Set<CustomThing> getThings() { return [new CustomThing()] }
    Map<String, CustomThing> getThingsByName() { return [thing: new CustomThing()] }
}
class CustomThing implements Serializable {
}
class CustomBuilder implements ToolingModelBuilder {
    boolean canBuild(String modelName) {

|Java
|Binary plugin
|an abstract class that implements the `apply(Project project)` method of the `Plugin<Project>` interface in Java.
|Yes

|6
|Kotlin / Kotlin DSL
|Binary plugin
|an abstract class that implements the `apply(Project project)` method of the `Plugin<Project>` interface in Kotlin and/or Kotlin DSL.
|Yes

|7
|Groovy / Groovy DSL
|Binary plugin

                    return parameterValue;
                }
            }

            class DefaultCustomModel2 implements Serializable {
                String getValue() {
                    return "myValue";
                }
            }

            class CustomPlugin implements Plugin<Project> {
                @Inject
                CustomPlugin(ToolingModelBuilderRegistry registry) {

}

// ConvertToType implements ref.Val.ConvertToType.
func (d URL) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case typeValue:
		return d
	case types.TypeType:
		return typeValue
	}
	return types.NewErr("type conversion error from '%s' to '%s'", typeValue, typeVal)
}

// Equal implements ref.Val.Equal.
func (d URL) Equal(other ref.Val) ref.Val {

            include "a"
            include "b"
        """
        buildFile """
            class Plugin1 implements Plugin {
                void apply(project) {
                    project.rootProject.project(":b").apply(plugin: Plugin2)
                }
            }
            class Plugin2 implements Plugin {
                void apply(project) {

                }
            }

	}
	return out
}

// deriveSecret implements Derive-Secret from RFC 8446, Section 7.1.
func (c *cipherSuiteTLS13) deriveSecret(secret []byte, label string, transcript hash.Hash) []byte {
	if transcript == nil {
		transcript = c.hash.New()
	}
	return c.expandLabel(secret, label, transcript.Sum(nil), c.hash.Size())
}

// extract implements HKDF-Extract with the cipher suite hash.

}

class TestR22Connection extends TestR21Connection implements StoppableConnection {
    @Override
    void shutdown(ShutdownParameters parameters) {
        throw new UnsupportedOperationException()
    }

    ConnectionMetaDataVersion1 getMetaData() {
        return new TestMetaData('2.2')
    }
}

class TestR21Connection extends TestR12Connection implements InternalCancellableConnection {
    @Override

}

// ConvertToType implements ref.Val.ConvertToType.
func (d IP) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case IPType:
		return d
	case types.TypeType:
		return IPType
	case types.StringType:
		return types.String(d.Addr.String())
	}
	return types.NewErr("type conversion error from '%s' to '%s'", IPType, typeVal)
}

// Equal implements ref.Val.Equal.

// RouteMetrics represents route metrics.
type RouteMetrics struct {
	PathMTU int // path maximum transmission unit
}

// SysType implements the SysType method of Sys interface.
func (rmx *RouteMetrics) SysType() SysType { return SysMetrics }

// Sys implements the Sys method of Message interface.
func (m *RouteMessage) Sys() []Sys {
	return []Sys{
		&RouteMetrics{