Class <org.gradle.api.DefaultTask> extends/implements org.gradle.api.internal.AbstractTask that is Gradle Internal API in (DefaultTask.java:0)
Class <org.gradle.api.ExtensiblePolymorphicDomainObjectContainer> extends/implements org.gradle.api.internal.rules.NamedDomainObjectFactoryRegistry that is Gradle Internal API in (ExtensiblePolymorphicDomainObjectContainer.java:0)

        @Override
        boolean isSatisfied() {
            return OperatingSystem.current().isWindows()
        }
    }

    static final class NotWindows implements TestPrecondition {
        @Override
        boolean isSatisfied() {
            return notSatisfied(Windows)
        }
    }

    static final class NotWindowsJavaBefore11 implements TestPrecondition {

class IntegTestPreconditions {

    static final class IsLongLivingProcess implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {
            return GradleContextualExecuter.isLongLivingProcess()
        }
    }

    static final class IsEmbeddedExecutor implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {

	name string
}

// Decrement implements Metric
func (dm *disabledMetric) Decrement() {}

// Increment implements Metric
func (dm *disabledMetric) Increment() {}

// Name implements Metric
func (dm *disabledMetric) Name() string {
	return dm.name
}

// Record implements Metric
func (dm *disabledMetric) Record(value float64) {}

// RecordInt implements Metric

}

// Implements reports whether type V implements interface T.
//
// The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated
// generic type.
func Implements(V Type, T *Interface) bool {
	if T.Empty() {
		// All types (even Typ[Invalid]) implement the empty interface.
		return true
	}
	// Checker.implements suppresses errors for invalid types, so we need special

}

// Implements reports whether type V implements interface T.
//
// The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated
// generic type.
func Implements(V Type, T *Interface) bool {
	if T.Empty() {
		// All types (even Typ[Invalid]) implement the empty interface.
		return true
	}
	// Checker.implements suppresses errors for invalid types, so we need special

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *StatusType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = StatusType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z StatusType) EncodeMsg(en *msgp.Writer) (err error) {

class ScriptApiTest {

    @Test
    fun `IDE build script template implements script api`() =
        assertScriptApiOf<KotlinProjectScriptTemplate>()

    @Test
    fun `IDE settings script template implements script api`() =
        assertScriptApiOf<KotlinSettingsScriptTemplate>()

    @Test
    fun `IDE init script template implements script api`() =
        assertScriptApiOf<KotlinGradleScriptTemplate>()

    @Test

package driver

import (
	"flag"
	"strings"
)

// GoFlags implements the plugin.FlagSet interface.
type GoFlags struct {
	UsageMsgs []string
}

// Bool implements the plugin.FlagSet interface.
func (*GoFlags) Bool(o string, d bool, c string) *bool {
	return flag.Bool(o, d, c)
}

// Int implements the plugin.FlagSet interface.
func (*GoFlags) Int(o string, d int, c string) *int {

// license that can be found in the LICENSE file.

// This file implements encoding/decoding of Ints.

package big

import (
	"bytes"
	"fmt"
)

// Gob codec version. Permits backward-compatible changes to the encoding.
const intGobVersion byte = 1

// GobEncode implements the [encoding/gob.GobEncoder] interface.
func (x *Int) GobEncode() ([]byte, error) {
	if x == nil {