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) {

    }

    @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;

 *
 * @author Kevin Bourrillion
 * @author Ben Yu
 * @since 1.0
 */
@GwtCompatible
public final class Throwables {
  private Throwables() {}

  /**
   * Throws {@code throwable} if it is an instance of {@code declaredType}. Example usage:
   *
   * <pre>
   * for (Foo foo : foos) {
   *   try {
   *     foo.bar();
   *   } catch (BarException | RuntimeException | Error t) {
   *     failure = t;
   *   }

    /** View as a {@link Set} */
    protected transient Set<? extends Map.Entry<K, V>> entrySet = null;

    /**
     * Constructs an instance with the default initial capacity.
     */
    public ArrayMap() {
        this(INITIAL_CAPACITY);
    }

    /**
     * Constructs an instance with the specified initial capacity.
     *
     * @param initialCapacity the initial capacity
     */
    @SuppressWarnings("unchecked")

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

/**
 * 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).

     */
    protected final List<String> tags;

    /**
     * The list of roles associated with the elevate word.
     */
    protected final List<String> roles;

    /**
     * Constructs an ElevateWord instance with the specified properties.
     *
     * @param elevateWord the elevate word
     * @param boost the boost value
     * @param readings the list of readings
     * @param fields the list of fields

    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.

    }

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

    void testEncodeDecodeRoundtrip() throws SMBProtocolDecodingException {
        // Setup first instance with test data
        long expectedIndexNumber = 0x1122334455667788L;
        byte[] originalBuffer = new byte[8];
        SMBUtil.writeInt8(expectedIndexNumber, originalBuffer, 0);

        // Decode into first instance
        FileInternalInfo firstInstance = new FileInternalInfo();