*/
public class InvalidAccessTokenException extends FessSystemException {

    /** Serial version UID for serialization */
    private static final long serialVersionUID = 1L;

    /** Type of the invalid access token */
    private final String type;

    /**
     * Creates a new InvalidAccessTokenException with the specified type and message.
     *
     * @param type the type of the invalid access token

    implements Iterator<T> {
  final Iterator<? extends F> backingIterator;

  TransformedIterator(Iterator<? extends F> backingIterator) {
    this.backingIterator = checkNotNull(backingIterator);
  }

  @ParametricNullness
  abstract T transform(@ParametricNullness F from);

  @Override
  public final boolean hasNext() {
    return backingIterator.hasNext();
  }

  @Override

  // public named classes with a public default constructor.

  public static final class DoublesAsListGenerator extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      return asList(elements);
    }
  }

  public static final class DoublesAsListHeadSubListGenerator extends TestDoubleListGenerator {
    @Override

 * to access a specific action or resource.
 *
 */
public class UserRoleLoginException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /** The action class that requires specific user roles */
    private final Class<? extends RootAction> actionClass;

    /**
     * Constructs a new UserRoleLoginException with the specified action class.
     *

     * @param value the small integer value (will be masked to 0-255 range)
     */
    public NdrSmall(final int value) {
        this.value = value & 0xFF;
    }

    @Override
    public void encode(final NdrBuffer dst) throws NdrException {
        dst.enc_ndr_small(this.value);
    }

    @Override
    public void decode(final NdrBuffer src) throws NdrException {
        this.value = src.dec_ndr_small();
    }

import java.io.IOException;
import java.io.OutputStream;

class SocketOutputStream extends FilterOutputStream {

    SocketOutputStream(final OutputStream out) {
        super(out);
    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {

    /**
     * @throws Exception
     */
    @Test
    public void testIsEqualsMethod() throws Exception {
        final Method equalsMethod = ClassUtil.getMethod(getClass(), "equals", Object.class);
        assertThat(MethodUtil.isEqualsMethod(equalsMethod), is(true));
        final Method hashCodeMethod = ClassUtil.getMethod(getClass(), "hashCode");
        assertThat(MethodUtil.isEqualsMethod(hashCodeMethod), is(not(true)));
    }

/**
 * @author David Beaumont
 */
@GwtCompatible
@NullMarked
public class ArrayBasedCharEscaperTest extends TestCase {
  private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
  private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
      ImmutableMap.of(
          '\n', "<newline>",
          '\t', "<tab>",
          '&', "<and>");

   *
   * @since 15.0 (since 12.0 in HashCodes)
   */
  public static HashCode fromInt(int hash) {
    return new IntHashCode(hash);
  }

  private static final class IntHashCode extends HashCode implements Serializable {
    final int hash;

    IntHashCode(int hash) {
      this.hash = hash;
    }

    @Override
    public int bits() {
      return 32;
    }

    @Override

        // Test that the constructor and getters work with proper setup
        FessConfig mockConfig = new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public Set<String> getApiPingEsFieldSet() {
                return new HashSet<>();
            }
        };