}
        };

    ExecutionException ee1 = getExpectingExecutionException(future);
    ExecutionException ee2 = getExpectingExecutionException(future);

    // Ensure we get a unique execution exception on each get
    assertNotSame(ee1, ee2);

    assertThat(ee1).hasCauseThat().isSameInstanceAs(failure);
    assertThat(ee2).hasCauseThat().isSameInstanceAs(failure);

    checkStackTrace(ee1);
    checkStackTrace(ee2);

        String[] origins = { "http://localhost:8080", "https://example.com", "http://subdomain.example.com", "https://example.com:3000" };

        for (String origin : origins) {
            setUp(); // Reset for each test
            mockRequest.setHeader("Origin", origin);
            mockRequest.setMethod("GET");
            TestCorsHandler handler = new TestCorsHandler();
            corsHandlerFactory.setHandler(handler);

        NtTransNotifyChange notify3 = new NtTransNotifyChange(mockConfig, 0x3333, FILE_NOTIFY_CHANGE_ATTRIBUTES, false);

        // Verify each instance maintains its own state
        byte[] dst1 = new byte[8];
        byte[] dst2 = new byte[8];
        byte[] dst3 = new byte[8];

        notify1.writeSetupWireFormat(dst1, 0);

        assertEquals(0, c2.compareTo(c1), "expected " + v2 + " == " + v1);
    }

    private void checkVersionsArrayEqual(String[] array) {
        // compare against each other (including itself)
        for (int i = 0; i < array.length; ++i) {
            for (int j = i; j < array.length; ++j) {
                checkVersionsEqual(array[i], array[j]);
            }
        }
    }

	type _C_int int32
	type _C_mp_limb_t uint64
	type _C___mpz_struct struct {
		_mp_alloc _C_int;
		_mp_size _C_int;
		_mp_d *_C_mp_limb_t;
	}
	type _C_mpz_t [1]_C___mpz_struct

and then replaces each occurrence of a type C.xxx with _C_xxx.

If xxx is data, cgo arranges for C.xxx to refer to the C variable,
with the type translated as described above.  To do this, cgo must

     * a line containing the cipher suite. Next is the length of the peer certificate chain. These
     * certificates are base64-encoded and appear each on their own line. The next line contains the
     * length of the local certificate chain. These certificates are also base64-encoded and appear
     * each on their own line. A length of -1 is used to encode a null array. The last line is
     * optional. If present, it contains the TLS version.
     */

    extends AbstractMultimap<K, V> implements ListMultimap<K, V>, Serializable {
  /*
   * Order is maintained using a linked list containing all key-value pairs. In
   * addition, a series of disjoint linked lists of "siblings", each containing
   * the values for a specific key, is used to implement {@link
   * ValueForKeyIterator} in constant time.
   */

  static final class Node<K extends @Nullable Object, V extends @Nullable Object>

   */
  public static <T extends @Nullable Object> Predicate<T> not(Predicate<T> predicate) {
    return new NotPredicate<>(predicate);
  }

  /**
   * Returns a predicate that evaluates to {@code true} if each of its components evaluates to
   * {@code true}. The components are evaluated in order, and evaluation will be "short-circuited"
   * as soon as a false predicate is found. It defensively copies the iterable passed in, so future

            Each source is specified by a {@code directory} element, which is relative to the POM.
            The kind of sources (source files to compile or resources to copy) and their usage (for the main code
            or for the tests) is specified by the {@code scope} element together with each source directory.
          </description>
          <association>

            }
          }
        });
      }
    ```

### Accessing Headers ([.kt][AccessHeadersKotlin], [.java][AccessHeadersJava])