given:
        def collection = new EmptyFileCollection("foo")

        when:
        def executionTimeValue = collection.calculateExecutionTimeValue()

        then:
        executionTimeValue.present

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

        then:
        newCollection.isEmpty()
        newCollection.displayName == "foo"
    }

     */
    Summary(false),

    /**
     * No deprecation warnings at all.
     */
    None(false),

    /**
     * Show all warnings and fail the build if any warning present
     *
     * @since 5.6
     */
    Fail(true);

    private final boolean displayMessages;

    WarningMode(boolean displayMessages) {
        this.displayMessages = displayMessages;
    }

        jdkRepository = new JdkRepository(JAVA_VERSION)
        uri = jdkRepository.start()
    }

    def cleanupSpec() {
        jdkRepository.stop()
    }

    def setup() {
        jdkRepository.reset()

        executer.requireOwnGradleUserHomeDir()
            .withToolchainDownloadEnabled()
    }

    def cleanup() {
        executer.gradleUserHomeDir.file("jdks").deleteDir()
    }

				ImageRepository: "registry.k8s.io",
				Arch:            "amd64",
			},
			output:      validTmplOut,
			errExpected: false,
		},
		{
			name:     "should noop if there aren't any {{ .foo }} present",
			template: doNothing,
			data: struct{ ImageRepository, Arch string }{
				ImageRepository: "registry.k8s.io",
				Arch:            "amd64",
			},
			output:      doNothing,
			errExpected: false,
		},
		{

		var err error
		r.gen, r.spill, err = readGeneration(r.r, r.spill)
		if r.gen == nil {
			return Event{}, err
		}
		r.spillErr = err

		// Reset CPU samples cursor.
		r.cpuSamples = r.gen.cpuSamples

		// Reset frontier.
		for m, batches := range r.gen.batches {
			bc := &batchCursor{m: m}
			ok, err := bc.nextEvent(batches, r.gen.freq)
			if err != nil {
				return Event{}, err
			}

        if (features.add(usage.getSummary())) {
            LOGGER.warn(String.format("%s is an incubating feature.", usage.getSummary()));
        }
    }

    public void reset() {
        features.clear();
    }

        backingMapping[typeParameter] = type
    }

    /**
     * Adds a new substitutions to the substitutor which is being built.
     * If there already was a substitution with a [KaTypeParameterSymbol] which is present in a [substitutions],
     * replaces corresponding substitution with a new one.
     */
    public fun substitutions(substitutions: Map<KaTypeParameterSymbol, KaType>): Unit = withValidityAssertion {

import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.operations.OperationIdentifier;

import javax.annotation.Nullable;

/**
 * Requests that the client present the given prompt to the user and return the user's response as a single line of text.
 *
 * The response is delivered to the {@link UserInputReader} service.
 */

    public val annotationsList: KaAnnotationList
        get() = annotations
}

public typealias KtAnnotated = KaAnnotated

/**
 * A list of annotations applied.
 *
 * To check if annotation is present, please use [hasAnnotation].
 *
 * @see [KaAnnotationList.annotations]
 */
@Deprecated("Use the 'annotations' the member property instead.")
public val KaAnnotated.annotations: List<KaAnnotation>
    get() = annotations

		case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)

			// Reset the timer for next cycle.
			callhomeTimer.Reset(globalCallhomeConfig.FrequencyDur())
		}
	}
}

func performCallhome(ctx context.Context) {
	deadline := 10 * time.Second // Default deadline is 10secs for callhome