/**
 * Admin action for Boost Document management.
 *
 */
public class AdminBoostdocAction extends FessAdminAction {

    /**
     * Default constructor.
     */
    public AdminBoostdocAction() {
        super();
    }

    /** The role for this action. */
    public static final String ROLE = "admin-boostdoc";

    private static final Logger logger = LogManager.getLogger(AdminBoostdocAction.class);

/**
 * Admin action for Role management.
 *
 */
public class AdminRoleAction extends FessAdminAction {

    /**
     * Default constructor.
     */
    public AdminRoleAction() {
        super();
    }

    /** Role name for admin role operations */
    public static final String ROLE = "admin-role";

    private static final Logger logger = LogManager.getLogger(AdminRoleAction.class);

public class FacetInfoTest extends UnitFessTestCase {

    private FacetInfo facetInfo;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        facetInfo = new FacetInfo();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
    }

    // Test default constructor
    public void test_constructor() {
        FacetInfo info = new FacetInfo();

    while (allTests.hasMoreElements()) {
      Object test = allTests.nextElement();
      if (test instanceof AbstractTester) {
        @SuppressWarnings("unchecked")
        AbstractTester<? super G> tester = (AbstractTester<? super G>) test;
        tester.init(subjectGenerator, name, setUp, tearDown);
      }
    }

    return suite;
  }

  private TestSuite filterSuite(TestSuite suite) {

/**
 * Admin action for suggest management.
 *
 */
public class AdminSuggestAction extends FessAdminAction {

    /**
     * Default constructor.
     */
    public AdminSuggestAction() {
        super();
    }

    /** Role name for admin suggest operations */
    public static final String ROLE = "admin-suggest";

    // ===================================================================================

    EmptyAbstractSequentialIterator() {
      super(null);
    }

    @Override
    protected T computeNext(T previous) {
      throw new AssertionFailedError();
    }
  }

  private static class BrokenAbstractSequentialIterator extends AbstractSequentialIterator<Object> {

    BrokenAbstractSequentialIterator() {
      super("UNUSED");
    }

    @Override

/** An ordering that uses the reverse of a given order. */
@GwtCompatible
final class ReverseOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Ordering<? super T> forwardOrder;

  ReverseOrdering(Ordering<? super T> forwardOrder) {
    this.forwardOrder = checkNotNull(forwardOrder);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {

    /**
     * Constructs a TransPeekNamedPipeResponse with the specified configuration.
     *
     * @param config the SMB configuration
     */
    public TransPeekNamedPipeResponse(final Configuration config) {
        super(config);
    }

    /**
     * Gets the number of bytes available to read from the named pipe.
     *
     * @return the available
     */
    public final int getAvailable() {
        return this.available;

     *
     * @param config the CIFS configuration
     * @param signingEnforced whether SMB signing is enforced
     */
    public SmbComNegotiate(final Configuration config, final boolean signingEnforced) {
        super(config, SMB_COM_NEGOTIATE);
        this.signingEnforced = signingEnforced;
        setFlags2(config.getFlags2());

        if (config.getMinimumVersion().isSMB2()) {

    private Invisible() {
      super("CharMatcher.invisible()", RANGE_STARTS.toCharArray(), RANGE_ENDS.toCharArray());
    }
  }

  /** Implementation of {@link #singleWidth()}. */
  private static final class SingleWidth extends RangesMatcher {

    static final CharMatcher INSTANCE = new SingleWidth();

    private SingleWidth() {
      super(
          "CharMatcher.singleWidth()",