}

	// Signature is valid, lets validate the claims for
	// other fields such as expiry etc.
	return claims.Valid()
}

// ParseUnverifiedStandardClaims - WARNING: Don't use this method unless you know what you're doing
//
// This method parses the token but doesn't validate the signature. It's only
// ever useful in cases where you know the signature is valid (because it has

    assertEmpty(getMultiset());
  }

  /**
   * Returns {@link Method} instances for the read tests that assume multisets support duplicates so
   * that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getElementSetDuplicateInitializingMethods() {
    return asList(
        getMethod(

     * was called, in which case entries are sorted by value.
     *
     * <p>Prefer the equivalent method {@link #buildOrThrow()} to make it explicit that the method
     * will throw an exception if there are duplicate keys or values. The {@code build()} method
     * will soon be deprecated.
     *
     * @throws IllegalArgumentException if duplicate keys or values were added
     */
    @Override

      return this;
    }

    /**
     * Returns a newly-created immutable table.
     *
     * <p>Prefer the equivalent method {@link #buildOrThrow()} to make it explicit that the method
     * will throw an exception if there are duplicate key pairs. The {@code build()} method will
     * soon be deprecated.
     *
     * @throws IllegalArgumentException if duplicate key pairs were added
     */

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.

        PhantomReference<Object> frqRef)
        throws Throwable;
  }

  private static final class ReflectiveStarter implements FinalizerStarter {
    final Method startFinalizer;

    ReflectiveStarter(Method startFinalizer) {
      this.startFinalizer = startFinalizer;
    }

    @Override
    public void startFinalizer(
        Class<?> finalizableReferenceClass,

    }

    /**
     * Helper method to set header start using reflection
     */
    private void setHeaderStart(Smb2ChangeNotifyResponse response, int headerStart) throws Exception {
        Method method = ServerMessageBlock2.class.getDeclaredMethod("getHeaderStart");
        method.setAccessible(true);

  /**
   * Replaces the existing container under test with a new container. This is useful when a single
   * test method needs to create multiple containers while retaining the ability to use {@link
   * #expectContents(Object[]) expectContents(E...)} and other convenience methods. The creation of
   * multiple containers in a single method is discouraged in most cases, but it is vital to the
   * iterator tests.
   *
   * @return the new container instance

    private final ExecutorService inline = newDirectExecutorService();

    void assertLastMethodCalled(String method) {
      assertThat(lastMethodCalled).isEqualTo(method);
    }

    void assertMethodWithTimeout(String method, long timeout, TimeUnit unit) {
      assertLastMethodCalled(method + "Timeout");
      assertEquals(unit.toMillis(timeout), lastTimeoutInMillis);
    }

    @Override

        int bytesRead = response.readDataWireFormat(fullBuffer, startIndex, buffer.length);

        // Verify the method returns the correct number of bytes read
        assertTrue(bytesRead > 0);
        assertTrue(bytesRead <= buffer.length);
    }

    /**
     * Helper method to create a valid security descriptor buffer
     */
    private byte[] createValidSecurityDescriptorBuffer() {