runningAsyncCalls.add(asyncCall)
        }

        return@synchronized Effects(
          callsToExecute = callsToExecute,
          idleCallbackToRun = idleCallbackToRun,
        )
      }

    var callDispatcherQueueStart = true

    for (i in 0 until effects.callsToExecute.size) {
      val call = effects.callsToExecute[i]

        // Then
        // Verify that the super constructor is called with correct arguments
        // Note: Directly verifying super constructor calls is not straightforward in JUnit/Mockito.
        // We verify the effects of the super constructor by checking the fields of the created object.

        // Assert object_attributes fields
        assertNotNull(msrpcLsarOpenPolicy2.object_attributes);

   * expected</i>, but not absolutely required, to have the following properties:
   *
   * <ul>
   *   <li>Its execution does not cause any observable side effects.
   *   <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equals
   *       Objects.equals}{@code (a, b)} implies that {@code Objects.equals(function.apply(a),
   *       function.apply(b))}.

    interface EnumConsumer {
        void accept(RequestParam rp);
    }

    @Mock
    EnumConsumer consumer;

    @Test
    @DisplayName("Enum value can be passed to collaborators without side effects")
    void enumUsedWithCollaboratorHasNoSideEffects() {
        // Arrange: pick a value and a mocked consumer
        RequestParam rp = RequestParam.NO_RETRY;

        // Act: pass to the collaborator

## Status

- ACCEPTED on 2024-02-07

## Context

The Gradle code base is essentially a large monolith, without strong internal boundaries.
This has a number of negative effects on productivity, including:

- Unclear ownership of code.
- Difficult to focus on one particular area.
- Unintended coupling between areas of the code, including tests.

## Decision

   * listeners, see {@link Futures}. For a simplified but general listener interface, see {@link
   * Futures#addCallback addCallback()}.
   *
   * <p>Memory consistency effects: Actions in a thread prior to adding a listener <a
   * href="https://docs.oracle.com/javase/specs/jls/se25/html/jls-17.html#jls-17.4.5">
   * <i>happen-before</i></a> its execution begins, perhaps in another thread.
   *

    private static final double TIMING_TOLERANCE = 2.0; // 200% tolerance - JVM timing is inherently variable for timing variations

    @BeforeEach
    public void setUp() {
        // Warm up JVM to reduce JIT compilation effects
        for (int i = 0; i < 100; i++) {
            NtlmPasswordAuthenticator auth1 = new NtlmPasswordAuthenticator("testdomain", "testuser", "password123");

  /**
   * Creates the permissions normally used for Windows filesystems, looking up the user afresh, even
   * if previous calls have initialized the {@code PermissionSupplier} fields.
   *
   * <p>This lets us test the effects of different values of the {@code user.name} system property
   * without needing a separate VM or classloader.
   */
  @IgnoreJRERequirement // used only when Path is available (and only from tests)
  @VisibleForTesting

   * listeners, see {@link Futures}. For a simplified but general listener interface, see {@link
   * Futures#addCallback addCallback()}.
   *
   * <p>Memory consistency effects: Actions in a thread prior to adding a listener <a
   * href="https://docs.oracle.com/javase/specs/jls/se25/html/jls-17.html#jls-17.4.5">
   * <i>happen-before</i></a> its execution begins, perhaps in another thread.
   *

	if objectAPI == nil {
		return
	}

	// NB rebalance-start admin API is always coordinated from first pool's
	// first node. The following is required to serialize (the effects of)
	// concurrent rebalance-start commands.
	if ep := globalEndpoints[0].Endpoints[0]; !ep.IsLocal {
		for nodeIdx, proxyEp := range globalProxyEndpoints {
			if proxyEp.Host == ep.Host {