*/
    public String validatePath(String path) throws SmbException {
        if (path == null || path.isEmpty()) {
            throw new SmbException("Path cannot be null or empty");
        }

        // Check length
        if (path.length() > maxPathLength) {
            throw new SmbException("Path exceeds maximum length: " + path.length() + " > " + maxPathLength);
        }

        // Check for null bytes

      val privateHost = isPrivateHost(hostname)

      if (privateHost && !resolvePrivateAddresses) {
        throw UnknownHostException("private hosts not resolved")
      }

      if (!privateHost && !resolvePublicAddresses) {
        throw UnknownHostException("public hosts not resolved")
      }
    }

    return lookupHttps(hostname)
  }

  @Throws(UnknownHostException::class)

      @Nullable Object p4) {
    if (reference == null) {
      throw new NullPointerException(Platform.lenientFormat(errorMessageTemplate, p1, p2, p3, p4));
    }
    return reference;
  }

  /*
   * All recent hotspots (as of 2009) *really* like to have the natural code
   *
   * if (guardExpression) {
   *    throw new BadException(messageExpression);
   * }
   *

   * {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>
   *   <li>{@code view.equals(view)} evaluates to {@code true} (but any other {@code equals()}
   *       expression involving {@code view} will throw)
   *   <li>{@code hashCode()} does not throw

        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was absent");
                }));
    expectAdded(e3());
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})

     */
    @SuppressWarnings("unchecked")
    public <T extends Decodable> T getInfo(final Class<T> clazz) throws CIFSException {
        if (!clazz.isAssignableFrom(this.info.getClass())) {
            throw new CIFSException("Incompatible file information class");
        }
        return (T) getInfo();
    }

    /**
     * {@inheritDoc}
     *

        if (src == null || dst == null) {
            throw new IllegalArgumentException("Arrays cannot be null");
        }
        if (srcOffset < 0 || dstOffset < 0 || length < 0) {
            throw new IllegalArgumentException("Offsets and length must be non-negative");
        }
        if (srcOffset + length > src.length) {
            throw new IllegalArgumentException(

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

            failedValidations.incrementAndGet();
            throw new SmbException("Negative offset: " + offset);
        }

        if (length < 0) {
            failedValidations.incrementAndGet();
            throw new SmbException("Negative length: " + length);
        }

        if (fileSize < 0) {
            failedValidations.incrementAndGet();
            throw new SmbException("Invalid file size: " + fileSize);
        }

                    log.trace("Failed to send nameservice request for " + name.name, ioe);
                }
                throw new UnknownHostException(name.name);
            } catch (final IOException ioe) {
                log.info("Failed to send nameservice request for " + name.name, ioe);
                throw new UnknownHostException(name.name);
            }

            if (response.received && response.resultCode == 0) {