context.setBaseResource(Resource.newResource(repoDir.getAbsolutePath()))
        context
    }

    void startServer() {
        try {
            serverPort = AvailablePortFinder.getNextAvailable(5000)
            server = new Server(serverPort)
            WebAppContext context = createContext()
            context.setContextPath("/")
            context.setBaseResource(Resource.newResource(repoDir.getAbsolutePath()))

	// We only consider PipeName as regular windows path, while the pipe path components are fixed, hence we use constants.
	serverPart := `\\.`
	pipePart := "pipe"
	pipeName := "kubelet-" + podResourcesDir
	return npipeProtocol + "://" + filepath.Join(serverPart, pipePart, pipeName), nil
}

var tickCount = syscall.NewLazyDLL("kernel32.dll").NewProc("GetTickCount64")

    }

    def "merge exclude rules"() {
        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']
        runner.args = ['-PuseHttp', "-PhttpPort=${serverPort}", "-Dorg.gradle.parallel=false"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

        cleanup:
        stopServer()
    }

        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']
        runner.args = ['-I', 'init.gradle', "-PmirrorPath=${repoDir.absolutePath}", "-PmavenRepoURL=http://127.0.0.1:${serverPort}/", "-Dorg.gradle.parallel=false"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

        cleanup:
        stopServer()
    }

				return errors.New(`--output must be 'yaml' or 'json'`)
			}

			version.ClientVersion = &Info

			if options.GetRemoteVersion != nil && remote {
				remoteVersion, serverErr = options.GetRemoteVersion()
				if serverErr != nil {
					return serverErr
				}
				version.MeshVersion = remoteVersion
			}
			if options.GetProxyVersions != nil && remote {
				version.DataPlaneVersion, _ = options.GetProxyVersions()
			}

  val client =
    OkHttpClient.Builder()
      .trustMockServer()
      .build()

  @Test
  fun testRequest() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request().withPath("/person")
            .withQueryStringParameter("name", "peter"),
        )

		serverConfig.ClientAuth = RequireAndVerifyClientCert

		_, serverErr := boringHandshake(t, clientConfig, serverConfig)

		if (serverErr == nil) == ok {
			if ok {
				t.Logf("%s: accept", desc)
			} else {
				t.Logf("%s: reject", desc)
			}
		} else {
			if ok {
				t.Errorf("%s: BAD reject (%v)", desc, serverErr)
			} else {
				t.Errorf("%s: BAD accept", desc)
			}
		}
	}

  @Container
  val socks5Proxy =
    GenericContainer(SOCKS5_PROXY)
      .withNetwork(network)
      .withExposedPorts(1080)

  @Test
  fun testLocal() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request().withPath("/person")
            .withQueryStringParameter("name", "peter"),
        )

        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']
        runner.args = ['-PuseHttp', "-PhttpPort=${serverPort}", '-PnoExcludes']
        if (parallel) {
            runner.args += '--parallel'
        }
        if (locking) {
            runner.args += '-PuseLocking'
        }

        when:

        ]
      },
      "initialDelaySeconds": {{ liveness_probe_initial_delay }},
      "timeoutSeconds": 15,
      "periodSeconds": 5,
      "failureThreshold": 5
    },
    "ports": [
      { "name": "serverport",
        "containerPort": {{ server_port }},
        "hostPort": {{ server_port }}
      },
      { "name": "clientport",
        "containerPort": {{ port }},
        "hostPort": {{ port }}
      }
        ],