assertEquals(20, counter.skip(30));
    assertEquals(20, counter.getCount());
    assertEquals(0, counter.skip(20));
    assertEquals(20, counter.getCount());

    // Test reading a single byte while we're in the right state
    assertEquals(-1, counter.read());
    assertEquals(20, counter.getCount());
  }

  public void testReadArrayEOF() throws IOException {

 *   <li>Audit logging of session operations</li>
 *   <li>Performance monitoring of nested operations</li>
 * </ul>
 *
 * @param context The context identifier for this request trace, helping to identify the scope or purpose
 *                of the request. May be null if no specific context is needed.
 * @param parent The parent request trace that led to this request, establishing the chain of nested

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * A chain of {@link ReadingConverter} implementations that applies each converter in sequence to generate possible reading variations of a given text.
 * It maintains a list of ReadingConverter instances and iterates through them, applying each converter to the input text and accumulating the results.

	// ensure that this error is sticky.
	err error
}

type fileReader interface {
	io.Reader
	fileState

	WriteTo(io.Writer) (int64, error)
}

// NewReader creates a new [Reader] reading from r.
func NewReader(r io.Reader) *Reader {
	return &Reader{r: r, curr: &regFileReader{r, 0}}
}

// Next advances to the next entry in the tar archive.

     */
    int TYPE_COMM = 0x40;

    /* open flags */

    /**
     * Open for reading only.
     */
    int O_RDONLY = 0x01;
    /**
     * Open for writing only.
     */
    int O_WRONLY = 0x02;
    /**
     * Open for reading and writing.
     */
    int O_RDWR = 0x03;
    /**
     * Open in append mode.
     */
    int O_APPEND = 0x04;

		if err := setxattr(path, name, value); err != nil {
			log.Fatalln(fmt.Errorf("setting attribute %s failed with: %v", name, err))
		}
	} else {
		if name == "" {
			log.Fatalln("you must specify an attribute name for reading")
		}
		var names []string
		if name == "." {
			attrs, err := listxattr(path)
			if err != nil {
				log.Fatalln(fmt.Errorf("listing attributes failed with: %v", err))
			}
			names = append(names, attrs...)

                        logger.debug("Reusing existing session (both userId null). sessionId={}", sessionId);
                    }
                    return session;
                } else if (userId != null && userId.equals(sessionUserId)) {
                    session.touch();
                    if (logger.isDebugEnabled()) {
                        logger.debug("Reusing existing session. sessionId={}, userId={}", sessionId, userId);

	if flag.NArg() != 1 {
		usage()
	}

	f, err := objfile.Open(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	tab, err := f.PCLineTable()
	if err != nil {
		log.Fatalf("reading %s: %v", flag.Arg(0), err)
	}

	stdin := bufio.NewScanner(os.Stdin)
	stdout := bufio.NewWriter(os.Stdout)

	for stdin.Scan() {
		p := stdin.Text()
		if strings.Contains(p, ":") {

   * draining it is flipped (undrained bytes between position and limit).
   */
  private ByteBuffer byteBuffer;

  /** Whether we've finished reading the reader. */
  private boolean endOfInput;

  /** Whether we're copying encoded bytes to the caller's buffer. */
  private boolean draining;

  /** Whether we've successfully flushed the encoder. */

     * @throws CIFSException if an error occurs retrieving the session key
     */
    byte[] getSessionKey() throws CIFSException;

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream
     */
    @Override
    SmbPipeInputStream getInput() throws CIFSException;