authenticator = null;
    }

    @AfterEach
    public void tearDown() throws Exception {
        if (authenticator != null) {
            authenticator.close();
        }
    }

    @Test
    @DisplayName("Test password stored as char array")
    void testPasswordStoredAsCharArray() throws Exception {
        authenticator = new NtlmPasswordAuthenticator("DOMAIN", "username", "password123");

  }

  /**
   * Guaranteed to throw an exception and leave the map unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable Entry<K, V> pollFirstEntry() {
    throw new UnsupportedOperationException();
  }

    }
  }

  @Throws(IOException::class)
  fun flush() {
    withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

    Settings buildSettings(MavenExecutionRequest request) throws IOException, XmlPullParserException;

    /**
     * @return a <code>Settings</code> object from the user settings file.
     * @throws IOException if any
     * @throws XmlPullParserException if any
     */
    Settings buildSettings() throws IOException, XmlPullParserException;

    /**

                }
            } else {
                throw new IllegalStateException("unexpected task " + task);
            }
        }
        return mojoExecutions;
    }

    private Map<String, List<MojoExecution>> calculateLifecycleMappings(
            MavenSession session, MavenProject project, String lifecyclePhase)

     * @return The extracted descriptor or {@code null} if no descriptor was found.
     * @throws IOException If the descriptor is present but could not be parsed.
     */
    public ExtensionDescriptor build(File extensionJar) throws IOException {
        ExtensionDescriptor extensionDescriptor = null;

        if (extensionJar.isFile()) {

     * @param repositories
     * @param session
     * @return PluginDescriptor The component descriptor for the Maven plugin.
     * @throws PluginNotFoundException The plugin could not be found in any repositories.
     * @throws PluginResolutionException The plugin could be found but could not be resolved.
     * @throws InvalidPluginDescriptorException
     */
    @Override
    public PluginDescriptor loadPlugin(

        }
    }

    public void test_cleanup() throws Exception {
        final String sessionId = crawler.getSessionId();

        // Add some test data
        crawler.addUrl("http://example.com/");

        // Perform cleanup - should not throw exception
        crawler.cleanup(sessionId);
    }

    public void test_stop() throws Exception {

   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

  @SuppressWarnings("unchecked") // not really safe, but that's the point
  private Error throwIt(Throwable t) throws T {
    throw (T) t;
  }

  private SneakyThrows() {}

        });

        assertEquals("Missing AvEOL", exception.getMessage(), "Should throw exception for truncated data");
    }

    /**
     * Test decode with unknown AvPair type
     */
    @Test
    @DisplayName("Decode unknown AvPair type as generic AvPair")
    void testDecodeUnknownType() throws CIFSException {
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        int unknownType = 0xFF;