}

  @Override
  public T or(Supplier<? extends T> supplier) {
    return checkNotNull(
        supplier.get(), "use Optional.orNull() instead of a Supplier that returns null");
  }

  @Override
  public @Nullable T orNull() {
    return null;
  }

  @Override
  public Set<T> asSet() {
    return Collections.emptySet();
  }

  @Override
  public <V> Optional<V> transform(Function<? super T, V> function) {

  public boolean isPresent() {
    return true;
  }

  @Override
  public T get() {
    return reference;
  }

  @Override
  public T or(T defaultValue) {
    checkNotNull(defaultValue, "use Optional.orNull() instead of Optional.or(null)");
    return reference;
  }

  @Override
  public Optional<T> or(Optional<? extends T> secondChoice) {
    checkNotNull(secondChoice);
    return this;
  }

  @Override

val artifactoryUrl
    get() = System.getenv("GRADLE_INTERNAL_REPO_URL") ?: ""

val artifactoryUserName
    get() = project.providers.gradleProperty("artifactoryUserName").orNull

val artifactoryUserPassword
    get() = project.providers.gradleProperty("artifactoryUserPassword").orNull

tasks.withType<AbstractPublishToMaven>().configureEach {
    val noUpload = project.gradleProperty("noUpload")

val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(
        project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,
        project.providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE").orNull
    )
    publishing.publications.configureEach {
        if (signArtifacts) {

                timeZone = TimeZone.getTimeZone("UTC")
            }
            return formatter.format(Date(0L))
        }

        val buildTimestampFromReceipt = buildTimestampFromBuildReceipt.orNull
        if (buildTimestampFromReceipt != null) {
            println("Using timestamp from incoming build receipt: $buildTimestampFromReceipt")
            return buildTimestampFromReceipt
        }

val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(pgpSigningKey.orNull, pgpSigningPassPhrase.orNull)
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }

        dependencies {
            "crossVersionTestImplementation"(testFixtures(project(":tooling-api")))
        }
    }
}
val releasedVersions = gradleModule.identity.releasedVersions.orNull

fun createQuickFeedbackTasks() {
    val testType = TestType.CROSSVERSION
    val defaultExecuter = "embedded"
    val prefix = testType.prefix
    testType.executers.forEach { executer ->

                else -> it
            }
        }

    private
    fun Parameters.buildReceiptString(): String? = when {
        ignoreIncomingBuildReceipt.get() -> null
        else -> buildReceiptFileContents.orNull
    }

            logger.lifecycle("Skip warmning up Android home because ANDROID_HOME/ANDROID_SDK_ROOT env vars are not set.")
            return
        }
        sdkVersions.orNull.orEmpty().forEach { version ->
            val projectName = "platform-${version.compileSdk}-buildtools-${version.buildTools.replace(".", "-")}"
            val projectDir = File(warmupProjectsDirectory.get().asFile, projectName)

   */
  @Override
  public <A extends Annotation> @Nullable A getDeclaredAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);
    return FluentIterable.from(annotations).filter(annotationType).first().orNull();
  }

  /**
   * @since 18.0
   */
  @Override
  public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationType) {
    @Nullable A[] result =