/**
     * Creates a new blank SMB1 response.
     *
     * @param config the CIFS configuration
     */
    public SmbComBlankResponse(final Configuration config) {
        super(config);
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

     * @param tmpDir the temporary directory to create the file in
     */
    public ContentOutputStream(final int threshold, final File tmpDir) {
        super(threshold, PREFIX, SUFFIX, tmpDir);
    }

    @Override
    public File getFile() {
        done = true;
        return super.getFile();
    }

    /**
     * Closes the stream and deletes the temporary file if it was not retrieved.

        assertEquals(MsrpcSamrCloseHandle.DCERPC_FIRST_FRAG | MsrpcSamrCloseHandle.DCERPC_LAST_FRAG, msrpcSamrCloseHandle.getFlags(),
                "flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");
        // Verify that the super constructor was called with the correct handle.
        // This is implicitly tested by the object being created without error and
        // the fields set by the constructor being correct.
    }

    return specialized;
  }

  @SuppressWarnings("unchecked") // The declaring class is T's raw class, or one of its supertypes.
  @Override
  public final Class<? super T> getDeclaringClass() {
    return (Class<? super T>) member.getDeclaringClass();
  }

  /** Returns the type of {@code T}. */
  // Overridden in TypeToken#method() and TypeToken#constructor()

  /** Constructor for use by subclasses. */
  protected ForwardingSortedMap() {}

  @Override
  protected abstract SortedMap<K, V> delegate();

  @Override
  public @Nullable Comparator<? super K> comparator() {
    return delegate().comparator();
  }

  @Override
  @ParametricNullness
  public K firstKey() {
    return delegate().firstKey();
  }

  @Override

  }

  private HashMultimap(int expectedKeys, int expectedValuesPerKey) {
    super(Platform.newHashMapWithExpectedSize(expectedKeys));
    Preconditions.checkArgument(expectedValuesPerKey >= 0);
    this.expectedValuesPerKey = expectedValuesPerKey;
  }

  private HashMultimap(Multimap<? extends K, ? extends V> multimap) {
    super(Platform.newHashMapWithExpectedSize(multimap.keySet().size()));
    putAll(multimap);
  }

     * @param servletPath The custom servlet path for this web API request
     */
    public WebApiRequest(final HttpServletRequest request, final String servletPath) {
        super(request);
        this.servletPath = servletPath;
    }

    /**
     * Gets the servlet path for this request.
     * Returns the custom servlet path unless the query string contains SAStruts.method.
     *

    return new Out();
  }

  private final class Out extends TestOutputStream {

    Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

final class RegularImmutableSet<E> extends ForwardingImmutableSet<E> {
  static final RegularImmutableSet<Object> EMPTY =
      new RegularImmutableSet<Object>(Collections.emptySet());

  RegularImmutableSet(Set<E> delegate) {
    super(delegate);
  }

     * Creates a new {@link InterruptedRuntimeException} with the specified cause.
     *
     * @param e
     *            the cause
     */
    public InterruptedRuntimeException(final InterruptedException e) {
        super(e);
    }