which are unordered by happens before
(that is, neither <i>r</i> happens before <i>w</i>
nor <i>w</i> happens before <i>r</i>).
</p>

<p>
A <i>write-write data race</i> on memory location <i>x</i>
consists of two write-like memory operations <i>w</i> and <i>w'</i> on <i>x</i>,
at least one of which is non-synchronizing,
which are unordered by happens before.
</p>

<p>

        verify(mockDeferredNdrBuffer).advance(4 * sidArray.num_sids);
        verify(sidArray.sids[0]).encode(any(NdrBuffer.class)); // Buffer reassignment happens inside encode
        verify(sidArray.sids[1]).encode(any(NdrBuffer.class)); // Buffer reassignment happens inside encode
    }

    @Test
    void testLsarSidArrayEncodeNullSids() throws NdrException {
        lsarpc.LsarSidArray sidArray = new lsarpc.LsarSidArray();

  abstract T runInterruptibly() throws Exception;

  /**
   * Any interruption that happens as a result of calling interruptTask will arrive before this
   * method is called. Complete Futures here.
   */
  abstract void afterRanInterruptiblySuccess(@ParametricNullness T result);

  /**
   * Any interruption that happens as a result of calling interruptTask will arrive before this
   * method is called. Complete Futures here.

MinIO exposes a custom S3 STS API endpoint as `Action=AssumeRoleWithCertificate`. A client has to send an HTTP `POST` request to `https://<host>:<port>?Action=AssumeRoleWithCertificate&Version=2011-06-15`. Since the authentication and authorization happens via X.509 certificates the client has to send the request over **TLS** and has to provide
a client certificate.

  public void testRemovalNotification_clear_basher() throws InterruptedException {
    // If a clear() happens close to the end of computation, one of two things should happen:
    // - computation ends first: the removal listener is called, and the cache does not contain the
    //   key/value pair
    // - clear() happens first: the removal listener is not called, and the cache contains the pair

  public void testRemovalNotification_clear_basher() throws InterruptedException {
    // If a clear() happens close to the end of computation, one of two things should happen:
    // - computation ends first: the removal listener is called, and the cache does not contain the
    //   key/value pair
    // - clear() happens first: the removal listener is not called, and the cache contains the pair

 * cancelled).
 *
 * <p>This class serializes execution of <i>submitted</i> tasks but not any <i>listeners</i> of
 * those tasks.
 *
 * <p>Submitted tasks have a happens-before order as defined in the Java Language Specification.
 * Tasks execute with the same happens-before order that the function calls to {@link #submit} and
 * {@link #submitAsync} that submitted those tasks had.
 *

    public void test_instanceFieldsInitialization() {
        // Test that instance fields are properly initialized
        assertNotNull(crawlerEngineClient);
        // The actual client initialization happens lazily when needed
    }

    // Test that close method exists (inherited)
    public void test_closeMethodExists() {
        // Test that close method is available (inherited from parent)
        try {

    void noInteraction_whenExceptionOccursBeforeCall() {
        // Arrange
        Runnable r = mock(Runnable.class);

        // Act: simulate control flow where the exception happens before any collaborator is used
        try {
            throw new SmbUnsupportedOperationException();
        } catch (SmbUnsupportedOperationException ignored) {
            // ignore
        }

* Certificates have a **lifetime**.
    * They **expire**.
    * And then they need to be **renewed**, **acquired again** from the third party.
* The encryption of the connection happens at the **TCP level**.
    * That's one layer **below HTTP**.
    * So, the **certificate and encryption** handling is done **before HTTP**.
* **TCP doesn't know about "domains"**. Only about IP addresses.