import org.codehaus.plexus.interpolation.QueryEnabledValueSource;

/**
 * Wraps an arbitrary object with an {@link ObjectBasedValueSource} instance, then
 * wraps that source with a {@link PrefixedValueSourceWrapper} instance, to which
 * this class delegates all of its calls.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")

    private static Method makeAccessible(Method method) {
        method.setAccessible(true);
        return method;
    }

    private static <T> T invoke(Method method, Object instance, Object... args) {
        try {
            Object result = method.invoke(instance, args);
            @SuppressWarnings("unchecked")
            T cast = (T) result;
            return cast;
        } catch (IllegalAccessException | InvocationTargetException e) {

    }

    /**
     * Gets the query field configuration.
     * @return The query field configuration instance.
     */
    protected QueryFieldConfig getQueryFieldConfig() {
        return ComponentUtil.getQueryFieldConfig();
    }

    /**
     * Gets the query processor instance.
     * @return The query processor instance.
     */
    protected QueryProcessor getQueryProcessor() {

/**
 * Resident invoker implementation, specialization of Maven Invoker, but keeps Maven instance resident. This implies, that
 * things like environment, system properties, extensions etc. are loaded only once. It is caller duty to ensure
 * that subsequent call is right for the resident instance (ie no env change or different extension needed).

   * Returns a new {@code MutableClassToInstanceMap} instance backed by a {@link HashMap} using the
   * default initial capacity and load factor.
   */
  public static <B extends @Nullable Object> MutableClassToInstanceMap<B> create() {
    return new MutableClassToInstanceMap<>(new HashMap<Class<? extends @NonNull B>, B>());
  }

  /**
   * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code

 */
@Immutable
abstract class AbstractHashFunction implements HashFunction {
  @Override
  public <T extends @Nullable Object> HashCode hashObject(
      @ParametricNullness T instance, Funnel<? super T> funnel) {
    return newHasher().putObject(instance, funnel).hash();
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {
    int len = input.length();

import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A map, each entry of which maps a Java <a href="http://tinyurl.com/2cmwkz">raw type</a> to an
 * instance of that type. In addition to implementing {@code Map}, the additional type-safe
 * operations {@link #putInstance} and {@link #getInstance} are available.
 *

    private MonotonicClock() {
        this.startNanos = System.nanoTime();
        this.startInstant = Clock.systemUTC().instant();
    }

    /**
     * Returns the singleton instance of MonotonicClock.
     *
     * @return the monotonic clock instance
     */
    public static MonotonicClock get() {
        return CLOCK;
    }

    /**
     * Returns the current instant from the monotonic clock.

   *
   * @since 13.0
   * @since 4.0 (in Equivalences)
   */
  public static Equivalence<Object> identity() {
    return Identity.INSTANCE;
  }

  static final class Equals extends Equivalence<Object> implements Serializable {

    static final Equals INSTANCE = new Equals();

    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return a.equals(b);
    }

    @Override

    }

    @Test
    void close_shouldClosePolicySuccessfully() throws IOException {
        // Arrange
        // First, successfully create an LsaPolicyHandle instance
        doAnswer(invocation -> {
            MsrpcLsarOpenPolicy2 rpc = invocation.getArgument(0);
            rpc.retval = 0;
            return null;