*
     * @param key the parameter key to look up
     * @param defaultValue the default value to return if key is not found or value is null
     * @return the parameter value as a String, or defaultValue if not found
     */
    public String getAsString(final String key, final String defaultValue) {
        final String value = getAsString(key);
        if (value != null) {
            return value;

  }

  @Override
  public @Nullable V edgeValueOrDefault(N nodeU, N nodeV, @Nullable V defaultValue) {
    return delegate().edgeValueOrDefault(nodeU, nodeV, defaultValue);
  }

  @Override
  public @Nullable V edgeValueOrDefault(EndpointPair<N> endpoints, @Nullable V defaultValue) {
    return delegate().edgeValueOrDefault(endpoints, defaultValue);
  }

   * Returns the first element in {@code iterable} that satisfies the given predicate, or {@code
   * defaultValue} if none found. Note that this can usually be handled more naturally using {@code
   * tryFind(iterable, predicate).or(defaultValue)}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code
   * stream.filter(predicate).findFirst().orElse(defaultValue)}
   *
   * @since 7.0
   */
  // The signature we really want here is...
  //

     * @param key parameter key
     * @param defaultValue default value if parameter not found
     * @return parameter value or default value
     */
    private long getParamValue(final Map<String, Long> params, final String key, final long defaultValue) {
        final Long value = params.get(key);
        return value != null ? value : defaultValue;
    }

    /**
     * Delays after processing a URL.
     */

          <version>4.0.0+</version>
          <defaultValue>mail</defaultValue>
          <type>String</type>
          <description>The mechanism used to deliver notifications.</description>
        </field>
        <field>
          <name>sendOnError</name>
          <version>4.0.0+</version>
          <defaultValue>true</defaultValue>
          <type>boolean</type>

   * position}th position or {@code defaultValue} otherwise.
   *
   * @param position position of the element to return
   * @param defaultValue the default value to return if the iterator is empty or if {@code position}
   *     is greater than the number of elements remaining in {@code iterator}
   * @return the element at the specified position in {@code iterator} or {@code defaultValue} if

    return false;
  }

  @Override
  public T get() {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }

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

  @SuppressWarnings("unchecked") // safe covariant cast
  @Override
  public Optional<T> or(Optional<? extends T> secondChoice) {

     * @param clazz the class type to convert the value to
     * @param defaultValue the default value to return if the key is not found or conversion fails
     * @return the converted value or the default value if not found
     */
    public static <T> T getValue(final Map<String, Object> doc, final String key, final Class<T> clazz, final T defaultValue) {
        final T value = getValue(doc, key, clazz);
        if (value == null) {

        @ValueSource(strings = { "text/unknown", "application/x-unknown", "custom/type", "" })
        void testVariousDefaultValues(String defaultValue) throws IOException {
            assertEquals(defaultValue, mimeMap.getMimeType("notinmap", defaultValue));
        }
    }

    @Nested
    @DisplayName("Edge cases and special scenarios")
    class EdgeCases {

        @Test

        // v1 == 0.
        .optional(defaultValue = 0),
      Adapters.INTEGER_AS_BIG_INTEGER,
      algorithmIdentifier,
      name,
      validity,
      name,
      subjectPublicKeyInfo,
      Adapters.BIT_STRING.withTag(tag = 1L).optional(),
      Adapters.BIT_STRING.withTag(tag = 2L).optional(),
      extension.asSequenceOf().withExplicitBox(tag = 3).optional(defaultValue = listOf()),
      decompose = {