assertNotNull(secured);
        assertEquals("INTERFACE_METHOD_ROLE", secured.value()[0]);
    }

    // Test implementation of secured interface
    static class SecuredInterfaceImpl implements SecuredInterface {
        @Override
        public void securedMethod() {
        }
    }

    @Test
    public void test_interfaceImplementation() {

     */
    String getMailReturnPath();

    /**
     * The simple implementation for configuration.
     * @author FreeGen
     */
    public static class SimpleImpl extends ObjectiveConfig implements FessEnv {

        /** The serial version UID for object serialization. (Default) */
        private static final long serialVersionUID = 1L;

        public String getLastaDiSmartDeployMode() {

      unused -> {
        throw new AssertionFailedError("This predicate should never have been evaluated");
      };

  /** Instantiable predicate with reasonable hashCode() and equals() methods. */
  static class IsOdd implements Predicate<@Nullable Integer>, Serializable {
    @GwtIncompatible @J2ktIncompatible     private static final long serialVersionUID = 0x150ddL;

    @Override
    public boolean apply(@Nullable Integer i) {

 *
 * @author Jared Levy
 * @author Louis Wasserman
 * @since 2.0 (implements {@code NavigableSet} since 12.0)
 */
// TODO(benyu): benchmark and optimize all creation paths, which are a mess now
@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization
public abstract class ImmutableSortedSet<E> extends ImmutableSet<E>
    implements NavigableSet<E>, SortedIterable<E> {
  /**

        return new ManagedResource<>(resource, resourceId, this);
    }

    /**
     * Wrapper for managed resources
     */
    public static class ManagedResource<T extends AutoCloseable> implements AutoCloseable {
        private final T resource;
        private final String resourceId;
        private final ResourceManager manager;
        private volatile boolean closed = false;

  }

  /**
   * A CharSequence that is composed of multiple chunks. This is used to work around the 64k size
   * limit for string literals in Java.
   */
  private static class ChunksCharSequence implements CharSequence {
    private final ImmutableList<CharSequence> chunks;
    private final int length;
    private final int chunkShift;
    private final int chunkMask;

@SuppressWarnings("ShortCircuitBoolean")
abstract class AbstractTransformFuture<
        I extends @Nullable Object, O extends @Nullable Object, F, T extends @Nullable Object>
    extends FluentFuture.TrustedFuture<O> implements Runnable {
  static <I extends @Nullable Object, O extends @Nullable Object> ListenableFuture<O> createAsync(
      ListenableFuture<I> input,
      AsyncFunction<? super I, ? extends O> function,
      Executor executor) {

            } else if ("test".equals(scope)) {
                result.clear();
            }
        }

        return result;
    }

    private static class ReactorDependencyFilter implements DependencyFilter {

        private final Set<String> keys = new HashSet<>();

        ReactorDependencyFilter(Collection<Artifact> artifacts) {
            for (Artifact artifact : artifacts) {

 * caller's responsibility.
 *
 * @author Paul Marks
 * @since 10.0
 */
@Immutable
@GwtCompatible
public final class HostAndPort implements Serializable {
  /** Magic value indicating the absence of a port number. */
  private static final int NO_PORT = -1;

  /** Hostname, IPv4/IPv6 literal, or unvalidated nonsense. */
  private final String host;

import org.codelibs.core.lang.MethodUtil;
import org.codelibs.core.lang.ModifierUtil;

/**
 * Implementation class of {@link PropertyDesc}.
 *
 * @author higa
 */
public class PropertyDescImpl implements PropertyDesc {

    private static final Object[] EMPTY_ARGS = new Object[0];

    private final String propertyName;

    private final Class<?> propertyType;

    private Method readMethod;