// argument to errorCheck as it does double duty as both a
		// string that appears in the output, and as file name
		// openable relative to the test directory, containing text
		// expectations.
		//
		// So, we munge the file.
		stderr = strings.ReplaceAll(stderr, filepath.FromSlash("./rangeloop.go"), filename)

		if err := errorCheck(stderr, false, filename, filepath.Base(filename)); err != nil {

type ListenersTest struct {
	// Match listener by name
	Name string
	// Match listener by port
	Port uint32

	// Listener assertions
	Listener ListenerTest
}

// ListenerTest provides a struct for defining expectations for a listener
type ListenerTest struct {
	// Assert the listener contains these filter chains (in order, if TotalMatch)
	FilterChains []FilterChainTest

	var podUID string = string(pod.ObjectMeta.UID)
	ipProto := uint8(unix.IPPROTO_TCP)
	ctx, cancel := context.WithCancel(context.Background())
	fixture := getTestFixure(ctx)
	defer cancel()
	setupLogging()

	// expectations
	fixture.ipsetDeps.On("addIP",
		"foo-v4",
		netip.MustParseAddr("3.3.3.3"),
		ipProto,
		podUID,
		false,
	).Return(nil)

	fixture.ipsetDeps.On("addIP",
		"foo-v4",

  // TODO(griffithjames): Exactly match these explanations.
  //
  // When the OSS build has been updated to include the new error messages, the
  // Explain() expectations can be exact strings again.
  {
    const std::string explanation =
        Explain(placeholder_c.node(), NodeWith(CtrlDeps()));
    EXPECT_NE(explanation.find("ctrl_deps, which has 2 elements"),

            request2.release()
        }
        server.stop()

        then:
        instant.aDone > instant.aBlocked
        instant.bDone > instant.bBlocked
    }

    def "can chain expectations"() {
        given:
        server.expectConcurrent("a", "b")
        server.expect("c")
        def handle = server.expectConcurrentAndBlock(2, "d", "e")
        server.expect("f")
        server.start()

    private final static Logger logger = LoggerFactory.getLogger(HttpServer.class)

    protected Matcher expectedUserAgent = null

    List<ServerExpectation> expectations = []

    boolean chunkedTransfer = false

    org.gradle.api.Action<HttpServletRequest> beforeHandle
    org.gradle.api.Action<HttpServletRequest> afterHandle

    enum SupportedHash {

        when:
        fails ':checkDeps'

        then:
        errorOutput.contains("Plugin [id: 'org.gradle.repo-conventions'] was not found in any of the following sources")

        // real expectations below

        /*
        when:
        repositoryInteractions {
            'org:from-buildsrc:1.0' {
                expectResolve()
            }
            'org:from-main-build:1.0' {

In a few lines of code, it is possible to run an analyzer on a package
of testdata files and check that it reported all the expected
diagnostics and facts (and no more). Expectations are expressed using
"// want ..." comments in the input code.

# Standalone commands

Analyzers are provided in the form of packages that a driver program is

		// Job managedBy field let's the Job object be controlled by external
		// controllers. We want to make sure the transitions done by the external
		// controllers meet the expectations of the clients of the Job API.
		// For example, we verify that a Job in terminal state (Failed or Complete)
		// does not flip to a non-terminal state.
		//

		schemaGenerator func(maxLength *int64) *schema.Structural
		setMaxElements  int64

		// calc costs expectations are checked against the generated schema without any max element limits set
		expectedCalcCost           uint64
		expectCalcCostExceedsLimit uint64

		// calc costs expectations are checked against the generated schema with max element limits set
		expectedSetCost             uint64