)

        assertThat(
            subject.nextGroup(),
            equalTo(requestsInGroup1.reversed())
        )
    }

    @Test
    fun `#nextGroup honours timeout`() {

        val subject = ConcurrentGroupingQueue<Int> { false }

        val pushElementSignal = CountDownLatch(1)
        thread {

                |:a
                |\\--- :b
                |     \\--- :a (*)
                |
                |(*) - details omitted (listed previously)""".stripMargin()
        }
    }

    def "honours mustRunAfter task ordering"() {
        buildFile << """
            task a {
                mustRunAfter 'b'
            }
            task b
            task c(dependsOn: ['a', 'b'])
            task d

        when:
        fails("runInWorker")

        then:
        failureCauseContains('Setting the working directory of a worker is not supported')
    }

    def "interesting worker daemon fork options are honored"() {
        OptionsVerifier optionsVerifier = new OptionsVerifier(file('process.json'))
        optionsVerifier.with {
            minHeap("128m")
            maxHeap("128m")
            systemProperty("foo", "bar")

	"os"
	"path/filepath"
	"syscall"
)

func access(name string) error {
	_, err := os.Lstat(name)
	return err
}

func osMkdirAll(dirPath string, perm os.FileMode, _ string) error {
	// baseDir is not honored in windows platform
	return os.MkdirAll(dirPath, perm)
}

// readDirFn applies the fn() function on each entries at dirPath, doesn't recurse into

            blockingServer.expectConcurrent(":b:cPing")
            run ":a:aPing", ":b:cPing"
        }
    }

    def "explicit task dependency relationships are honored even if it violates destroys/creates/consumes relationships"() {
        given:
        withParallelThreads(2)

        buildFile << """
            def foo = file("foo")

This code of conduct outlines our expectations for participants, as well as steps to reporting
unacceptable behavior. We are committed to providing a welcoming and inspiring community for all and
expect our code of conduct to be honored.

Square’s open source community strives to:

 * **Be open**: We invite anyone to participate in any aspect of our projects. Our community is

import org.gradle.launcher.exec.BuildActionResult;

import java.io.InputStream;
import java.util.UUID;

public class SingleUseDaemonClient extends DaemonClient {
    public static final String MESSAGE = "To honour the JVM settings for this build a single-use Daemon process will be forked.";
    private static final Logger LOGGER = Logging.getLogger(SingleUseDaemonClient.class);
    private final DocumentationRegistry documentationRegistry;

}

// TCPOptions specify customizable TCP optimizations on raw socket
type TCPOptions struct {
	UserTimeout int // this value is expected to be in milliseconds

	// When the net.Conn is a remote drive this value is honored, we close the connection to remote peer proactively.
	DriveOPTimeout func() time.Duration

	SendBufSize int              // SO_SNDBUF size for the socket connection, NOTE: this sets server and client connection

			// Windows can have both isSysErrNotDir(err) and osIsNotExist(err) returning
			// true if the source file path contains an non-existent directory. In that case,
			// we want to return errFileNotFound instead, which will honored in subsequent
			// switch cases
			return errFileAccessDenied
		case isSysErrPathNotFound(err):
			// This is a special case should be handled only for
			// windows, because windows API does not return "not a

					{"planet", "mars"}: ptr.To[int64](0),
				},
				TopologyNormalizingWeight: []float64{topologyNormalizingWeight(1)},
			},
		},
		{
			name: "NodeAffinityPolicy honored with labelSelectors",
			pod: st.MakePod().Name("p").Label("foo", "").
				NodeSelector(map[string]string{"foo": ""}).
				SpreadConstraint(1, "zone", v1.ScheduleAnyway, barSelector, nil, nil, nil, nil).
				Obj(),