close(f.result)
		f.stopped = true
	}
}

func (f *FakeWatcher) IsStopped() bool {
	f.Lock()
	defer f.Unlock()
	return f.stopped
}

// Reset prepares the watcher to be reused.
func (f *FakeWatcher) Reset() {
	f.Lock()
	defer f.Unlock()
	f.stopped = false
	f.result = make(chan Event)
}

func (f *FakeWatcher) ResultChan() <-chan Event {
	return f.result
}

        val importedFromObjectData = (this as FirCallableDeclaration).importedFromObjectOrStaticData
            ?: errorWithAttachment("Declaration has ImportedFromObject origin, but no importedFromObjectData present") {
                withFirEntry("firToGetOrigin", this@ktSymbolOrigin)
            }

        importedFromObjectData.original.ktSymbolOrigin()
    }

    FirDeclarationOrigin.WrappedIntegerOperator -> {

    override fun markSupported(): Boolean = inputStream.markSupported()

    override fun mark(readlimit: Int) = inputStream.mark(readlimit)

    override fun reset() = inputStream.reset()

    override fun read(): Int = inputStream.read()

    override fun readChar(): Char = readContext.readInt().toChar()

    override fun readUnsignedByte(): Int = readByte().let {
        require(it >= 0)

			Description:    "An Object Lock configuration is present on this bucket, versioning cannot be suspended.",
			HTTPStatusCode: http.StatusBadRequest,
		}, r.URL)
		return
	}
	if rc, _ := getReplicationConfig(ctx, bucket); rc != nil && v.Suspended() {
		writeErrorResponse(ctx, w, APIError{
			Code:           "InvalidBucketState",
			Description:    "A replication configuration is present on this bucket, bucket wide versioning cannot be suspended.",

     * </p>
     * <p>Even if the given provider has no value, after this method is invoked,
     * the actual value of this property is guaranteed to be present.</p>
     *
     * @param provider The provider of an element
     */
    @Incubating
    void append(Provider<? extends T> provider);

    /**
     * Adds zero or more elements to the property value.
     *

 * over this visitor, since here we only mark a configuration observed if its metadata is present in the final graph.
 * There are likely scenarios that this visitor does not cover, where a configuration's metadata is observed but
 * its component is not present in the final graph.
 */
public class ResolvedLocalComponentsResultGraphVisitor implements DependencyGraphVisitor {

        def collection = fileCollectionFactory().fixed("foo", new File("foo.txt"))

        when:
        def executionTimeValue = collection.calculateExecutionTimeValue()

        then:
        executionTimeValue.present

        and:
        def newCollection = executionTimeValue.get().toFileCollection(fileCollectionFactory())

        then:
        newCollection.files == [new File("foo.txt")] as Set

            }
        """
    }

    def cleanup() {
        jdkRepository.stop()
    }

    def "current version does not use jdk provisioned by previous version"() {
        given:
        jdkRepository.reset()

        when:
        def result = version previous withGradleUserHomeDir userHome withTasks 'run' withArguments '-Porg.gradle.java.installations.auto-download=true' run()

        then:

        when:
        gitVcs.populate(target, repoHead, repoSpec)

        then:
        target.file( '.git').assertIsDir()
        target.file( 'submodule/foo.txt').text == "hello from submodule"
    }

    def 'reset a cloned repository with dirty working dir'() {
        given:
        def target = tmpDir.file('versionDir')
        gitVcs.populate(target, repoHead, repoSpec)

        def removed = target.file("source.txt")

	if err != nil {
		t.Fatalf("expected no error: %+v", err)
	}
	err = checkExistingKubeConfigFile(cfg, expectedKC)

	if err == nil {
		t.Fatalf("expected error, no kubeconfig present")
	}
}

func TestCheckMismatchedExistingKubeConfig(t *testing.T) {
	tmp := t.TempDir()
	os.WriteFile(filepath.Join(tmp, "token"), []byte(saToken), 0o644)
	tempDir := t.TempDir()