* the internal list.
   */
  @JvmStatic
  fun fragmentBuffer(buffer: Buffer): Buffer {
    // Write each byte into a new buffer, then clone it so that the segments are shared.
    // Shared segments cannot be compacted so we'll get a long chain of short segments.
    val result = Buffer()
    while (!buffer.exhausted()) {
      val box = Buffer()
      box.write(buffer, 1)
      result.write(box.copy(), 1)
    }
    return result

	scannerMetricScanFolder      // Scan a folder on disk, recursively.
	scannerMetricScanCycle       // Full cycle, cluster global
	scannerMetricScanBucketDrive // Single bucket on one drive
	scannerMetricCompactFolder   // Folder compacted.

	// Must be last:
	scannerMetricLast
)

// log scanner action.
// Use for s > scannerMetricStartTrace
func (p *scannerMetrics) log(s scannerMetric, paths ...string) func(custom map[string]string) {

    return insertAt == 0
  }

  /**
   * Schedules immediate execution of [Task.tryCancel] on all currently-enqueued tasks. These calls
   * will not be made until any currently-executing task has completed. Tasks that return true will
   * be removed from the execution schedule.
   */
  fun cancelAll() {
    taskRunner.assertLockNotHeld()

    taskRunner.withLock {
      if (cancelAllAndDecide()) {

        processor.completed("rootId", rootCompleteEvent)

        then:
        1 * delegate.completed("testId1", testCompleteEvent1)
        1 * delegate.completed("rootId", rootCompleteEvent)
    }

    def "events for aborted tests are ignored"() {
        given:
        def delegate = Mock(TestResultProcessor)
        def processor = new RerunTestResultProcessor(delegate);

        return memoryRegion;
    }

    /**
     * Check if request is completed
     *
     * @return true if completed, false otherwise
     */
    public boolean isCompleted() {
        return completed;
    }

    /**
     * Mark request as completed
     */
    public void markCompleted() {
        this.completed = true;
    }

    /**
     * Mark request as failed with error
     *

		expectedCompletedSize:             249,
		expectedReplicationStatusInternal: "arn1=COMPLETED;",
		expectedReplicationStatus:         replication.Completed,
		expectedOpType:                    replication.ObjectReplicationType,
		expectedAction:                    replicateAll,
	},
	{ // 3. replication completed to single target; failed to another
		name: "replication completed to single target",
		tgtInfos: []replicatedTargetInfo{
			{

            if (!completed) {
              completed = true
              progressListener.update(totalBytesWritten, contentLength(), completed)
            }
          }
        }

      val bufferedSink = forwardingSink.buffer()
      delegate.writeTo(bufferedSink)
      bufferedSink.flush()
    }
  }

  fun interface ProgressListener {
    fun update(
      bytesWritten: Long,

  }

  public void testGet() {
    Object computed = new Object();
    LoadingCache<Object, Object> cache =
        CacheBuilder.newBuilder()
            .maximumSize(0)
            .removalListener(listener)
            .build(constantLoader(computed));

    Object key = new Object();
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(computed);

@J2ktIncompatible
public class ThreadFactoryBuilderTest extends TestCase {
  private final Runnable monitoredRunnable = () -> completed = true;

  private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =
      (thread, throwable) -> {};

  private ThreadFactoryBuilder builder;
  private volatile boolean completed = false;

  @Override
  public void setUp() {
    builder = new ThreadFactoryBuilder();
  }

	return ETag(sum)
}

// VerifyError is an error signaling that a
// computed ETag does not match an expected
// ETag.
type VerifyError struct {
	Expected ETag
	Computed ETag
}

func (v VerifyError) Error() string {
	return fmt.Sprintf("etag: expected ETag %q does not match computed ETag %q", v.Expected, v.Computed)
}

// UUIDHash - use uuid to make md5sum
type UUIDHash struct {
	uuid []byte