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, " "))

    /**
     * Last fragment flag - indicates last fragment of a multi-fragment message
     */
    int DCERPC_LAST_FRAG = 0x02; /* Last fragment */
    /**
     * Pending cancel flag - indicates cancel was pending at sender
     */
    int DCERPC_PENDING_CANCEL = 0x04; /* Cancel was pending at sender */
    /**
     * Reserved flag for future use
     */
    int DCERPC_RESERVED_1 = 0x08;
    /**
     * Supports concurrent multiplexing flag

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Cancel request message.
 *
 * This command is used to cancel a previously sent command
 * that is still being processed by the server.
 *
 * @author mbechler
 */
public class Smb2CancelRequest extends ServerMessageBlock2 implements CommonServerMessageBlockRequest {

    /**
     * Constructs a SMB2 cancel request
     *
     * @param config

			break
		}
	}
}

// Tests presigned v2 signature.
func TestDoesPresignedV2SignatureMatch(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatal(err)

    // stop it.
    blockingCallable.waitForStart();

    // This time, cancel the future for the first task. The task remains running, only the future
    // is cancelled.
    future1.cancel(false);

    // Give the second task a chance to (incorrectly) start up while the first task is running.
    // (This is the assertion that fails.)

	ctx, cancel := context.WithCancel(ctx)

	// reset global variables to start afresh.
	resetTestGlobals()

	// Set globalIsErasure to indicate that the setup uses an erasure
	// code backend.
	globalIsErasure = true

	// Initializing objectLayer for HealFormatHandler.
	objLayer, erasureDirs, xlErr := initTestErasureObjLayer(ctx)
	if xlErr != nil {
		cancel()
		return nil, xlErr
	}

    return object : Socket {
      override fun cancel() {
        this@Exchange.cancel()
      }

      override val sink = RequestBodySink(codec.socket.sink, -1L)
      override val source = ResponseBodySource(codec.socket.source, -1L)
    }
  }

  fun noNewExchangesOnConnection() {
    codec.carrier.noNewExchanges()
  }

  fun cancel() {
    codec.cancel()
  }

  /**