inputFuture.set(SLOW_OUTPUT_VALID_INPUT_DATA);
    outputFuture.cancel(true); // argument is ignored
    assertThrows(CancellationException.class, () -> resultFuture.get());
  }

  public void testAsyncToString() throws Exception {
    inputFuture.set(SLOW_OUTPUT_VALID_INPUT_DATA);
    assertThat(resultFuture.toString()).contains(outputFuture.toString());
  }

  public void testFutureCancelBeforeInputCompletion() throws Exception {

    public Set<Object> keySet() {
        return (Set) getter.get().keySet();
    }

    @Override
    public Collection<Object> values() {
        return (Collection) getter.get().values();
    }

    @Override
    public Set<Map.Entry<Object, Object>> entrySet() {
        return (Set) getter.get().entrySet();
    }

    @Override
    public synchronized boolean equals(Object o) {

        when:
        def result = cache.get()

        then:
        result == "bar"
        1 * fileAccess.readFile(!null) >> { it[0].get() }
    }

    def "can set value when file integrity is violated"() {
        given:
        def cache = createStateCache(createOnDemandFileLock(file))

        and:
        cache.set "a"

        expect:
        cache.get() == "a"

        when:

    var deprecatedProperty: Int = 0
        get() = field
        set(value) {
            field = value
        }

    @Deprecated("Deprecated function")
    fun deprecatedFunction() {

    }

    @get:Deprecated("Deprecated getter")
    @set:Deprecated("Deprecated setter")
    var deprecatedAccessors: Int = 1
        get() = field
        set(value) {
            field = value
        }
}

        get() = threadLocalExplicitAnalysisRestriction.get()
        set(value) = threadLocalExplicitAnalysisRestriction.set(value)

    override var isAnalysisAllowedOnEdt: Boolean
        get() = threadLocalAllowOnEdt.get()
        set(value) = threadLocalAllowOnEdt.set(value)

    override var isAnalysisAllowedInWriteAction: Boolean
        get() = threadLocalAllowInWriteAction.get()

        final Set<String> analyzerNames = analyzerMap.get(analyzerSettingsIndexName);
        final String analyzerName;
        if (StringUtil.isNotBlank(field) && fieldAnalyzerMapping.containsKey(field)
                && fieldAnalyzerMapping.get(field).readingAnalyzer != null) {
            analyzerName = fieldAnalyzerMapping.get(field).readingAnalyzer;
        } else {

plugins {
    id 'groovy'
}

repositories {
    mavenCentral()
}

// tag::set-prop[]
// Setting a property
def simpleMessageProperty = project.objects.property(String)
simpleMessageProperty.set("Hello, World from a Property!")
// Accessing a property
println(simpleMessageProperty.get())
// end::set-prop[]

// tag::set-prov[]
// Setting a provider

            return getObjectFactory().newInstance(ResolutionData.class, internalServices.get(), serializer.get(), typeRegistryCache.get());
        });
        return new ResolutionScope() {
            @Override
            public void setTypeHierarchyAnalysisResult(FileCollection analysisResult) {

        this.delegate = delegate;
    }

    @Override
    public E get(int index) {
        return delegate.get().get(index);
    }

    @Override
    public E set(int index, E element) {
        List<E> list = new ArrayList<>(delegate.get());
        E replaced = list.set(index, element);
        delegate.set(list);
        return replaced;
    }

    @Override
    public boolean add(E element) {

        return baseDirectory.dir("dir1").get()
    }

    @Override
    Directory someOtherValue() {
        return baseDirectory.dir("other1").get()
    }

    @Override
    Directory someOtherValue2() {
        return baseDirectory.dir("other2").get()
    }

    @Override
    Directory someOtherValue3() {
        return baseDirectory.dir("other3").get()
    }

    @Override