if (token == null) {
                if (len == 0) {
                    return new byte[0];
                }
                throw new CIFSException("token is null but len > 0");
            }
            if (off < 0 || len < 0 || off > token.length || off + len > token.length) {
                throw new CIFSException("invalid offset/length");
            }
            return Arrays.copyOfRange(token, off, off + len);
        }

            }
        } catch (ConnectionException e) {
            throw new TransferFailedException("Connection failed: " + e.getMessage(), e);
        } catch (AuthenticationException e) {
            throw new TransferFailedException("Authentication failed: " + e.getMessage(), e);
        } catch (AuthorizationException e) {
            throw new TransferFailedException("Authorization failed: " + e.getMessage(), e);

t=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{},e=t.action,n=void 0===e?"copy":e,o=t.container,e=t.target,t=t.text;if("copy"!==n&&"cut"!==n)throw new Error('Invalid "action" value, use either "copy" or "cut"');if(void 0!==e){if(!e||"object"!==l(e)||1!==e.nodeType)throw new Error('Invalid "target" value, use a valid Element');if("copy"===n&&e.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if("cut"===n&&(e.hasAttribute("readon...

      throw new UnsupportedOperationException();
    }

    @Override
    public boolean retainAll(Collection<?> elementsToRetain) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int setCount(@ParametricNullness E element, int count) {

    apply {
      actions += { stream ->
        val actual = stream.source.readUtf8(expected.utf8Size())
        if (actual != expected) throw AssertionError("$actual != $expected")
      }
    }

  fun exhaustRequest() =
    apply {
      actions += { stream ->
        if (!stream.source.exhausted()) throw AssertionError("expected exhausted")
      }
    }

  fun cancelStream() =
    apply {

    }
  }

  @Override
  public void invalidateAll() {
    throw new UnsupportedOperationException();
  }

  @Override
  public CacheStats stats() {
    throw new UnsupportedOperationException();
  }

  @Override
  @J2ktIncompatible // Thread safety complexity
  public ConcurrentMap<K, V> asMap() {
    throw new UnsupportedOperationException();
  }

  /**

            decodeCallCount++;
            if (throwOnDecode) {
                throw new SMBProtocolDecodingException("Test decode error");
            }
            if (buffer == null) {
                throw new SMBProtocolDecodingException("Buffer cannot be null");
            }
            if (bufferIndex < 0 || len < 0) {
                throw new SMBProtocolDecodingException("Invalid buffer parameters");
            }

    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the {@code RangeMap} unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void remove(Range<K> range) {

      call.eventListener.requestFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  @Throws(IOException::class)
  fun finishRequest() {
    try {
      codec.finishRequest()
    } catch (e: IOException) {
      call.eventListener.requestFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  fun responseHeadersStart() {

    Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");
    }

    @Override
    boolean isLessThan(Comparable<?> value) {
      return true;
    }

    @Override
    BoundType typeAsLowerBound() {
      throw new IllegalStateException();
    }

    @Override
    BoundType typeAsUpperBound() {