project.getDependencies().add("loggerUsagePlugin", project.project(":test:logger-usage"));
        }
        TaskProvider<LoggerUsageTask> loggerUsage = project.getTasks().register("loggerUsageCheck", LoggerUsageTask.class);
        loggerUsage.configure(t -> t.setClasspath(loggerUsageConfig));
        return loggerUsage;
    }

	// Override the default Deflate compressor with a higher compression level.

	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Register a custom Deflate compressor.
	w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
		return flate.NewWriter(out, flate.BestCompression)
	})

	// Proceed to add files to w.

        final String url = System.getenv("SCA_URL");
        final String token = System.getenv("SCA_TOKEN");
        TaskProvider<DependenciesGraphTask> depsGraph = project.getTasks().register("dependenciesGraph", DependenciesGraphTask.class);
        depsGraph.configure(t -> {
            project.getPlugins().withType(JavaPlugin.class, p -> {

As part of the application object creation, a *path operation* for `/openapi.json` (or for whatever you set your `openapi_url`) is registered.

It just returns a JSON response with the result of the application's `.openapi()` method.

By default, what the method `.openapi()` does is check the property `.openapi_schema` to see if it has contents and return them.

	"database/sql"
	"slices"
	"testing"
)

// TestPostgreSQLRegistration checks if postgres driver
// is registered and fails otherwise.
func TestPostgreSQLRegistration(t *testing.T) {
	var found bool
	if slices.Contains(sql.Drivers(), "postgres") {
		found = true
	}
	if !found {
		t.Fatal("postgres driver not registered")
	}
}

func TestPsqlTableNameValidation(t *testing.T) {

        this.providerFactory = providerFactory;
    }

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        return project.getTasks().register(FORBIDDEN_PATTERNS_TASK_NAME, ForbiddenPatternsTask.class, forbiddenPatternsTask -> {
            forbiddenPatternsTask.getSourceFolders()
                .addAll(
                    providerFactory.provider(

	metricsRouter.Handle(prometheusMetricsV2ResourcePath, auth(metricsResourceHandler()))

	// Metrics v3
	metricsV3Server := newMetricsV3Server(auth)

	// Register metrics v3 handler. It also accepts an optional query
	// parameter `?list` - see handler for details.
	metricsRouter.Methods(http.MethodGet).Path(metricsV3Path + "{pathComps:.*}").Handler(metricsV3Server)

// If the host does not exist nil will be returned.
func (m *Manager) Connection(host string) *Connection {
	return m.targets[host]
}

// RegisterSingleHandler will register a stateless handler that serves
// []byte -> ([]byte, error) requests.
// subroutes are joined with "/" to a single subroute.
func (m *Manager) RegisterSingleHandler(id HandlerID, h SingleHandlerFn, subroute ...string) error {

    private val gradlePlugin: GradlePluginDevelopmentExtension
) {

    fun bundledGradlePlugin(name: String, shortDescription: String, pluginId: String, pluginClass: String) {
        gradlePlugin.plugins {
            register(name) {
                id = pluginId
                displayName = shortDescription
                description = shortDescription
                implementationClass = pluginClass
            }
        }
    }

 * limitations under the License.
 */

plugins {
    java
}

val validateTaskName = "validatePlugins"
val reportFileName = "task-properties/report.txt"

tasks.register<ValidatePlugins>(validateTaskName) {
    val main = project.sourceSets.main.get()
    classes.from(main.output)
    classpath.from(main.runtimeClasspath)
    outputFile = project.reporting.baseDirectory.file(reportFileName)