## Quick Start

    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    // Running the red task starts another thread, so the two can run in parallel.
    taskFaker.runNextTask()
    assertThat(log).containsExactly("red:starting@0")
    assertThat(taskFaker.executeCallCount).isEqualTo(2)

    // Next the blue task starts.
    taskFaker.runNextTask()
    assertThat(log).containsExactly(
      "red:starting@0",

	0: {
		id:           "case-1-normal",
		bucket:       "bucket",
		root:         "folder/prefix",
		recursive:    false,
		status:       scanStateSuccess,
		fileNotFound: false,
		error:        "",
		started:      metaCacheTestsetTimestamp,
		ended:        metaCacheTestsetTimestamp.Add(time.Minute),
		lastUpdate:   metaCacheTestsetTimestamp.Add(time.Minute),
		lastHandout:  metaCacheTestsetTimestamp,

message StatefulSetOrdinals {
  // start is the number representing the first replica's index. It may be used
  // to number replicas from an alternate index (eg: 1-indexed) over the default
  // 0-indexed names, or to orchestrate progressive movement of replicas from
  // one StatefulSet to another.
  // If set, replica indices will be in the range:
  //   [.spec.ordinals.start, .spec.ordinals.start + .spec.replicas).

automatically on GitHub.

If you want to contribute, start working through the TensorFlow codebase,
navigate to the
[GitHub "issues" tab](https://github.com/tensorflow/tensorflow/issues) and start
looking through interesting issues. If you are not sure of where to start, then
start by trying one of the smaller/easier issues here i.e.

		}

		if _, _, err := net.SplitHostPort(consoleAddr); err != nil {
			logger.FatalIf(err, "Unable to start listening on console port")
		}

		if consoleAddr == addr {
			logger.FatalIf(errors.New("--console-address cannot be same as --address"), "Unable to start the server")
		}
	}

	globalMinioHost, globalMinioPort = mustSplitHostPort(addr)
	if globalMinioPort == "0" {

	if len(endpoints) == 0 || setCount == 0 || setDriveCount == 0 {
		return nil, nil, errInvalidArgument
	}

	// prepare getElapsedTime() to calculate elapsed time since we started trying formatting disks.
	// All times are rounded to avoid showing milli, micro and nano seconds
	formatStartTime := time.Now().Round(time.Second)
	getElapsedTime := func() string {

  ) {
    defaultInstancePort = defaultInstance.port
    instanceAPort = instanceA.port
    instanceBPort = instanceB.port
    assertThat(defaultInstance.started).isTrue()
    assertThat(instanceA.started).isTrue()
    assertThat(instanceB.started).isTrue()
    assertThat(defaultInstancePort).isNotEqualTo(instanceAPort)
    assertThat(defaultInstancePort).isNotEqualTo(instanceBPort)
  }

  @AfterEach
  fun tearDown(

  final ReferenceQueue<Object> queue;

  final PhantomReference<Object> frqRef;

  /** Whether or not the background thread started successfully. */
  final boolean threadStarted;

  /** Constructs a new queue. */
  public FinalizableReferenceQueue() {
    // We could start the finalizer lazily, but I'd rather it blow up early.
    queue = new ReferenceQueue<>();
    frqRef = new PhantomReference<>(this, queue);

    log(task, queue, messageBlock())
  }
}

internal inline fun <T> Logger.logElapsed(
  task: Task,
  queue: TaskQueue,
  block: () -> T,
): T {
  var startNs = -1L
  val loggingEnabled = isLoggable(Level.FINE)
  if (loggingEnabled) {
    startNs = queue.taskRunner.backend.nanoTime()
    log(task, queue, "starting")
  }

  var completedNormally = false
  try {
    val result = block()