constructor.setAccessible(true);
            SmbComNtCancel cancel = constructor.newInstance(config, testMid);

            // Then
            assertNotNull(cancel);
            assertEquals(testMid, cancel.getMid());
            assertTrue(cancel.isCancel());
        }
    }

    @Nested
    @DisplayName("Method Behavior Tests")

    }

    @Test
    @DisplayName("Test isResponseAsync returns false")
    void testIsResponseAsync() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

        // When
        boolean isAsync = request.isResponseAsync();

        // Then
        assertFalse(isAsync, "Cancel requests should not expect async responses");

    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {
    assertThat(future.cancel(false /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, false);
  }

  public void testInterrupted() throws Exception {
    assertThat(future.cancel(true /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, true);
  }

	if !deleteOpts.Immediate {
		// add deadlines for all non-immediate purges
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, globalDriveConfig.GetMaxTimeout())
		defer cancel()
	}

	_, err := storageDeleteFileRPC.Call(ctx, client.gridConn, &DeleteFileHandlerParams{
		DiskID:   *client.diskID.Load(),
		Volume:   volume,

    assertEvents(
      "take plan 1",
      "plan 1 TCP connecting...",
    )

    taskFaker.advanceUntil(500.ms)
    assertEvents(
      "take plan 2",
      "plan 0 cancel",
      "plan 1 cancel",
    )

    taskFaker.advanceUntil(510.ms)
    assertEvents(
      "plan 1 TCP connect canceled",
    )

    taskFaker.advanceUntil(520.ms)
    assertEvents(

      @Override
      @SuppressWarnings("Interruption") // We are propagating an interrupt from a caller.
      public void cancel(boolean mayInterruptIfRunning) {
        /*
         * Lock to ensure that a task cannot be rescheduled while a cancel is ongoing.
         *
         * In theory, cancel() could execute arbitrary listeners -- bad to do while holding a lock.

    inFinished: Boolean,
  ) {
    pushQueue.execute("$connectionName[$streamId] onHeaders") {
      val cancel = pushObserver.onHeaders(streamId, requestHeaders, inFinished)
      ignoreIoExceptions {
        if (cancel) writer.rstStream(streamId, ErrorCode.CANCEL)
        if (cancel || inFinished) {
          withLock {
            currentPushRequests.remove(streamId)
          }
        }
      }

	// Disconnect from call above, but cancel on exit.
	listCtx, cancel := context.WithCancel(GlobalContext)
	saveCh := make(chan metaCacheEntry, metacacheBlockSize)
	inCh := make(chan metaCacheEntry, metacacheBlockSize)
	outCh := make(chan metaCacheEntry, o.Limit)

	filteredResults := o.gatherResults(ctx, outCh)

	mc := o.newMetacache()

	return BucketInfo{}, toObjectErr(errVolumeNotFound, bucket)
}

func (client *remotePeerS3Client) ListBuckets(ctx context.Context, opts BucketOptions) ([]BucketInfo, error) {
	ctx, cancel := context.WithTimeout(ctx, globalDriveConfig.GetMaxTimeout())
	defer cancel()

	bi, err := listBucketsRPC.Call(ctx, client.gridConn(), &opts)
	if err != nil {
		return nil, toStorageErr(err)
	}
	buckets := make([]BucketInfo, 0, len(bi.Value()))

	}
	return testCases
}()

const (
	EnvTestEtcdBackend = "_MINIO_ETCD_TEST_SERVER"
)

func (s *TestSuiteIAM) setUpEtcd(c *check, etcdServer string) {
	ctx, cancel := context.WithTimeout(context.Background(), testDefaultTimeout)
	defer cancel()

	configCmds := []string{
		"etcd",
		"endpoints=" + etcdServer,
		"path_prefix=" + mustGetUUID(),
	}
	_, err := s.adm.SetConfigKV(ctx, strings.Join(configCmds, " "))