}
  }

  @Test fun headersEquals() {
    val headers1 =
      Headers.Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    val headers2 =
      Headers.Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    assertThat(headers2).isEqualTo(headers1)

          X deltaToCeiling = minus(roundCeiling, x);
          int diff = deltaToFloor.compareTo(deltaToCeiling);
          if (diff < 0) { // closer to floor
            return roundFloorAsDouble;
          } else if (diff > 0) { // closer to ceiling
            return roundCeilingAsDouble;
          }
          // halfway between the representable values; do the half-whatever logic
          switch (mode) {

	finished := make(chan struct{})
	go func() {
		globalMRFState.shutdown()
		close(finished)
	}()
	select {
	case <-time.After(shutdownTimeout):
	case <-finished:
	}
}

func handleSignals() {
	// Custom exit function
	exit := func(success bool) {
		if globalLoggerOutput != nil {
			globalLoggerOutput.Close()
		}

		// If global profiler is set stop before we exit.
		globalProfilerMu.Lock()

// as an error to be reported.
func ReadFileWithFileInfo(name string) ([]byte, fs.FileInfo, error) {
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()

	st, err := f.Stat()
	if err != nil {
		return nil, nil, err
	}

	dst := make([]byte, st.Size())
	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

     */
    OutputStream getOutput () throws CIFSException;


    /**
     * {@inheritDoc}
     * 
     * @throws CIFSException
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close () throws CIFSException;


    /**
     * @return whether the FD is open and valid
     */
    boolean isOpen ();


    /**

func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()
	for tok == scanner.EOF && len(s.tr) > 1 {
		tos.Close()
		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

func (s *Stack) Text() string {
	return s.tr[len(s.tr)-1].Text()

func TestBuffConnReadTimeout(t *testing.T) {
	l, err := net.Listen("tcp", "localhost:0")
	if err != nil {
		t.Fatalf("unable to create listener. %v", err)
	}
	defer l.Close()
	serverAddr := l.Addr().String()

	tcpListener, ok := l.(*net.TCPListener)
	if !ok {
		t.Fatalf("failed to assert to net.TCPListener")
	}

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {

        this.pipe = pipe;
        this.dcePipe = ( pipe.pipeType & SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT ) == SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT;
        path = pipe.unc;
    }

    public void close() throws IOException {
        pipe.close();
    }
    public void write( int b ) throws IOException {
        tmp[0] = (byte)b;
        write( tmp, 0, 1 );
    }
    public void write( byte[] b ) throws IOException {

 * 
 * @author mbechler
 *
 */
public interface SmbRandomAccess extends DataOutput, DataInput, AutoCloseable {

    /**
     * Close the file
     * 
     * @throws SmbException
     */
    @Override
    void close () throws SmbException;


    /**
     * Read a single byte from the current position
     * 
     * @return read byte, -1 if EOF
     * @throws SmbException

      StringWriter target = new StringWriter(2 * n);
      OutputStream encodingStream = encoding.encoding.encodingStream(target);
      encodingStream.write(encodingInputs[i & INPUTS_MASK]);
      encodingStream.close();
      tmp += target.getBuffer().length();
    }
    return tmp;
  }

  @Benchmark
  public int decodingStream(int reps) throws IOException {
    int tmp = 0;
    byte[] target = new byte[n];