manualExecutorTask[0].run();

    for (Future<?> result : results) {
      if (!result.isCancelled()) {
        result.get(10, SECONDS);
      }
      // TODO(cpovirk): Verify that the cancelled futures are exactly ones that we expect.
    }

    assertThat(logHandler.getStoredLogRecords()).isEmpty();
  }

  public void testAvoidsStackOverflow_manySubmitted() throws Exception {

        // Should use UNSPECIFIED_FILEID by default
    }

    @Test
    @DisplayName("Test various FSCTL constants")
    void testFsctlConstants() {
        // Test that all FSCTL constants are properly defined
        assertEquals(0x0060194, Smb2IoctlRequest.FSCTL_DFS_GET_REFERRALS);
        assertEquals(0x0011400C, Smb2IoctlRequest.FSCTL_PIPE_PEEK);
        assertEquals(0x00110018, Smb2IoctlRequest.FSCTL_PIPE_WAIT);

	expected := false
	if locked != expected {
		t.Errorf("TestDualWriteLockTimedOut(): \nexpected %#v\ngot      %#v", expected, locked)
	}
}

// Test cases below are copied 1 to 1 from sync/rwmutex_test.go (adapted to use DRWMutex)

// Borrowed from rwmutex_test.go
func parallelReader(ctx context.Context, m *DRWMutex, clocked, cunlock, cdone chan bool) {

    }

    protected PromptBuilder confirmPrompt(PromptBuilder promptBuilder) {
        promptBuilder
                .createConfirmPromp()
                .name("confirm")
                .message("Are values above correct?")
                .defaultValue(ConfirmChoice.ConfirmationValue.YES)
                .addPrompt();
        return promptBuilder;
    }

panic("bigmod: modulus for Exp must be odd") } // We use a 4 bit window. For our RSA workload, 4 bit windows are faster // than 2 bit windows, but use an extra 12 nats worth of scratch space. // Using bit sizes that don't divide 8 are more complex to implement, but // are likely to be more efficient if necessary. table := [(1 << 4) - 1]*Nat{ // table[i] = x ^ (i+1) // newNat calls are unrolled so they are allocated on the stack. NewNat(), NewNat(), NewNat(), NewNat(), NewNat(), NewNat(), NewNat(), NewNat(),...

   * <ul>
   *   <li>normalNormal: two params, neither is Nullable
   *   <li>nullableNormal: only first param is Nullable
   *   <li>normalNullable: only second param is Nullable
   *   <li>nullableNullable: both params are Nullable
   * </ul>
   */
  public static class TwoArg {
    /** Action to take on a null param. */
    public enum Action {
      THROW_A_NPE {
        @Override
        public void act() {

                /* UPDATE: Maybe not! Could this be a Unicode alignment issue. I hope
                 * so. We cannot just comment out this method and use readString of
                 * ServerMessageBlock.java because the arguments are different, however
                 * one might be able to reduce this.
                 */

                if (len > 0 && src[srcIndex + len - 1] == '\0') {
                    len--;
                }

- **Newsletter**: Subscribe to the [Gradle Newsletter](https://newsletter.gradle.org) for news, tutorials, and community highlights.

> **Quick Tip**: New contributors to Gradle projects are encouraged to ask questions in the Slack `#community-support` channel.

---

### 🌱 **Contributing to Gradle**

            assertEquals(USER_PRINCIPAL_NAME, ticket.getUserPrincipalName());
            assertEquals(USER_REALM, ticket.getUserRealm());
        }
    }

    // Note: Testing the code path where keys are null and retrieved from
    // KerberosCredentials requires mocking the constructor of KerberosCredentials,
    // which is not possible with standard Mockito. A tool like PowerMock would be needed.

            Key<?> keyType = key.getTypeParameter(0);
            Key<Object> valueType = key.getTypeParameter(1);
            if (keyType.getRawType() != String.class) {
                throw new DIException("Only String keys are supported for maps: " + key);
            }
            return () -> {
                var comparator = getPriorityComparator();
                Map<String, Binding<?>> map = new HashMap<>();