setupProject(newLocation)

        when:
        inDirectory(originalLocation)
        withBuildCache().run compileTask(buildType)

        then:
        executedAndNotSkipped allCompileTasks

        when:
        originalLocation.deleteDir()
        executer.beforeExecute {
            inDirectory(newLocation)
        }

        run 'clean'

	"go/ast"
	"reflect"
	"testing"
	"time"

	"gorm.io/gorm/utils"
)

func AssertObjEqual(t *testing.T, r, e interface{}, names ...string) {
	for _, name := range names {
		rv := reflect.Indirect(reflect.ValueOf(r))
		ev := reflect.Indirect(reflect.ValueOf(e))
		if rv.IsValid() != ev.IsValid() {
			t.Errorf("%v: expect: %+v, got %+v", utils.FileWithLineNum(), r, e)
			return
		}
		got := rv.FieldByName(name).Interface()

written by hand

-- .mod --
module patch.example.com/direct

require (
	patch.example.com/indirect v1.0.0
)
-- .info --
{"Version":"v1.1.0"}
-- go.mod --
module patch.example.com/direct

require (
	patch.example.com/indirect v1.0.0
)
-- direct.go --
package direct

        def result1 = executer
            .inDirectory(temporaryFolder.testDirectory)
            .withTasks("help")
            .withTestConsoleAttached()
            .withConsole(console)
            .run()

        System.out.println("AFTER OUT")
        System.err.println("AFTER ERR")

        def result2 = executer
            .inDirectory(temporaryFolder.testDirectory)
            .withTasks("help")

          - pkg: github.com/golang/protobuf/jsonpb
            desc: "don't use the jsonpb package directly; use util/protomarshal instead"
          - pkg: google.golang.org/protobuf/encoding/protojson
            desc: "don't use the protojson package directly; use util/protomarshal instead"
          - pkg: gomodules.xyz/jsonpatch/v3
            desc: "don't use v3; v2 is orders of magnitude higher performance"

                }
            """
            settingsFile << """
                includeBuild("../includedBuild")
            """
        }
        executer.beforeExecute {
            inDirectory(consumer)
        }
        def expectedWatchableHierarchies = [
            ImmutableSet.of(consumer),
            ImmutableSet.of(consumer, includedBuild)
        ]

        when:

    @UsesSample("modelRules/modelDsl")
    def "dsl creation example works"() {
        when:
        inDirectory(sample.dir.file('groovy'))

        then:
        succeeds "hello"
        output.contains("Hello John Smith!")

        when:
        inDirectory(sample.dir.file('groovy'))

        then:
        succeeds "listPeople"
        output.contains("configuring Person 'people.john'")

You can also declare the `Response` parameter in dependencies, and set headers (and cookies) in them.

## Return a `Response` directly

You can also add headers when you return a `Response` directly.

Create a response as described in [Return a Response Directly](response-directly.md){.internal-link target=_blank} and pass the headers as an additional parameter:

```Python hl_lines="10-12"

                * **FastAPI** adds a reference here to the global JSON Schemas in another place in your OpenAPI instead of including it directly. This way, other applications and clients can use those JSON Schemas directly, provide better code generation tools, etc.

The generated responses in the OpenAPI for this *path operation* will be:

```JSON hl_lines="3-12"
{
    "responses": {

        def relocated = testDirectory.file("relocated")

        setupProjectIn(original)
        setupProjectIn(relocated)

        inDirectory(original)
        withBuildCache().run "broken"

        when:
        inDirectory(relocated)
        withBuildCache().run "broken"
        then:
        skipped ":broken"
    }

    private void setupProjectIn(TestFile dir) {