void parseSetsMechanismToken() throws IOException {
        TestSpnegoToken t = new TestSpnegoToken();
        byte[] raw = new byte[] { 5, 6 };
        t.parse(raw);
        assertTrue(t.isParsed(), "parse should mark parsed");
        assertArrayEquals(raw, t.getMechanismToken(), "parse should set mechanismToken");
    }

    @Test
    @DisplayName("parse throws IOException on null input")
    void parseThrowsOnNull() {

    void ensureDFSResolved_throws() throws Exception {
        // Arrange: configure the mock to throw
        doThrow(new CIFSException("DFS resolution failed")).when(handle).ensureDFSResolved();

        // Act + Assert: exception is propagated with message
        CIFSException ex = assertThrows(CIFSException.class, () -> handle.ensureDFSResolved());

     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

    private static ASN1Sequence parseSequence(byte[] token) throws PACDecodingException {
        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos ApReq");

  @DoNotCall("Always throws UnsupportedOperationException")
  public void addAll(RangeSet<C> other) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the {@code RangeSet} unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")

        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 {

    public byte[] compress(byte[] data, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        return compress(data, 0, data.length, algorithm);
    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final int setCount(E element, int count) {
    throw new UnsupportedOperationException();
  }

  /**

  private final OkHttpClient client;

  public CacheResponse(File cacheDirectory) throws Exception {
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()

     *
     * @param handle the DCERPC handle
     * @param server the server name
     * @param access the access rights
     * @throws IOException if an I/O error occurs
     */
    public LsaPolicyHandle(final DcerpcHandle handle, String server, final int access) throws IOException {
        this.handle = handle;
        if (server == null) {
            server = "\\\\";
        }

            + " see the Javadoc for Files.createTempDir().";

    @Override
    File createTempDir() {
      throw new IllegalStateException(MESSAGE);
    }

    @Override
    File createTempFile(String prefix) throws IOException {
      throw new IOException(MESSAGE);
    }
  }

  private TempFileCreator() {}