*/
package gradlebuild.jvm.extension

import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*


/**
 * Strict compilation options honored by [gradlebuild.Strict_compile_gradle].
 */
abstract class StrictCompileExtension(val tasks: TaskContainer) {

    fun ignoreDeprecations() {
        tasks.withType<JavaCompile>().configureEach {

     *
     * <p>
     * IMPORTANT: the build service must be explicitly registered with every using task via {@link org.gradle.api.Task#usesService(Provider) Task#usesService}
     * for this constraint to be honored.
     * </p>
     *
     * @see org.gradle.api.Task#usesService(Provider)
     */
    Property<Integer> getMaxParallelUsages();

        when:
        configurationCacheRun 'help'

        then:
        file('.gradle/configuration-cache').isDirectory()
    }

    def "configuration cache honours --project-cache-dir"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'help', '--project-cache-dir', 'custom-cache-dir'

        then:

     *
     * <p>
     * IMPORTANT: the build service must be explicitly registered with every using task via {@link org.gradle.api.Task#usesService(Provider) Task#usesService}
     * for this constraint to be honored.
     * </p>
     *
     * @see org.gradle.api.Task#usesService(Provider)
     */
    Property<Integer> getMaxParallelUsages();

    /**

unfinished work which they who fought here have thus far so
nobly advanced.  It is rather for us to be here dedicated to
the great task remaining before us - that from these honored
dead we take increased devotion to that cause for which they
gave the last full measure of devotion -
  that we here highly resolve that these dead shall not have
died in vain - that this nation, under God, shall have a new

// (I am unsure if this test has any value since it only tests the fake implementation)
func TestSetGetLocalAddresses(t *testing.T) {
	fake := NewFakeNetlinkHandle(false)
	_ = ipvs.NetLinkHandle(fake) // Ensure that the interface is honored
	fake.SetLocalAddresses("eth0", "1.2.3.4")
	var expected, addr sets.Set[string]
	expected = sets.New("1.2.3.4")
	addr, _ = fake.GetLocalAddresses("eth0")
	if !addr.Equal(expected) {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "tooling api honours jvm args specified in gradle.properties"() {
        file('build.gradle') << """
assert java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.contains('-Xmx62m')
assert System.getProperty('some-prop') == 'some-value'

#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include "libcgo.h"

/*
 * Assumed POSIX compliant libc system call wrappers. For linux, the
 * glibc/nptl/setxid mechanism ensures that POSIX semantics are
 * honored for all pthreads (by default), and this in turn with cgo
 * ensures that all Go threads launched with cgo are kept in sync for
 * these function calls.
 */

// argset_t matches runtime/cgocall.go:argset.
typedef struct {

import org.gradle.internal.operations.RunnableBuildOperation
import org.gradle.internal.work.WorkerLeaseService

class MaxWorkersIntegrationTest extends AbstractIntegrationSpec {
    def "max workers is honored when it changes between invocations"() {
        buildFile << """
            import ${WorkerLeaseService.class.name}
            import ${BuildOperationExecutor.class.name}
            import ${RunnableBuildOperation.class.name}

        assert eclipseProject.projectDependencies.size() == 1
        with(eclipseProject.projectDependencies.first()) {
            it.path == 'b1'
        }
    }

    def "EclipseProject model honours custom project name"() {
        when:
        buildB.buildFile << """
            subprojects {
                apply plugin: 'eclipse'
                eclipse {