return file;
    }

    public void writeToFile(TestFile file) {
        if (file.exists()) {
            file.write("");
        }
        file.write(content);
    }

    public String withPath(String basePath) {
        return Joiner.on('/').join(basePath, path, name);
    }

	return &HTTPGetActionApplyConfiguration{}
}

// WithPath sets the Path field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Path field is set to the value of the last call.
func (b *HTTPGetActionApplyConfiguration) WithPath(value string) *HTTPGetActionApplyConfiguration {
	b.Path = &value
	return b

      .withExposedPorts(1080)

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

      val client =
        OkHttpClient.Builder()

        and:
        final projectFile = projectFile("very/deeply/nested/mainExe.vcxproj")
        assert projectFile.headerFiles == app.headerFiles*.withPath("../../../src/main").sort()
        assert projectFile.sourceFiles == ['../../../build.gradle'] + app.sourceFiles*.withPath("../../../src/main").sort()
        projectFile.projectConfigurations.values().each {

        return new Transform() {
            @Override
            public void applyChangesToProject(TestFile projectDir) {
                TestFile file = projectDir.file(beforeFile.withPath("src/" + sourceSetName));
                file.assertExists();

                file.write(afterFile.getContent());
            }

            @Override
            public List<SourceFile> getBeforeFiles() {

        passingTestFixture.writeToProject(testDirectory)
    }

    @Override
    protected void changeTestImplementation() {
        file(passingTestFixture.testSuites.first().sourceFile.withPath("src/test")) << """
            func test() -> Int32 { return 1; }
        """
    }

    @Override
    protected void assertTestCasesRan() {
        passingTestFixture.assertTestCasesRan(testExecutionResult)

		return nil
	}
	affinity := args.AddedAffinity
	var errs []error
	if ns := affinity.RequiredDuringSchedulingIgnoredDuringExecution; ns != nil {
		_, err := nodeaffinity.NewNodeSelector(ns, field.WithPath(path.Child("addedAffinity", "requiredDuringSchedulingIgnoredDuringExecution")))
		if err != nil {
			errs = append(errs, err)
		}
	}

        file("build/relocated").assertHasDescendants(objectFile("main").name, objectFile("other").name)
        mainObject.lastModified() == oldTimestamp

        when:
        assert file(otherFile.sourceFile.withPath("src/main")).delete()
        succeeds("unexport")
        then:
        assertMainSymbolIsNotExported(objectFile("build/relocated/main"))
        file("build/relocated").assertHasDescendants(objectFile("main").name)

  }

  @Test
  fun testHttpsRequest() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request().withPath("/person")
            .withQueryStringParameter("name", "peter"),
        )
        .respond(response().withBody("Peter the person!"))

      val results =
        (1..20).map {
          executor.submit {

    }

    private static List<String> sourceFiles(List<SourceFile> files, String path) {
        return files*.withPath(path).sort()
    }