// for technical reasons we cannot throw here, even if delegate does cancel transfer
            listener.transferInitiated(event(session, resource, TransferEvent.EventType.INITIATED));

            Thread.sleep(500); // to make sure queue is processed, cancellation applied

            // subsequent call will cancel
            assertThrows(
                    TransferCancelledException.class,

     * Sets the number of request credits.
     *
     * @param credits the number of credits to set
     */
    void setRequestCredits(int credits);

    /**
     * Checks if this is a cancel request.
     *
     * @return whether this is a cancel request
     */
    boolean isCancel();

    /**
     * Gets the next request in the chain.
     *
     * @return chained request
     */
    Request getNext();

    /**

				t.Errorf("Expected dangling %t, got %t", testCase.expectedDangling, dangling)
			}
		})
	}
}

// Tests both object and bucket healing.
func TestHealing(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDirs, err := prepareErasure16(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer obj.Shutdown(t.Context())

	// initialize the server and obtain the credentials and root.

        transaction.setMid(12345);

        // Create cancel request
        CommonServerMessageBlockRequest cancelRequest = transaction.createCancel();

        // Verify it returns an SmbComNtCancel instance
        assertNotNull(cancelRequest);
        assertTrue(cancelRequest instanceof SmbComNtCancel);

        // Verify the cancel request has the correct MID
        assertEquals(12345, cancelRequest.getMid());

package cmd

import (
	"context"
	"os"
	"testing"

	"github.com/minio/minio/internal/config"
)

func TestServerConfig(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

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

	if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {

  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);
    assertTrue(task.isDone());
    assertTrue(task.isCancelled());
    assertFalse(task.wasInterrupted());
    assertThrows(CancellationException.class, () -> getDone(task));
    verifyThreadWasNotInterrupted();

					_ = syscall.SetsockoptString(int(fdPtr), syscall.SOL_SOCKET, syscall.SO_BINDTODEVICE, opts.Interface)
				}
			})
			return nil
		},
	}

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	l, err := lc.Listen(ctx, "tcp", net.JoinHostPort(host, port))
	if err != nil {
		return err
	}

	// As we are able to listen on this network, the port is not in use.

	stopFn := globalFtpMetrics.log(ctx, objPath)
	defer stopFn(0, err)

	clnt, err := driver.getMinIOClient(ctx)
	if err != nil {
		return err
	}

	cctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	bucket, prefix := path2BucketObject(objPath)
	if bucket == "" {
		buckets, err := clnt.ListBuckets(cctx)
		if err != nil {
			return err
		}

	if err != nil {
		return err
	}
	m[policy] = p
	return nil
}

func (iamOS *IAMObjectStore) loadPolicyDocs(ctx context.Context, m map[string]PolicyDoc) error {
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	for item := range listIAMConfigItems(ctx, iamOS.objAPI, iamConfigPoliciesPrefix) {
		if item.Err != nil {
			return item.Err
		}

		policyName := path.Dir(item.Item)

		}
		r = gzr
		pr.closer = gzr
	case bzip2Type:
		ctx, cancel := context.WithCancel(context.Background())
		r = pbzip2.NewReader(ctx, scannedReader, pbzip2.DecompressionOptions(
			pbzip2.BZConcurrency((runtime.GOMAXPROCS(0)+1)/2),
			pbzip2.BZConcurrencyPool(bz2Limiter),
		))
		pr.closer = &nopReadCloser{fn: cancel}
	case zstdType:
		// Set a max window of 64MB. More than reasonable.