verify(mockResponse, times(2)).isReceived();
    }

    @Test
    void testReceived() {
        // Call the method
        mockResponse.received();

        // Verify that the method was called
        verify(mockResponse, times(1)).received();
    }

    @Test
    void testClearReceived() {
        // Call the method
        mockResponse.clearReceived();

        // Verify that the method was called

     *
     * @param flag the flag to set
     */
    public void setFlag(final int flag) {
        this.flags |= flag;
    }

    /**
     * Get the result of the DCERPC call.
     * @return result exception, if the call failed
     */
    public DcerpcException getResult() {
        if (this.result != 0) {
            return new DcerpcException(this.result);
        }
        return null;
    }

   *
   * <p>If another call to {@link #get} or {@link #getUnchecked} is currently loading the value for
   * {@code key}, simply waits for that thread to finish and returns its loaded value. Note that
   * multiple threads can concurrently load values for distinct keys.
   *
   * <p>Caches loaded by a {@link CacheLoader} will call {@link CacheLoader#load} to load new values

    // The typed instance is also used for calls
    conn := manager.Connection("host")
    resp, err := instance.Call(ctx, conn, grid.NewMSSWith(map[string]string{"myfield": "myvalue"}))
    if err == nil {
        fmt.Println("Got response with field", resp["result"])
    }
```

The wrapper will handle all serialization and de-serialization of the request and response,

     *
     * 1. The client thread begins to block on a get() call to a future.
     * 2. The client thread is interrupted sometime before the result would be
     *   available.
     * 3. We expect the client's get() to throw an InterruptedException.
     * 4. We expect the client thread's interrupt state to be false.
     * 5. The client thread again makes a blocking call to get().
     * 6. Now the result becomes available.

        // When & Then
        assertTrue(negotiationRequest.isSigningEnforced(), "First call should return true");
        assertFalse(negotiationRequest.isSigningEnforced(), "Second call should return false");
        assertTrue(negotiationRequest.isSigningEnforced(), "Third call should return true");

        verify(negotiationRequest, times(3)).isSigningEnforced();
    }

    @Test

      throw new AssertionFailedError();
    }

    @Override
    public V get() throws InterruptedException {
      /*
       * Wait a little to give us time to call addListener before the future's
       * value is set in addition to the call we'll make after then.
       */
      allowGetToComplete.await(1, SECONDS);
      throw new RuntimeException("expected, should be caught");
    }

    @Override

    this(size, 0);
  }

  /**
   * Constructs an iterator across a sequence of the given size with the given initial position.
   * That is, the first call to {@link #nextIndex()} will return {@code position}, and the first
   * call to {@link #next()} will return the element at that index, if available. Calls to {@link
   * #previous()} can retrieve the preceding {@code position} elements.
   *

  }

  /**
   * Returns the element that follows {@code previous}, or returns {@code null} if no elements
   * remain. This method is invoked during each call to {@link #next()} in order to compute the
   * result of a <i>future</i> call to {@code next()}.
   */
  protected abstract @Nullable T computeNext(T previous);

  @Override
  public final boolean hasNext() {
    return nextOrNull != null;
  }

// '*num_retvals' should be set to the size of this array. It is an error if
// the size of 'retvals' is less than the number of outputs. This call sets
// *num_retvals to the number of outputs.
//
// If async execution is enabled, the call may simply enqueue the execution
// and return "non-ready" handles in `retvals`. Note that any handles contained