}

    def "method removal can be reported if current class is first public class"() {
        given:
        apiClass.oldClass >> Optional.of(classes['OldBase'])
        apiClass.newClass >> Optional.of(classes['NewBase'])

        when:
        Violation violation = rule.maybeViolation(apiClass)

        then:
        violation.humanExplanation.contains('SuperInternal.publicMethod()')

    assertEquals(
        com.google.common.base.Optional.absent(),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    assertEquals(
        com.google.common.base.Optional.of("2"),
        generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {}));
    // Test that the first generated instance for different cgcb.Optional<T> is always absent().

        return flags.entries
            .map { entry ->
                entry.key.map {
                    when (it) {
                        true -> Optional.of(entry.value)
                        false -> Optional.empty()
                    }
                }.orElse(provider {
                    throw GradleException("Expected boolean flag to be configured")
                })
            }

    }

    public static Optional<AccessorKey> maybeGetKeyOfOldAccessorOfUpgradedProperty(JApiCompatibility jApiCompatibility, ViolationCheckContext context) {
        if (!(jApiCompatibility instanceof JApiMethod) || ((JApiMethod) jApiCompatibility).getOldMethod().isEmpty()) {
            return Optional.empty();
        }
        JApiMethod jApiMethod = (JApiMethod) jApiCompatibility;

 * exception when queried.
 */
fun <T: Any> atMostOneOf(vararg providers: Provider<T>): Provider<T> {
    return providers.map { provider ->
        provider.map {
            Optional.of(it)
        }.orElse(
            Optional.empty<T>()
        )
    }.reduce { acc, next ->
        acc.zip(next) { left, right ->
            when {
                left.isPresent -> {

    } catch (NoSuchFieldException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**
   * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
   * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
   * user input or falling back to a default enum constant. For example, {@code

ingInputs=this.dependingInputs||[],this.dependingInputs.push(c)})})},c=function(b,c){var d=function(){var c=a(this),d=c.valAttr("optional-if-answered"),e=!1,f=!!a.formUtils.getValue(c);f||(a.each(a.split(d),function(c,d){var f=b.find('[name="'+d+'"]');if(e=!!a.formUtils.getValue(f))return!1}),e&&c.valAttr("skipped",1))},e=function(){var d=a(this),e=d.valAttr("optional-if-answered");a.each(a.split(e),function(d,e){var f=b.find('[name="'+e+'"]'),g=!!a.formUtils.getValue(f);g||a.formUtils.dialogs.r...

    id: build-scan-url
    attributes:
      label: Build scan URL (optional)
      description: |
        You can run your build command with `--scan` to publish a Build Scan to [scans.gradle.com](https://scans.gradle.com/).
    validations:
      required: false
  - type: textarea
    id: environment
    attributes:
      label: Your Environment (optional)
      description: |

   */
  RangeSet<C> complement();

  /**
   * Returns a view of the intersection of this {@code RangeSet} with the specified range.
   *
   * <p>The returned view supports all optional operations supported by this {@code RangeSet}, with
   * the caveat that an {@link IllegalArgumentException} is thrown on an attempt to {@linkplain

        stablePublicInterface = instanceScopedPool.get(StablePublicInterface.name)

        apiClass.changeStatus >> JApiChangeStatus.MODIFIED
        apiClass.oldClass >> Optional.of(oldBase)
        apiClass.newClass >> Optional.of(newBase)

        internalInterface.name = replaceAsInternal(internalInterface.name)

        interfaces = ['internal': internalInterface,