if (isApiRequest) {
            return ComponentUtil.getComponent(AccessTokenService.class).getPermissions(request).map(p -> {
                p.forEach(roleSet::add);
                return true;
            }).orElse(false);
        }
        return false;
    }

    /**
     * Processes the request parameter.
     * @param request The HTTP request.

    }

    @Test
    @DisplayName("getAvailable should return initial value of 0")
    void testGetAvailableInitialValue() {
        // Assert
        assertEquals(0, response.getAvailable());
    }

    @Test
    @DisplayName("writeSetupWireFormat should return 0")
    void testWriteSetupWireFormat() {
        // Arrange
        byte[] dst = new byte[100];

        }

        public String getName() {
            return name;
        }

        public int getValue() {
            return value;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null || getClass() != obj.getClass())
                return false;

     * @return The list of access results.
     */
    @Override
    public List<OpenSearchAccessResult> getAccessResultList(final String url, final boolean hasData) {
        return getList(OpenSearchAccessResult.class, builder -> builder.setQuery(QueryBuilders.termQuery(URL, url)));
    }

    /**
     * Returns a list of OpenSearchAccessResult objects.

     */
    public long getCurrentEndRecordNumber() {
        return currentEndRecordNumber;
    }

    /**
     * Gets a list of page numbers for pagination display.
     * Typically returns a range of page numbers around the current page.
     *
     * @return a list of page numbers as strings
     */
    public List<String> getPageNumberList() {

    assertEquals(new TreeSet<E>(), empty);
  }

  /*
   * TODO(cpovirk): more testing of subSet/headSet/tailSet/descendingSet? and/or generate derived
   * suites?
   */

  /**
   * Returns the {@link Method} instances for the test methods in this class that create a set with
   * a "hole" in it so that set tests of {@code ContiguousSet} can suppress them with {@code
   * FeatureSpecificTestSuiteBuilder.suppressing()}.

        String message = "Localized error message";
        DataStoreException exception = new DataStoreException(message);

        // By default, getLocalizedMessage returns the same as getMessage
        assertEquals(message, exception.getLocalizedMessage());
    }

    public void test_toString() {
        // Test toString method
        String message = "Test exception";

    .build();
```

[`HandshakeCertificates`][handshake_certificates] keeps the certificates for a TLS handshake.
Use its [builder][handshake_certificates_builder] to define which certificates the HTTPS server
returns to its clients. The returned instance can create an `SSLSocketFactory` that implements this
policy:

```java
HandshakeCertificates serverCertificates = new HandshakeCertificates.Builder()
    .heldCertificate(localhostCertificate)

     * Unsafe.getUnsafe when integrating into a JDK.
     *
     * @return an Unsafe instance if successful
     */
    private static Unsafe getUnsafe() {
      try {
        return Unsafe.getUnsafe();
      } catch (SecurityException tryReflectionInstead) {
        // We'll try reflection instead.
      }
      try {
        return AccessController.doPrivileged(
            (PrivilegedExceptionAction<Unsafe>)

		if err != nil {
			return nil, err
		}

		return format, nil
	}

	// Return error when quorum unformatted disks - indicating we are
	// waiting for first server to be online.
	unformattedDisks := quorumUnformattedDisks(sErrs)
	if unformattedDisks && !firstDisk {
		return nil, errNotFirstDisk
	}

	// Return error when quorum unformatted disks but waiting for rest