}
    val multimap = mapOf("Set-Cookie" to cookieStrings)
    try {
      cookieHandler.put(url.toUri(), multimap)
    } catch (e: IOException) {
      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {

    checkNotNull(annotationType);
    return FluentIterable.from(annotations).filter(annotationType).first().orNull();
  }

  /**
   * @since 18.0
   */
  @Override
  public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationType) {
    @Nullable A[] result =
        FluentIterable.from(annotations).filter(annotationType).toArray(annotationType);

 *
 * <ul>
 *   <li><b>Methods that return a reader:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned reader is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are
 *       typically implemented by opening a reader using one of the methods in the first category,

 * It also uses an AtomicBoolean to track whether the thread is running.
 * </p>
 *
 * <p>
 * The expired method is called when a timeout occurs.
 * It interrupts the running thread up to a maximum number of times.
 * The stop method is called to stop the timeout target.
 * </p>
 */
public class AccessTimeoutTarget implements TimeoutTarget {

    @Test
    void testRun_successfulClose() throws CIFSException {
        // Simulate the shutdown hook being run
        context.run();

        assertTrue(context.isCloseCalled()); // Verify close() was called
    }

    @Test
    void testRun_closeThrowsException() throws CIFSException {
        // Create a spy on the context to make close() throw an exception

    void connectLogon_throws_propagates() throws Exception {
        // Arrange
        doThrow(new SmbException("login failed")).when(tree).connectLogon(context);

        // Act + Assert
        SmbException ex = assertThrows(SmbException.class, () -> tree.connectLogon(context));
        assertEquals("login failed", ex.getMessage());
        verify(tree).connectLogon(context);
    }

    @Test

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
                ComponentUtil.getKeyMatchHelper().update();
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

 * {@link #callAndAssertBlocks} method is ever called in a test, the lock-like object must have a
 * method equivalent to {@link java.util.concurrent.locks.ReentrantLock#hasQueuedThread(Thread)}. If
 * the {@link #callAndAssertWaits} method is ever called in a test, the lock-like object must have a
 * method equivalent to {@link

        this(5, 10, 100, Duration.ofMinutes(30), Duration.ofMinutes(5));
    }

    /**
     * Create rate limiter with custom settings
     *
     * @param maxAttemptsPerAccount max failed attempts per account before lockout
     * @param maxAttemptsPerIp max attempts from single IP
     * @param maxGlobalAttemptsPerMinute max global attempts per minute
     * @param lockoutDuration duration to lock out account/IP