}

    @Test
    public void test_multipleInstancesHaveIndependentSettings() {
        final SuppressErrorReportValve valve1 = new SuppressErrorReportValve();
        final SuppressErrorReportValve valve2 = new SuppressErrorReportValve();

        valve1.setShowReport(true);
        valve1.setShowServerInfo(true);

        // valve2 should still have default values

import okio.BufferedSource;
import okio.ForwardingSource;
import okio.Okio;
import okio.Source;

public final class Progress {

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    final ProgressListener progressListener = new ProgressListener() {
      boolean firstUpdate = true;

     * if the output was not already written directly to stdout.
     */
    public final ByteArrayOutputStream outputBuffer = new ByteArrayOutputStream()

    @Inject
    protected FileSystemOperations getFileSystemOperations() {
        throw new UnsupportedOperationException();
    }

    @TaskAction
    final void executeTask() {
        AntBuilder ant = new AntBuilder()

    @Execute
    public StreamResponse get$file(final String id) {
        final String filename = new String(Base64.getDecoder().decode(id), StandardCharsets.UTF_8).replace("..", "").replaceAll("\\s", "");
        final String logFilePath = systemHelper.getLogFilePath();
        if (StringUtil.isNotBlank(logFilePath) && isLogFilename(filename)) {
            final Path path = Paths.get(logFilePath, filename);

     */
    public void setType(final CredentialsType type) {
        this.type = type;
    }

    /**
     * Gets the username.
     *
     * @return the username
     */
    public String getUsername() {
        return username;
    }

    /**
     * Sets the username.
     *
     * @param username the username
     */
    public void setUsername(final String username) {

 * See {@link MultiEdgesConnecting} for a class that works with parallel edges.
 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
final class EdgesConnecting<E> extends AbstractSet<E> {

  private final Map<?, E> nodeToOutEdge;
  private final Object targetNode;

  EdgesConnecting(Map<?, E> nodeToEdgeMap, Object targetNode) {
    this.nodeToOutEdge = checkNotNull(nodeToEdgeMap);

 */
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.
     *