* with it.
 *
 * @throws IOException if a network error occurs
 */

    public void close() throws IOException {
        file.close();
        tmp = null;
    }

/**
 * Writes the specified byte to this file output stream.
 *
 * @throws IOException if a network error occurs
 */

    public void write( int b ) throws IOException {
        tmp[0] = (byte)b;

  }

  public void testBulkLoad_extra() throws ExecutionException {
    CacheLoader<Object, Object> loader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) throws Exception {
            return new Object();
          }

          @Override
          public Map<Object, Object> loadAll(Iterable<?> keys) throws Exception {

    throw UnsupportedOperationException()
  }

  @Throws(SSLPeerUnverifiedException::class)
  override fun getPeerPrincipal(): Principal {
    throw UnsupportedOperationException()
  }

  override fun getProtocol(): String {
    throw UnsupportedOperationException()
  }

  override fun getSessionContext(): SSLSessionContext {
    throw UnsupportedOperationException()
  }

     *
     * @param expression not null expression
     * @param root       not null object
     * @return the object defined by the expression
     * @throws IntrospectionException if any
     */
    public static Object evaluate(@Nonnull String expression, @Nullable Object root) throws IntrospectionException {
        return evaluate(expression, root, true);
    }

    /**
     * <p>

    }

    @Override
    public Model read(File input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");
        return read(input.toPath(), options);
    }

    @Override
    public Model read(Path path, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(path, "path cannot be null");

   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean removeIf(Predicate<? super E> filter) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the collection unmodified.
   *

    /**
     * Ensures that the file descriptor is openend
     * 
     * @throws CIFSException
     */
    public void open () throws CIFSException {
        try ( SmbFileHandleImpl fh = ensureOpen() ) {}
    }


    /**
     * Closes this output stream and releases any system resources associated
     * with it.
     *
     * @throws IOException
     *             if a network error occurs
     */

    } catch (IOException e) {
      result.close();
      throw e;
    }
    return result;
  }

  @Override public Socket createSocket(
      String host, int port, InetAddress localHost, int localPort) throws IOException {
    return createSocket(host, port);
  }

  @Override public Socket createSocket(InetAddress host, int port) throws IOException {
    Socket result = createSocket();

    try {

        }
    }


    /**
     * @param tc
     * @param chlng
     * @return the signing key
     * @throws SmbException
     * @throws GeneralSecurityException
     */
    public byte[] getSigningKey ( CIFSContext tc, byte[] chlng ) throws SmbException, GeneralSecurityException {
        switch ( tc.getConfig().getLanManCompatibility() ) {
        case 0:
        case 1:
        case 2:

    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

  private static Runnable runnableThrowing(final RuntimeException e) {
    return new Runnable() {
      @Override
      public void run() {
        throw e;
      }
    };
  }

  @SuppressWarnings("serial")