*
 * <pre class='autoTested'>
 * project.ext.set("myProp", "myValue")
 * assert project.myProp == "myValue"
 *
 * project.myProp = "anotherValue"
 * assert project.myProp == "anotherValue"
 * assert project.ext.get("myProp") == "anotherValue"
 * </pre>
 *
 * Extra properties extension objects support Groovy property syntax. That is, a property can be read via {@code extension.«name»} and set via

        if (!lockedState.get()) {
            owner.set(Thread.currentThread())
            lockedState.set(true)
            return true
        } else {
            return false
        }
    }

    @Override
    protected void releaseLock() {
        owner.set(null)
        lockedState.set(false)
    }

    boolean getLockedState() {
        return lockedState.get()
    }

                @get:Internal
                abstract val set: SetProperty<Int>
                @get:Internal
                abstract val map: MapProperty<Int, Boolean>

                @TaskAction
                fun run() {
                    println("flag = " + flag.get())
                    println("message = " + message.get())
                    println("number = " + number.get())
                    println("list = " + list.get())

                    def outFile = outputFile.get().asFile
                    outFile.parentFile.mkdirs()
                    outFile.text = archives.${archiveType}(inputFile.get().asFile).read().text
                }
            }

            tasks.register("myTask", MyTask) {
                inputFile.set(createArchive.flatMap { it.outputFile })
                outputFile.set(layout.buildDirectory.file("unpacked/file.txt"))

	Has(field string) (exists bool)

	// Get returns the value for the provided field.
	Get(field string) (value string)
}

// Set is a map of field:value. It implements Fields.
type Set map[string]string

// String returns all fields listed as a human readable string.
// Conveniently, exactly the format that ParseSelector takes.
func (ls Set) String() string {
	selector := make([]string, 0, len(ls))

                    System.out.println("list = " + list.get());
                    System.out.println("set = " + set.get());
                    System.out.println("map = " + map.get());
                }
            }
        """
    }

        resolveSession = componentProvider.get()
        deprecationResolver = componentProvider.get()
        callResolver = componentProvider.get()
        kotlinToResolvedCallTransformer = componentProvider.get()
        kotlinTypeRefiner = componentProvider.get()

        val builtIns = resolveSession!!.moduleDescriptor.builtIns
        val typeSpecificityComparator = componentProvider.get<TypeSpecificityComparator>()

	assert.Equal(t, s.Get(), nil)

	s.Set(ptr.Of("foo"))
	assert.Equal(t, s.Get(), ptr.Of("foo"))
	tt.WaitOrdered("add/foo")

	s.Set(nil)
	assert.Equal(t, s.Get(), nil)
	tt.WaitOrdered("delete/foo")

	s.Set(ptr.Of("bar"))
	assert.Equal(t, s.Get(), ptr.Of("bar"))
	tt.WaitOrdered("add/bar")

	s.Set(ptr.Of("bar2"))
	assert.Equal(t, s.Get(), ptr.Of("bar2"))
	tt.WaitOrdered("update/bar2")
}

    }

    @Override
    public T get(int index) {
        return mapper.apply(getter.get().get(index));
    }

    @Override
    public int size() {
        return getter.get().size();
    }

    @Override
    public boolean add(T t) {
        Objects.requireNonNull(t);
        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());

    return dep


@app.get("/directCookie")
def get_direct_cookie(dep: str = Depends(set_cookie)):
    return {"dep": dep}


@app.get("/indirectCookie")
def get_indirect_cookie(dep: str = Depends(set_indirect_cookie)):
    return {"dep": dep}


client = TestClient(app)


def test_cookie_is_set_once():
    direct_response = client.get("/directCookie")