`my-plugin`
            }
            """
        )

        build("clean")

        build("clean", "--rerun-tasks")
    }

    @Test
    fun `accessors are available after registering plugin`() {
        withSettings(
            """
            $defaultSettingsScript

            include("consumer", "producer")
            """
        )

        withBuildScript(

    }
}

val myReportTask by tasks.registering(MyReportTask::class) {
    outputFile = layout.buildDirectory.file("reports/my-report.pdf")
}

abstract class MyArchiveTask : DefaultTask() {
    @get:InputDirectory
    abstract val dirToArchive: DirectoryProperty
}

val archiveReportsTask by tasks.registering(MyArchiveTask::class) {
    dirToArchive = layout.buildDirectory.dir("toArchive")
}

// any sanitizer interceptors. This supports using the sanitizers
// with Go programs. The thread and memory sanitizers only apply to
// C/C++ code; this permits that code to see the Go runtime's existing signal
// handlers when registering new signal handlers for the process.

//go:cgo_import_static x_cgo_sigaction
//go:linkname x_cgo_sigaction x_cgo_sigaction
//go:linkname _cgo_sigaction _cgo_sigaction
var x_cgo_sigaction byte

plugins {
    java
}

version = "1.0.2"
group = "org.gradle.sample"

repositories {
    mavenCentral()
}

// tag::configure-type[]
testing {
    suites {
        val secondaryTest by registering(JvmTestSuite::class) {
            testType = TestSuiteType.INTEGRATION_TEST // <1>
        }
    }
}

import org.gradle.internal.service.scopes.AbstractGradleModuleServices;

/**
 * Service registration entry point for the Problems API.
 * <p>
 * This class is responsible registering all service providers for the Problems API.
 * See the {@code META-INF/services} directory to find the respective metadata file triggering the DI framework to load this class.
 */

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks a Settings plugin as registering one or more software types.
 *
 * @since 8.9
 */
@Incubating
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RegistersSoftwareTypes {
    /**

//}
import "C"

// CallMeBack call backs C code.
//
//export CallMeBack
func CallMeBack(callback C.callmeBackFunc) {
	C.bridgeCallback(callback)
}

// Dummy is called by the C code before registering the exception/continue handlers simulating a debugger.
// This makes sure that the Go runtime's lastcontinuehandler is reached before the C continue handler and thus,

                                        &BitcastOp_Delete);
    TF_RegisterKernelBuilder("BitcastOp", builder, status);
    CHECK_EQ(TF_OK, TF_GetCode(status))
        << "Error while registering bitcast kernel";
  }

#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
  {
    auto* builder = TF_NewKernelBuilder("Bitcast", tensorflow::DEVICE_GPU,

import gradlebuild.kotlindsl.generator.tasks.GenerateKotlinDslPluginsExtensions

plugins {
    java
}

val generatedSourcesDir = layout.buildDirectory.dir("generated-sources/kotlin")

val generateSources by tasks.registering(GenerateKotlinDslPluginsExtensions::class) {
    outputDir = generatedSourcesDir
    kotlinDslPluginsVersion = project.version
}

dependencies {
    api("com.google.guava:guava:30.1.1-jre") // <1>
    implementation("com.fasterxml.jackson.core:jackson-databind:2.13.3") // <2>
}

testing {
    suites {
        val integrationTest by registering(JvmTestSuite::class) {
            dependencies {
                implementation(project()) // <3>
            }
        }
    }
}