import org.gradle.workers.internal.WorkerDaemonClientsManager
            import org.gradle.internal.jvm.Jvm

            tasks.withType(JavaCompile) {
                options.forkOptions.memoryInitialSize = "128m"
                options.forkOptions.memoryMaximumSize = "256m"
                options.forkOptions.jvmArgs = ["-Dfoo=bar"]

                doLast {

        given:
        configuration.forkOptions { options ->
            options.minHeapSize = "128m"
            options.maxHeapSize = "128m"
            options.systemProperty("foo", "bar")
            options.jvmArgs("-foo")
            options.bootstrapClasspath("foo")
            options.debug = true
        }

        when:

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[PKCS1WithSHA256-1025]
	_ = x[PKCS1WithSHA384-1281]
	_ = x[PKCS1WithSHA512-1537]
	_ = x[PSSWithSHA256-2052]
	_ = x[PSSWithSHA384-2053]
	_ = x[PSSWithSHA512-2054]
	_ = x[ECDSAWithP256AndSHA256-1027]
	_ = x[ECDSAWithP384AndSHA384-1283]
	_ = x[ECDSAWithP521AndSHA512-1539]
	_ = x[Ed25519-2055]
	_ = x[PKCS1WithSHA1-513]
	_ = x[ECDSAWithSHA1-515]
}

		// So it may read up-to 192 bytes past end of p
		// We may add checks inside blockAVX2, but this will
		// just turn it into a copy of blockAMD64,
		// so call it directly, instead.
		safeLen := len(p) - 128
		if safeLen%128 != 0 {
			safeLen -= 64
		}
		blockAVX2(dig, p[:safeLen])
		blockAMD64(dig, p[safeLen:])
	} else {
		blockAMD64(dig, p)
	}

/**
 * This annotation is a marker and guarantees all integration tests are tagged.
 *
 * When we use JUnit Platform `includeTags('SomeTag')`, all spock tests are excluded:
 * https://github.com/spockframework/spock/issues/1288 . As a workaround,
 * we tag all non-spock integration tests and use `includeTags(none() | SomeTag)` to make
 * sure spock engine tests are executed.
 */
@Retention(RetentionPolicy.RUNTIME)

	}
	if alias.InexactOverlap(dst[:BlockSize], src[:BlockSize]) {
		panic("crypto/aes: invalid buffer overlap")
	}
	// The decrypt function code is equal to the function code + 128.
	cryptBlocks(c.function+128, &c.key[0], &dst[0], &src[0], BlockSize)
}

// expandKey is used by BenchmarkExpand. cipher message (KM) does not need key
// expansion so there is no assembly equivalent.

	_           [is64bit]int32 // Extra padding for 64-bit hosts only.

	// End of common part. Beginning of signal-specific part.

	Pid    int32
	Uid    uint32
	Status int32

	// Pad to 128 bytes.
	_ [128 - (6+is64bit)*4]byte
}

const (
	// Possible values for SiginfoChild.Code field.
	_CLD_EXITED    int32 = 1
	_CLD_KILLED          = 2
	_CLD_DUMPED          = 3
	_CLD_TRAPPED         = 4

import org.gradle.testing.junit.junit4.AbstractJUnit4LoggingOutputCaptureIntegrationTest

import static org.gradle.testing.fixture.JUnitCoverage.JUNIT_VINTAGE

// https://github.com/junit-team/junit5/issues/1285
@TargetCoverage({ JUNIT_VINTAGE })
class JUnitVintageLoggingOutputCaptureIntegrationTest extends AbstractJUnit4LoggingOutputCaptureIntegrationTest implements JUnitVintageMultiVersionTest {

func (f exprFlags) Addressable() bool     { return f&32 != 0 }
func (f exprFlags) Assignable() bool      { return f&64 != 0 }
func (f exprFlags) HasOk() bool           { return f&128 != 0 }
func (f exprFlags) IsRuntimeHelper() bool { return f&256 != 0 } // a runtime function called from transformed syntax

func (f *exprFlags) SetIsVoid()          { *f |= 1 }
func (f *exprFlags) SetIsType()          { *f |= 2 }

	// This avoids an unnecessary allocation of the aesCipher struct.
	c := aesCipherGCM{aesCipherAsm{aesCipher{l: uint8(len(key) + 28)}}}
	var rounds int
	switch len(key) {
	case 128 / 8:
		rounds = 10
	case 192 / 8:
		rounds = 12
	case 256 / 8:
		rounds = 14
	default:
		return nil, KeySizeError(len(key))
	}

	expandKeyAsm(rounds, &key[0], &c.enc[0], &c.dec[0])