// of
        // InputStream.read(byte[], int, int)
        // See https://github.com/google/guava/issues/3542
        Reader reader = new StringReader(cannotDecode);
        InputStream decodingStream = encoding.decodingStream(reader);
        try {
          ByteStreams.exhaust(decodingStream);
          fail("Expected DecodingException");
        } catch (DecodingException expected) {

            alloc_hint = length - alloc_hint_index;
            buf.enc_ndr_long(alloc_hint);
        }

        buf.setIndex(start);
        encode_header(buf);
        buf.setIndex(start + length);
    }
    public void decode(NdrBuffer buf) throws NdrException {
        decode_header(buf);

        if (ptype != 12 && ptype != 2 && ptype != 3 && ptype != 13)
            throw new NdrException("Unexpected ptype: " + ptype);

            buf.enc_ndr_long(this.alloc_hint);
        }

        buf.setIndex(start);
        encode_header(buf);
        buf.setIndex(start + this.length);
    }


    @Override
    public void decode ( NdrBuffer buf ) throws NdrException {
        decode_header(buf);

        if ( this.ptype != 12 && this.ptype != 2 && this.ptype != 3 && this.ptype != 13 )

            LOGGER.warn("The {} file does not exist. The --resume / -r feature will not work.", path);
            return properties;
        }

        try (Reader reader = Files.newBufferedReader(path)) {
            properties.load(reader);
        } catch (IOException e) {
            LOGGER.warn("Unable to read {}. The --resume / -r feature will not work.", path);
        }

        return properties;
    }

    }

    @Override
    public String getSinkContents() throws IOException {
      Path file = getPath();
      try (Reader reader = java.nio.file.Files.newBufferedReader(file, Charsets.UTF_8)) {
        StringBuilder builder = new StringBuilder();
        for (int c = reader.read(); c != -1; c = reader.read()) {
          builder.append((char) c);
        }
        return builder.toString();
      }
    }
  }

  }

  /**
   * Returns an {@code InputStream} that decodes base-encoded input from the specified {@code
   * Reader}. The returned stream throws a {@link DecodingException} upon decoding-specific errors.
   */
  @J2ktIncompatible
  @GwtIncompatible // Reader,InputStream
  public abstract InputStream decodingStream(Reader reader);

  /**
   * Returns a {@code ByteSource} that reads base-encoded bytes from the specified {@code

    Closeables.close(null, false);
  }

  public void testCloseQuietlyNull_inputStream() {
    Closeables.closeQuietly((InputStream) null);
  }

  public void testCloseQuietlyNull_reader() {
    Closeables.closeQuietly((Reader) null);
  }

  // Set up a closeable to expect to be closed, and optionally to throw an
  // exception.
  private void setupCloseable(boolean shouldThrow) throws IOException {

 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.base.Charsets.UTF_8;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;

/**
 * A char source for testing that has configurable options.
 *
 * @author Colin Decker
 */
public class TestCharSource extends CharSource implements TestStreamSupplier {

    static final int NBSTAT = 0x0021;
    static final int IN = 0x0001;
    static final int A = 0x0001;
    static final int NS = 0x0002;
    static final int NULL = 0x000a;

    static final int HEADER_LENGTH = 12;

    // header field offsets
    static final int OPCODE_OFFSET = 2;
    static final int QUESTION_OFFSET = 4;
    static final int ANSWER_OFFSET = 6;
    static final int AUTHORITY_OFFSET = 8;

            return;
        }

        StringBuilder builder = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new StringReader(rawCommentText));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.replaceFirst("\\s*\\* ?", "");
                if (line.startsWith("@")) {