private final TestByteSink byteSink;

  public TestCharSink(TestOption... options) {
    this.byteSink = new TestByteSink(options);
  }

  public String getString() {
    return new String(byteSink.getBytes(), UTF_8);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSink.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {
    return byteSink.wasStreamClosed();
  }

  void writeChars(String s);

  @Override
  void writeUTF(String s);

  /**
   * @deprecated This method is dangerous as it discards the high byte of every character. For
   *     UTF-8, use {@code write(s.getBytes(StandardCharsets.UTF_8))}.
   */
  @Deprecated
  @Override
  void writeBytes(String s);

  /** Returns the contents that have been written to this instance, as a byte array. */
  byte[] toByteArray();

        Method calcMethod = findMethod(transport.getClass(), "calculatePreauthHash", byte[].class, int.class, int.class, byte[].class);
        calcMethod.setAccessible(true);

        byte[] input = "test data".getBytes();
        byte[] oldHash = new byte[64];

        byte[] newHash = (byte[]) calcMethod.invoke(transport, input, 0, input.length, oldHash);

        assertNotNull(newHash);

  void writeChars(String s);

  @Override
  void writeUTF(String s);

  /**
   * @deprecated This method is dangerous as it discards the high byte of every character. For
   *     UTF-8, use {@code write(s.getBytes(StandardCharsets.UTF_8))}.
   */
  @Deprecated
  @Override
  void writeBytes(String s);

  /** Returns the contents that have been written to this instance, as a byte array. */
  byte[] toByteArray();

    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(this.maxReferralLevel, dst, dstIndex);
        dstIndex += 2;
        final byte[] pathBytes = this.path.getBytes(StandardCharsets.UTF_16LE);
        System.arraycopy(pathBytes, 0, dst, dstIndex, pathBytes.length);
        dstIndex += pathBytes.length;
        SMBUtil.writeInt2(0, dst, dstIndex);
        dstIndex += 2; // null terminator

        if (text == null) {
            return null;
        }

        final MessageDigest msgDigest = getInstance(algorithm);
        try {
            msgDigest.update(text.getBytes("UTF-8"));
        } catch (final UnsupportedEncodingException e) {
            throw new ClIllegalStateException(e);
        }
        final byte[] digest = msgDigest.digest();

        writeInt2(buffer, offset + 10, STRUCTURE_SIZE);  // DataOffset
        writeInt4(buffer, offset + 12, STRUCTURE_SIZE);  // DataLength
        
        // Name
        System.arraycopy(getName().getBytes(), 0, buffer, offset + 16, nameLen);
        
        // Data (16 bytes of reserved)
        int dataOffset = offset + 16 + nameLen;
        dataOffset = (dataOffset + 7) & ~7;  // 8-byte alignment
        

        FileUtil.write(
                file1.getAbsolutePath(),
                "token1,seg1,reading1,pos1\ntoken2,seg2,reading2,pos2\ntoken3,seg3,reading3,pos3"
                        .getBytes(Constants.UTF_8));
    }

    @Override
    protected void tearDown() throws Exception {
        file1.delete();
    }
    */

    @Override
    public void setUp() throws Exception {

                flags |= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED;
                domain = suppliedDomainString.toUpperCase().getBytes(getOEMEncoding());
                size += domain.length;
            } else {
                flags &= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED ^ 0xffffffff;
            }

            byte[] workstation = {};

        return 0;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        byte[] descr;

        try {
            descr = DESCR.getBytes("ASCII");
        } catch (final UnsupportedEncodingException uee) {
            return 0;
        }

        writeInt2(NET_SHARE_ENUM, dst, dstIndex);
        dstIndex += 2;