/**
     * Associates the specified session data with the given key if the key is currently mapped to the given value. This
     * method provides an atomic compare-and-update of some key's value.
     *
     * @param key the key under which to store the session data, must not be {@code null}
     * @param oldValue the expected data currently associated with the key, may be {@code null}

    private String testPipeName = "\\PIPE\\testpipe";

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    @DisplayName("Constructor should initialize with correct values")
    void testConstructor() {
        // Act
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);

        // Assert
        assertNotNull(transWaitNamedPipe);

     */
    boolean isDisconnected();

    /**
     * Disconnects the transport from the remote server.
     *
     * @param hard if true, force immediate disconnection
     * @param inuse whether the connection is currently in use
     * @return whether the connection was in use
     * @throws IOException if an I/O error occurs during disconnection
     */
    boolean disconnect(boolean hard, boolean inuse) throws IOException;

    /**

        byte[] buffer = new byte[100];
        int dstIndex = 10;
        int bytesWritten = info.encode(buffer, dstIndex);

        // Verify replaceIfExists flag at correct position
        assertEquals(1, buffer[dstIndex]);

        // Verify file name length at correct position
        int nameLength = SMBUtil.readInt4(buffer, dstIndex + 16);
        assertEquals(fileName.getBytes(StandardCharsets.UTF_16LE).length, nameLength);

        verify(mockResponse, times(1)).getErrorCode();
    }

    @Test
    void testSetMid() {
        long mid = 12345L;
        mockResponse.setMid(mid);

        // Verify that the method was called with the correct argument
        verify(mockResponse, times(1)).setMid(mid);
    }

    @Test
    void testGetMid() {
        long mid = 54321L;
        when(mockResponse.getMid()).thenReturn(mid);

Of course, the attackers would not try all this by hand, they would write a program to do it, possibly with thousands or millions of tests per second. And they would get just one extra correct letter at a time.

But doing that, in some minutes or hours the attackers would have guessed the correct username and password, with the "help" of our application, just using the time taken to answer.

#### Fix it with `secrets.compare_digest()` { #fix-it-with-secrets-compare-digest }

public class FessActionValidatorTest extends UnitFessTestCase {

    public void test_constructor() {
        // Test basic class structure without complex mocking
        assertEquals("FessActionValidator should be in correct package", "org.codelibs.fess.validation.FessActionValidator",
                FessActionValidator.class.getName());
    }

    public void test_inheritance() {

   * implementation; otherwise refreshes will be performed during unrelated cache read and write
   * operations.
   *
   * <p>Currently automatic refreshes are performed when the first stale request for an entry
   * occurs. The request triggering refresh will make a synchronous call to {@link
   * CacheLoader#reload}

        SamrAliasHandle aliasHandle = new SamrAliasHandle(mockDcerpcHandle, mockSamrDomainHandle, access, rid);

        // Assert
        assertNotNull(aliasHandle);
        // Verify that sendrecv was called with the correct MsrpcSamrOpenAlias object
        ArgumentCaptor<MsrpcSamrOpenAlias> rpcCaptor = ArgumentCaptor.forClass(MsrpcSamrOpenAlias.class);
        verify(mockDcerpcHandle).sendrecv(rpcCaptor.capture());

        Thread.yield();
      }
      state = get();
    }
    if (restoreInterruptedBit) {
      currentThread.interrupt();
    }
    /*
     * TODO(cpovirk): Clear interrupt status here? We currently don't, which means that an interrupt
     * before, during, or after runInterruptibly() (unless it produced an InterruptedException
     * caught above) can linger and affect listeners.
     */
  }

  /**