if match is found, the toolchain instance is made available to other Maven plugins.</p>
    <p>With {@code jdk} toolchain, for example, instead of being stuck with the JDK used to run Maven, all plugins can use
    the same other JDK instance without hardcoding absolute paths into the {@code pom.xml}
    and without configuring every plugin that require path to JDK tools.</p>

        // Two distinct auth instances
        NtlmPasswordAuthentication a1 = new NtlmPasswordAuthentication("DOM", "user", "pwd");
        NtlmPasswordAuthentication a2 = new NtlmPasswordAuthentication("DOM", "user", "pwd");
        SmbSession s1 = new SmbSession(addr, 445, inet, 0, a1);
        SmbSession s2 = new SmbSession(addr, 445, inet, 0, a2);
        // same auth instance => matches
        assertTrue(s1.matches(a1));

      Object instance = ArbitraryInstances.get(mutableClass);
      assertWithMessage("Expected to return non-null for: %s", mutableClass)
          .that(instance)
          .isNotNull();
      assertWithMessage("Expected to return fresh instance for: " + mutableClass)
          .that(ArbitraryInstances.get(mutableClass))
          .isNotSameInstanceAs(instance);
    }
  }

        // Arrange: create an implementation instance
        SmbRenewableCredentials impl = supplier.get();

        // Act: call renew
        CredentialsInternal renewed = impl.renew();

        // Assert: verify behavior based on scenario
        if (expectSame) {
            assertSame(impl, renewed, "renew() should return the same instance");
        } else if (expectNew) {

 * @author Harry Heymann
 * @since 2.0
 */
@GwtCompatible
public interface Supplier<T extends @Nullable Object> {
  /**
   * Retrieves an instance of the appropriate type. The returned object may or may not be a new
   * instance, depending on the implementation.
   *
   * @return an instance of the appropriate type
   */
  @ParametricNullness
  T get();

  /**

@GwtCompatible
final class Absent<T> extends Optional<T> {
  static final Absent<Object> INSTANCE = new Absent<>();

  @SuppressWarnings("unchecked") // implementation is "fully variant"
  static <T> Optional<T> withType() {
    return (Optional<T>) INSTANCE;
  }

  private Absent() {}

  @Override
  public boolean isPresent() {
    return false;
  }

  @Override

  }

  /**
   * Creates an instance of {@link ToStringHelper} in the same manner as {@link
   * #toStringHelper(Object)}, but using the simple name of {@code clazz} instead of using an
   * instance's {@link Object#getClass()}.
   *
   * <p>Note that in GWT, class names are often obfuscated.
   *
   * @param clazz the {@link Class} of the instance
   * @since 18.0 (since 7.0 as {@code Objects.toStringHelper}).

 * returns a new instance.
 *
 * This collection is optimized for safe concurrent access over a very small number of elements.
 *
 * This collection and is expected to hold fewer than 10 elements. Each operation is _O(N)_, and so
 * building an instance with _N_ elements is _O(N**2)_.
 */
internal sealed class Tags {
  /**

        ProjectBuilderRequestBuilder() {}

        /**
         * Sets the Maven session for this request.
         *
         * @param session the Maven session
         * @return this builder instance
         */
        public ProjectBuilderRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

        /**

            // Create new Mac instance for thread safety without blocking other operations
            Mac mac;
            try {
                mac = createMacInstance();
            } catch (GeneralSecurityException e) {
                log.error("Failed to create Mac instance for signing", e);
                throw new RuntimeException("Failed to create Mac instance", e);
            }