throws CIFSException {
        return delegate.getDfsReferrals(ctx, name, targetHost, targetDomain, rn);
    }

    @Override
    public boolean isSigningOptional() throws SmbException {
        return delegate.isSigningOptional();
    }

    @Override
    public boolean isSigningEnforced() throws SmbException {
        return delegate.isSigningEnforced();

    /**
     * Creates a new witness RPC client.
     *
     * @param serverAddress the witness server address
     * @param context the CIFS context
     * @throws IOException if connection fails
     */
    public WitnessRpcClient(InetAddress serverAddress, CIFSContext context) throws IOException {
        this.serverAddress = serverAddress;
        this.context = context;

        try {

  }

  public void testFrom_failedInput() throws Exception {
    assertFinallyFailsWithException(failedClosingFuture());
  }

  public void testFrom_cancelledInput() throws Exception {
    assertBecomesCanceled(ClosingFuture.from(immediateCancelledFuture()));
  }

  public void testEventuallyClosing() throws Exception {
    ClosingFuture<String> closingFuture =

    }

    /**
     * Test successful parsing with valid data.
     */
    @Test
    public void testValidNegotiateResponse() throws SMBProtocolDecodingException {
        byte[] validBuffer = createValidNegotiateResponseBuffer();

        // Should not throw any exception
        int bytesRead = response.readBytesWireFormat(validBuffer, 0);

        assertTrue(bytesRead > 0);

     * @param keys array of Kerberos keys for decryption
     * @throws PACDecodingException if token decoding fails
     */
    public KerberosToken(byte[] token, KerberosKey[] keys) throws PACDecodingException {

        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {

     * @param key
     * @param cipher
     * @return
     * @throws GeneralSecurityException
     * @throws InvalidKeyException
     * @throws InvalidAlgorithmParameterException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    private static byte[] decryptDES(byte[] data, Key key, Cipher cipher) throws GeneralSecurityException, InvalidKeyException,

            this.fileItem = fileItem;
        }

        @Override
        public byte[] getFileData() throws IOException {
            return fileItem.get();
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return fileItem.getInputStream();
        }

        @Override
        public String getContentType() {

      notifyAll()
    }
  }

  @Throws(IOException::class)
  internal fun checkOutNotClosed() {
    when {
      sink.closed -> throw IOException("stream closed")
      sink.finished -> throw IOException("stream finished")
      errorCode != null -> throw errorException ?: StreamResetException(errorCode!!)
    }
  }

  /**

        ComponentUtil.register(crawler, Crawler.class.getCanonicalName());
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
        // Clear static fields
        clearStaticFields();
    }

    private void clearStaticFields() throws Exception {
        Field runningField = Crawler.class.getDeclaredField("running");
        runningField.setAccessible(true);

            this.handle = handle;
        }

        @Override
        public void encode_in(final NdrBuffer _dst) throws NdrException {
            this.handle.encode(_dst);
        }

        @Override
        public void decode_out(final NdrBuffer _src) throws NdrException {
            this.retval = _src.dec_ndr_long();
        }
    }

    /**