throw new SmbException("Failed to connect to server", uhe);
        }
        catch ( SmbException se ) {
            throw se;
        }
        catch ( IOException ioe ) {
            throw new SmbException("Failed to connect to server", ioe);
        }
    }


    /**
     * @param loc
     * @return tree handle
     * @throws IOException
     */

                minioClient = builder.build();
            } catch (final Exception e) {
                throw new IOException("Failed to create MinioClient.", e);
            }
        }

        @Override
        public InputStream getInputStream() throws IOException {
            if (minioClient == null) {
                throw new IOException("Access is not ready.");
            }
            try {

  private static <X extends Exception> void wrapAndThrowExceptionOrError(
      Throwable cause, Class<X> exceptionClass) throws X {
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    }
    if (cause instanceof RuntimeException) {
      throw new UncheckedExecutionException(cause);
    }
    throw newWithCause(exceptionClass, cause);
  }

  /*

    protected abstract void doSendFragment(byte[] buf,
                int off,
                int length,
                boolean isDirect) throws IOException;
    protected abstract void doReceiveFragment(byte[] buf, boolean isDirect) throws IOException;
    public abstract void close() throws IOException;

            }
        }
    }


    @Override
    public int recv ( byte[] buf, int off, int len ) throws IOException {
        return getInput().readDirect(buf, off, len);

    }


    @Override
    public void send ( byte[] buf, int off, int length ) throws IOException {
        getOutput().writeDirect(buf, off, length, 1);
    }


    /**
     * 
     * {@inheritDoc}

                        }
                        break;
                }
            } catch( IOException ioe ) {
            }
        }
        throw new UnknownHostException( name.name );
    }
    NbtAddress[] getNodeStatus( NbtAddress addr ) throws UnknownHostException {
        int n, srcHashCode;
        NodeStatusRequest request;
        NodeStatusResponse response;

      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {
    if (c == null) throw new NullPointerException();

   *
   * <p><b>Java 8+ users:</b> the {@code Stream} equivalent to this method is {@code
   * stream.collect(MoreCollectors.onlyElement())}.
   *
   * @throws NoSuchElementException if the iterable is empty
   * @throws IllegalArgumentException if the iterable contains multiple elements
   */
  @ParametricNullness
  public static <T extends @Nullable Object> T getOnlyElement(Iterable<T> iterable) {

    }


    /**
     * {@inheritDoc}
     * 
     * @throws CIFSException
     * 
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get ( String url ) throws CIFSException {
        try {
            return new SmbFile(url, this);
        }
        catch ( MalformedURLException e ) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the set unmodified.
   *
   * @since 12.0
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @GwtIncompatible // NavigableSet
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  @CheckForNull