// Both instances should be of the same class
        assertEquals(exception1.getClass(), exception2.getClass());

        // Test serialization compatibility by checking class name
        assertEquals("org.codelibs.fess.exception.CommandExecutionException", exception1.getClass().getName());
    }

    public void test_exceptionThrown() {

   *
   * <p>Currently, this method is invoked while holding a lock. If an implementation of this method
   * blocks, it can prevent this service from changing state. If you need to performing a blocking
   * operation in order to trigger shutdown, consider instead registering a listener and
   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the

  /*
   * J2CL's EnumMap does not need the Class instance, so we can use Object.class instead. (Or we
   * could use null, but that messes with our nullness checking, including under J2KT. We could
   * probably work around it by changing how we annotate the J2CL EnumMap, but that's probably more
   * trouble than just using Object.class.)
   *

   * typically useful for {@code return} statements. That leaves the code with two options: Either
   * add the suppression to the whole method (which turns off checking for a large section of code),
   * or extract a variable, and put the suppression on that. However, a local variable typically
   * doesn't work: Because nullness analyses typically infer the nullness of local variables,

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.Serializable;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Queue;

/**
 * A non-blocking queue which automatically evicts elements from the head of the queue when
 * attempting to add new elements onto the queue and it is full. This queue orders elements FIFO

    public String name;

    /** User roles for search filtering */
    public String[] roles;

    /** User groups for search filtering */
    public String[] groups;

    /** Version number for optimistic locking */
    public String versionNo;

    /**
     * Clears all pagination state and search criteria.
     * Resets the pager to its initial state with default values.
     */
    public void clear() {

 *
 * <p>Tests should inherit from this class, and declare subtyping relationship with public methods
 * annotated by {@link TestSubtype}.
 *
 * <p>These declaration methods rely on Java static type checking to make sure what we want to
 * assert as subtypes are really subtypes according to javac. For example:
 *
 * {@snippet :
 * class MySubtypeTests extends SubtypeTester {

   * needed.
   *
   * A single spinlock ("busy") is used for initializing and
   * resizing the table, as well as populating slots with new Cells.
   * There is no need for a blocking lock; when the lock is not
   * available, threads try other slots (or the base).  During these
   * retries, there is increased contention and reduced locality,
   * which is still better than alternatives.
   *

ParsedCommandLineOpt(); } org/gradle/internal/file/PathTraversalChecker.class package org.gradle.internal.file; public abstract class PathTraversalChecker { public static String safePathName(String); } org/gradle/internal/file/locking/ExclusiveFileAccessM.class package org.gradle.internal.file.locking; public final class ExclusiveFileAccessM { public void ExclusiveFileAccessM(); public static void maybeCloseQuietly(java.io.Closeable); } org/gradle/util/internal/WrapperDistributionU.class package org.gradle.util.internal;...

    private int currentPageNumber;

    /** Group ID for search filtering. */
    public String id;

    /** Group name for search filtering. */
    public String name;

    /** Version number for optimistic locking. */
    public String versionNo;

    /**
     * Default constructor for GroupPager.
     * Initializes the pager with default values for pagination settings.
     */
    public GroupPager() {