},
		HeaderSize: headerSize,
	}
	newCtx := ctx
	if globalBucketMonitor.IsThrottled(bucket, tgt.ARN) && objInfo.Size < minLargeObjSize {
		var cancel context.CancelFunc
		newCtx, cancel = context.WithTimeout(ctx, throttleDeadline)
		defer cancel()
	}
	r := bandwidth.NewMonitoredReader(newCtx, globalBucketMonitor, gr, opts)
	if isMP {

				runAllIAMSTSTests(testCase, &check{t, testCase.serverType})
			},
		)
	}
}

func (s *TestSuiteIAM) TestSTSServiceAccountsWithUsername(c *check) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	bucket := "dillon-bucket"
	err := s.client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{})
	if err != nil {
		c.Fatalf("bucket create error: %v", err)
	}

  }

  private static void doTestSuccessfulAsListResultCancelledRacingInputDone() throws Exception {
    // Simple (combined.cancel -> input.cancel -> setOneValue):
    successfulAsList(ImmutableList.of(SettableFuture.create())).cancel(true);

    /*
     * Complex (combined.cancel -> input.cancel -> other.set -> setOneValue),
     * to show that this isn't just about problems with the input future we just
     * cancelled:

  }

  private static void doTestSuccessfulAsListResultCancelledRacingInputDone() throws Exception {
    // Simple (combined.cancel -> input.cancel -> setOneValue):
    successfulAsList(ImmutableList.of(SettableFuture.create())).cancel(true);

    /*
     * Complex (combined.cancel -> input.cancel -> other.set -> setOneValue),
     * to show that this isn't just about problems with the input future we just
     * cancelled:

	}

	// Start profiling on remote servers.
	for _, profiler := range profiles {
		// Limit start time to max 10s.
		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
		globalNotificationSys.StartProfiling(ctx, profiler)
		// StartProfiling blocks, so we can cancel now.
		cancel()

		// Start profiling locally as well.
		prof, err := startProfiler(profiler)
		if err == nil {

          callB.cancel()
          return MockResponse(body = (nextResponse++).toString())
        }
      }
    callA.enqueue(callback)
    callB.enqueue(callback)
    assertThat(server.takeRequest().url.encodedPath).isEqualTo("/a")
    callback.await(requestA.url).assertBody("A")
    // At this point we know the callback is ready, and that it will receive a cancel failure.
    callback

    consumer.accept(new ValueAndCloser<>(state));
  }

  /**
   * Attempts to cancel execution of this step. This attempt will fail if the step has already
   * completed, has already been cancelled, or could not be cancelled for some other reason. If
   * successful, and this step has not started when {@code cancel} is called, this step should never
   * run.
   *

    assertThat(readAscii(in1, 5)).isEqualTo("ABCDE")
    in1.close()
    call1.cancel()
    val call2 = client.newCall(newRequest("/"))
    val response2 = call2.execute()
    val in2 = response2.body.byteStream()
    assertThat(readAscii(in2, 5)).isEqualTo("LMNOP")
    in2.close()
    call2.cancel()
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    // Connection is pooled!

    public static final String LABELS_crawling_info_delete_all_confirmation = "{labels.crawling_info_delete_all_confirmation}";

    /** The key of the message: Cancel */
    public static final String LABELS_crawling_info_delete_all_cancel = "{labels.crawling_info_delete_all_cancel}";

    /** The key of the message: Thread Dump */

				results.NodeResults = append(results.NodeResults, result)
				resultsMu.Unlock()
			}()
			continue
		}
		wg.Add(1)
		go func() {
			defer wg.Done()
			ctx, cancel := context.WithTimeout(ctx, duration+10*time.Second)
			defer cancel()
			result := perfNetRequest(
				ctx,
				info.DeploymentID,
				adminPathPrefix+adminAPIVersionPrefix+adminAPISiteReplicationNetPerf,
				nil,
			)
			resultsMu.Lock()