if tt.initial != nil {
				copied := *tt.initial
				initial = &copied
			} else {
				initial = nil
			}
			t.Run(fmt.Sprintf("%#v seed=%d", initial, seed), func(t *testing.T) {
				rand.Seed(seed)
				for i := 0; i < len(tt.want); i++ {
					got := initial.Step()
					t.Logf("[%d]=%s", i, got)
					if initial != nil && initial.Jitter > 0 {
						if got == tt.want[i] {

	if err := verifyPV(cache, oldPV.Name, oldPV); err != nil {
		t.Fatalf("Failed to GetPV() after initial update: %v", err)
	}

	// Restore PV
	cache.Restore(oldPV.Name)
	if err := verifyPV(cache, oldPV.Name, oldPV); err != nil {
		t.Fatalf("Failed to GetPV() after initial restore: %v", err)
	}

	// Assume newPV
	if err := cache.Assume(newPV); err != nil {

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |

    /**
     * Convenience method that sets descriptions and logs started() event.
     *
     * @param status The initial status message. Can be null or empty.
     * @return this logger instance
     */
    ProgressLogger start(String description, String status);

    /**
     * Logs the start of the operation, with no initial status.
     */
    void started();

    /**
     * Logs the start of the operation, with the given status.

of the website repository and remove the `doc/next` directory in this repository.

To begin the next release development cycle, populate the contents of `next`
with those of `initial`. From the repo root:

    > cd doc
    > cp -r initial/* next

        Try.successful(20).tryMap { (it + 10).toString() } == Try.successful('30')
    }

    def "flat map failure"() {
        def initial = Try.<Integer>failure(new RuntimeException("failed"))
        expect:
        initial.flatMap { it.toString() } == initial
    }

    def "failing flat map"() {
        def failure = new RuntimeException("failed")
        when:

            jar {
                from file("version")
            }
        """
        repo.workTree.file("settings.gradle") << """
            rootProject.name = "dep"
        """
        commits["initial"] = repo.commit('initial')

        def versionFile = repo.workTree.file("version")
        versions.each { version ->
            versionFile.text = version
            def commit = repo.commit("version is $version")

                from(GitVersionControlSpec) {
                    url = uri('${repoC.url}')
                }
            }
        """
        repoA.commit('initial version')

        def repoBSettingsFile = repoB.file("settings.gradle")
        repoBSettingsFile << """
            rootProject.name = 'testB'
            gradle.rootProject {

        """

        when:
        inputFile.text = "initial"
        runWithFileSystemWatchingAndMakeChangesWhen("waitForUserChanges", "userInput") {
            inputFile.text = "changed"
            waitForChangesToBePickedUp()
        }
        then:
        executedAndNotSkipped(":consumer")
        outputFile.text == "initial"
        assertExpectedProjectFilesInVfs(1)

        when:

			// let the CRD controller process the initial set of CRDs before starting the autoregistration controller.
			// this prevents the autoregistration controller's initial sync from deleting APIServices for CRDs that still exist.
			// we only need to do this if CRDs are enabled on this server.  We can't use discovery because we are the source for discovery.
			if crdAPIEnabled {
				klog.Infof("waiting for initial CRD sync...")