}
	} else {
		oh, exists := ahs.getHealSequence(pathJoin(h.bucket, h.object))
		if exists && !oh.hasEnded() {
			errMsg = "Heal is already running on the given path " +
				"(use force-start option to stop and start afresh). " +
				fmt.Sprintf("The heal was started by IP %s at %s, token is %s",
					h.clientAddress, h.startTime.Format(http.TimeFormat), h.clientToken)
			return nil, errorCodes.ToAPIErr(ErrHealAlreadyRunning), errMsg
		}
	}

    }
  }

  private enum LinkedListSupplier implements Supplier<List<?>> {
    INSTANCE;

    static <V extends @Nullable Object> Supplier<List<V>> instance() {
      // Each call generates a fresh LinkedList, which can serve as a List<V> for any V.
      @SuppressWarnings({"rawtypes", "unchecked"})
      Supplier<List<V>> result = (Supplier) INSTANCE;
      return result;
    }

    @Override

    }
  }

  private enum LinkedListSupplier implements Supplier<List<?>> {
    INSTANCE;

    static <V extends @Nullable Object> Supplier<List<V>> instance() {
      // Each call generates a fresh LinkedList, which can serve as a List<V> for any V.
      @SuppressWarnings({"rawtypes", "unchecked"})
      Supplier<List<V>> result = (Supplier) INSTANCE;
      return result;
    }

    @Override

          .url(server.url("/"))
          .build(),
      )
    val response1 = call1.execute()
    assertThat(response1.body.string()).isEqualTo("abc")
    response1.close()

    // Force a fresh connection for the next request.
    client.connectionPool.evictAll()

    // Confirm that a second request also succeeds. This should detect caching problems.
    server.enqueue(
      MockResponse

      Object instance = ArbitraryInstances.get(mutableClass);
      assertNotNull("Expected to return non-null for: " + mutableClass, instance);
      assertNotSame(
          "Expected to return fresh instance for: " + mutableClass,
          instance,
          ArbitraryInstances.get(mutableClass));
    }
  }

  private enum EmptyEnum {}

  private enum Direction {
    UP,
    DOWN
  }

 * Immutable empty instances are returned for collection types; {@code ""} for string; {@code 0} for
 * number types; reasonable default instance for other stateless types. For mutable types, a fresh
 * instance is created each time {@code get()} is called.
 *
 * @author Kevin Bourrillion
 * @author Ben Yu
 * @since 12.0
 */
@GwtIncompatible
@J2ktIncompatible
@NullMarked

			disksToHeal = append(disksToHeal, disk.Endpoint())
		}
	}
	if len(disksToHeal) == globalEndpoints.NEndpoints() {
		// When all disks == all command line endpoints
		// this is a fresh setup, no need to trigger healing.
		return Endpoints{}
	}
	return disksToHeal
}

var newDiskHealingTimeout = newDynamicTimeout(30*time.Second, 10*time.Second)

			t.Errorf("Test %d: Expected %v but received %v -> %#v", tt.name, got, tt.want, tt)
		}
	}
}

// newTestXLMetaV1 - initializes new xlMetaV1Object, adds version, allocates a fresh erasure info and metadata.
func newTestXLMetaV1() xlMetaV1Object {
	xlMeta := xlMetaV1Object{}
	xlMeta.Version = xlMetaVersion101
	xlMeta.Format = xlMetaFormat
	xlMeta.Minio.Release = "test"
	xlMeta.Erasure = ErasureInfo{

    // Stalling the socket will cause TWO requests to time out!
    server.enqueue(MockResponse.Builder().onRequestStart(Stall).build())

    // The 3rd request should be sent to a fresh connection.
    server.enqueue(
      MockResponse(body = "fresh connection"),
    )

    // The first call times out.
    val call1 = client.newCall(Request(server.url("/")))
    assertFailsWith<IOException> {
      call1.execute()

  // Import it in a fresh graph.
  TF_DeleteGraph(graph);
  graph = TF_NewGraph();
  TF_ImportGraphDefOptions* opts = TF_NewImportGraphDefOptions();
  TF_GraphImportGraphDef(graph, graph_def, opts, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  TF_Operation* scalar = TF_GraphOperationByName(graph, "scalar");

  // Import it in a fresh graph with an unused input mapping.