/**
     * Returns {@code true} if there is a value present, otherwise {@code false}.
     *
     * @return {@code true} if there is a value present, otherwise {@code false}
     */
    boolean isPresent();

    /**
     * Returns a {@link Provider} whose value is the value of this provider, if present, otherwise the
     * given default value.
     *

        provider2.get() == ["a", "b"]
    }

    def "isPresent is true if all sources are present"() {
        given:
        def provider1 = new MergeProvider([providers.provider { new Object() }])
        def provider2 = new MergeProvider([providers.provider { new Object() }, providers.provider { new Object() }])

        expect:
        provider1.isPresent()
        provider2.isPresent()
    }

        }
    };

    /**
     * Checks if this attribute value is present, defined as not {@code null} and not {@link AttributeValue#MISSING}
     *
     * @return {@code true} if value is present, {@code false} otherwise
     */
    boolean isPresent();

    /**
     * Returns the value of this attribute.

                .map(OriginatingElement::getElement);

            if (!maybeOriginatingElement.isPresent()) {
                return false;
            }

            ExecutableElement originatingElement = maybeOriginatingElement.get();
            return AnnotationUtils.findMetaAnnotationMirror(originatingElement, annotationType).isPresent();
        };
    }

            if (!wildcardType.getExtendedType().isPresent() && !wildcardType.getSuperType().isPresent()) {
                typeMetaData.setWildcard();
            } else {
                wildcardType.getExtendedType().ifPresent(referenceType -> typeMetaData.setUpperBounds(extractTypeName(referenceType)));
                wildcardType.getSuperType().ifPresent(referenceType -> typeMetaData.setLowerBounds(extractTypeName(referenceType)));

            .map(Object::toString)
            .map(DefaultPluginId::new);

        StringBuilder builder = new StringBuilder();
        boolean typeRelevant = rootType.isPresent() && !typeIrrelevantInErrorMessage;
        if (typeRelevant) {
            if (pluginId.isPresent()) {
                builder.append("In plugin '")
                    .append(pluginId.get())
                    .append("' type '");
            } else {

        expect:
        property.present
        property.get() == 13

        when:
        property.convention((Number) null)
        property.get()

        then:
        def e = thrown(MissingValueException)
        e.message == "Cannot query the value of ${displayName} because it has no value available."

        and:
        !property.present
    }

        // If we did not capture any outputs after execution, remove them from history
        context.getHistory()
            .ifPresent(history -> {
                if (!result.getAfterExecutionOutputState().isPresent()) {
                    history.remove(context.getIdentity().getUniqueId());
                }
            });
        return result;
    }

                    .ifPresent(e -> params.put(Constants.SCHEDULED_JOB, e)).orElse(() -> {
                        logger.warn("Job {} is not found.", scheduledJob.getId());
                    });
            return params;
        };
        findJobByUniqueOf(LaJobUnique.of(id)).ifPresent(job -> {
            if (!job.isUnscheduled()) {

	// Otherwise, the metadata is corrupted.
	keyID, idPresent := metadata[MetaKeyID]
	b64KMSSealedKey, kmsKeyPresent := metadata[MetaDataEncryptionKey]
	if !idPresent && kmsKeyPresent {
		return keyID, kmsKey, sealedKey, Errorf("The object metadata is missing the internal KMS key-ID for SSE-S3")
	}
	if idPresent && !kmsKeyPresent {