import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.exception.InvalidAccessTokenException;
import org.codelibs.fess.util.ComponentUtil;

public class AccessTokenHelper {

    protected static final String BEARER = "Bearer";

    protected Random random = new SecureRandom();

    public String generateAccessToken() {

    }

    private int scaleCacheSize(int referenceValue, int granularity) {
        if (referenceValue < granularity) {
            throw new IllegalArgumentException("reference value must be larger than granularity");
        }
        int scaledValue = (int) ((double) referenceValue * sizingRatio) / granularity * granularity;
        return Math.max(scaledValue, granularity);
    }

 * features}, the features supported by the iterator; and {@code expectedElements}, the elements the
 * iterator should return in order.
 *
 * <p>The items in {@code elementsToInsert} will be repeated if {@code steps} is larger than the
 * number of provided elements.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class ListIteratorTester<E extends @Nullable Object>

    Optional<FileSystemNode> getNode(VfsRelativePath relativePath, CaseSensitivity caseSensitivity);

    /**
     * Stores information to the virtual file system that we have learned about.
     *
     * Complete information, like {@link FileSystemLocationSnapshot}s, are not touched nor replaced.
     */
    @CheckReturnValue

     *
     * For existing files, we watch the parent directory,
     * so we learn if the file itself disappears or gets modified.
     * For directories, we only watch the directory itself, as we get
     * events for that.
     * In case of a missing file we need to find the closest existing
     * ancestor to watch so we can learn if the missing file respawns.
     */

 * features}, the features supported by the iterator; and {@code expectedElements}, the elements the
 * iterator should return in order.
 *
 * <p>The items in {@code elementsToInsert} will be repeated if {@code steps} is larger than the
 * number of provided elements.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class ListIteratorTester<E extends @Nullable Object>

     * Interface precedence is breadth-first, declaration.
     *
     * The order of the methods follows the same precedence.
     * That is, the “nearer” declarations are earlier in the list.
     */
    Collection<Method> getGetters();

    /**
     * Similar to {@link #getGetters()}, but varies based on the param type instead of return type.
     *

 * A successful {@literal PUT} request must return any 2xx response.
 * <p>
 * {@literal PUT} requests may also return a {@literal 413 Payload Too Large} response to indicate that the payload is larger than can be accepted.
 * This is useful when {@link #isUseExpectContinue()} is enabled.
 * <p>
 * Redirecting responses may be issued with {@literal 301}, {@literal 302}, {@literal 303}, {@literal 307} or {@literal 308} responses.

    public void test_getAccessTokenFromRequest_ok0() {
        final String token = accessTokenHelper.generateAccessToken();
        MockletHttpServletRequest req = getMockRequest();
        req.addHeader("Authorization", "Bearer " + token);
        assertEquals(token, accessTokenHelper.getAccessTokenFromRequest(req));
    }

    public void test_getAccessTokenFromRequest_ok1() {
        final String token = accessTokenHelper.generateAccessToken();

                            break;
                        default:
                            throw new AssertionError();
                    }
                }
            });
            OutputsCleaner cleaner = new OutputsCleaner(
                deleter,
                file -> true,
                dir -> !outputDirectoriesToPreserve.contains(dir)
            );