import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2SetInfoResponse functionality
 */
@DisplayName("Smb2SetInfoResponse Tests")
@MockitoSettings(strictness = Strictness.LENIENT)
class Smb2SetInfoResponseTest {

    private Configuration mockConfig;
    private Smb2SetInfoResponse response;

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);

Here’s a [sample event listener](https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/PrintEventsNonConcurrent.java) that prints each event with a timestamp.

```java
class PrintingEventListener extends EventListener {
  private long callStartNanos;

  private void printEvent(String name) {
    long nowNanos = System.nanoTime();
    if (name.equals("callStart")) {

import com.google.common.base.MoreObjects;
import java.util.Objects;
import java.util.concurrent.Callable;
import org.jspecify.annotations.Nullable;

/**
 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable.
 *
 * <p>Cache statistics are incremented according to the following rules:
 *
 * <ul>
 *   <li>When a cache lookup encounters an existing cache entry {@code hitCount} is incremented.

import com.google.common.base.MoreObjects;
import java.util.Objects;
import java.util.concurrent.Callable;
import org.jspecify.annotations.Nullable;

/**
 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable.
 *
 * <p>Cache statistics are incremented according to the following rules:
 *
 * <ul>
 *   <li>When a cache lookup encounters an existing cache entry {@code hitCount} is incremented.

   * <p>We have chosen this approach over at least two alternatives:
   *
   * <ul>
   *   <li>We could change the serialization of this class incompatibly. We have reserved the right
   *       to make such changes to our serialized forms, and we have made them before, usually
   *       without trouble. In this case, my guess is that our chosen approach is even less likely
   *       to lead to trouble than an incompatible change would be.

import java.util.List;
import java.util.concurrent.Executor;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Test case for {@link AsyncEventBus}.
 *
 * @author Cliff Biffle
 */
@NullUnmarked
public class AsyncEventBusTest extends TestCase {
  private static final String EVENT = "Hello";

  /** The executor we use to fake asynchronicity. */
  private FakeExecutor executor;

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code
   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,

 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`
 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,
  private val launch: Launch? = null,
) : EventListener.Factory {

        assertThrows(SmbAuthException.class, () -> ctx.initSecContext(new byte[] {}, 0, 0));
    }

    @Test
    @DisplayName("searchSessionKey returns null when Subject has no tickets")
    void searchSessionKey_emptySubject() throws Exception {
        // Arrange GSS context so method can run without NPE
        GSSName src = mock(GSSName.class);
        GSSName targ = mock(GSSName.class);

from fastapi.security.utils import get_authorization_scheme_param
from pydantic import BaseModel
from starlette.requests import Request
from starlette.status import HTTP_401_UNAUTHORIZED


class HTTPBasicCredentials(BaseModel):
    """
    The HTTP Basic credentials given as the result of using `HTTPBasic` in a
    dependency.

    Read more about it in the