<w>jdks</w>
      <w>jsshell</w>
      <w>proguarded</w>
      <w>protobuf</w>
      <w>redirector</w>
      <w>remapper</w>
      <w>sonatype</w>
      <w>streamex</w>
      <w>unpresent</w>
    </words>
  </dictionary>

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 47341
releaseNotes:
- |

  }

  Optional() {}

  /**
   * Returns {@code true} if this holder contains a (non-null) instance.
   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> no differences.
   */
  public abstract boolean isPresent();

  /**
   * Returns the contained instance, which must be present. If the instance might be absent, use

 * the reference is "absent"); it is never said to "contain {@code null}".
 *
 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable {@code T}
 * reference. It allows you to represent "a {@code T} that must be present" and a "a {@code T} that
 * might be absent" as two distinct types in your program, which can aid clarity.
 *
 * <p>Some uses of this class include
 *
 * <ul>

    public T get() {
        return delegate.get();
    }

    public boolean isPresent() {
        return delegate.isPresent();
    }

    public boolean isEmpty() {
        return !delegate.isPresent();
    }

    public void ifPresent(Consumer<? super T> action) {
        delegate.ifPresent(action);
    }

    @SuppressWarnings("unused")

// out. It stores whether an element with the tag was found in outPresent,
// unless outPresent is nil. It reports whether the read was successful.
func (s *String) ReadOptionalASN1(out *String, outPresent *bool, tag asn1.Tag) bool {
	present := s.PeekASN1Tag(tag)
	if outPresent != nil {
		*outPresent = present
	}
	if present && !s.ReadASN1(out, tag) {
		return false
	}
	return true
}

		}
		return ParseSecretKey(s)
	}
}

// IsPresent reports whether a KMS configuration is present.
// It returns an error if multiple KMS configurations are
// present or if one configuration is incomplete.
func IsPresent() (bool, error) {
	// isPresent reports whether at least one of the
	// given env. variables is present.
	isPresent := func(vars ...string) bool {
		for _, v := range vars {

			os.Setenv(k, v)
		}

		ok, err := IsPresent()
		if err != nil && !test.ShouldFail {
			t.Fatalf("Test %d: %v", i, err)
		}
		if err == nil && test.ShouldFail {
			t.Fatalf("Test %d: should have failed but succeeded", i)
		}

		if !test.ShouldFail && ok != test.IsPresent {
			t.Fatalf("Test %d: reported that KMS present=%v - want present=%v", i, ok, test.IsPresent)
		}
	}
}

var isPresentTests = []struct {

    /**
     * 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()
    }