if err != nil {
		t.Fatal(err)
	}

	erasureDisks := xl.getDisks()
	z.serverPools[0].erasureDisksMu.Lock()
	xl.getDisks = func() []StorageAPI {
		for i := range erasureDisks[:6] {
			erasureDisks[i] = newNaughtyDisk(erasureDisks[i], nil, errFaultyDisk)
		}
		return erasureDisks
	}

     */
    public ClockTick clockTick(int tick) {
        lock.lock();
        try {
            return getTick(tick);
        } finally {
            lock.unlock();
        }
    }

    private ClockTickImpl getTick(int tick) {
        ClockTickImpl clockTick = ticks.get(tick);
        if (clockTick == null) {
            clockTick = new ClockTickImpl(tick);

// erasureObjects - Implements ER object layer.
type erasureObjects struct {
	setDriveCount      int
	defaultParityCount int

	setIndex  int
	poolIndex int

	// getDisks returns list of storageAPIs.
	getDisks func() []StorageAPI

	// getLockers returns list of remote and local lockers.
	getLockers func() ([]dsync.NetLocker, string)

	// getEndpoints returns list of endpoint belonging this set.

	defer func() {
		if errors.Is(err, errFileNotFound) {
			err = errUploadIDNotFound
		}
	}()

	uploadIDPath := er.getUploadIDDir(bucket, object, uploadID)

	storageDisks := er.getDisks()

	// Read metadata associated with the object from all disks.
	partsMetadata, errs := readAllFileInfo(ctx, storageDisks, bucket, minioMetaMultipartBucket,
		uploadIDPath, "", false, false)

    @Override
    @Nullable
    public ModelNodeInternal getLink(String name) {
        return links == null ? null : links.get(name);
    }

    @Override
    public Iterable<? extends ModelNodeInternal> getLinks() {
        return links == null ? Collections.<ModelNodeInternal>emptyList() : links.values();
    }

    @Override
    public int getLinkCount(Predicate<? super MutableModelNode> predicate) {

        assertNull(options.getWindowTitle());
        assertNull(options.getDocTitle());
        assertNull(options.getFooter());
        assertNull(options.getBottom());
        assertEmpty(options.getLinks());
        assertEmpty(options.getLinksOffline());
        assertFalse(options.isLinkSource());
        assertEmpty(options.getGroups());
        assertFalse(options.isNoDeprecated());

        }
    }

    private void ensureCanRemove(ModelNodeInternal node, List<ModelNodeInternal> nodesToRemove) {
        if (!(node instanceof ModelReferenceNode)) {
            for (ModelNodeInternal childNode : node.getLinks()) {
                ensureCanRemove(childNode, nodesToRemove);
            }
        }
        if (!Iterables.isEmpty(node.getDependents())) {

            getSource(), destinationDir, isUse(), isNoTimestamp(), isNoVersionStamp(),
            getWindowTitle(), getDocTitle(), getHeader(), getFooter(), getPathToOverview(),
            getAccess().get(), getLinks(), getGroovyClasspath(), getClasspath(),
            getTemporaryDir(), getServices().get(FileSystemOperations.class),
            getIncludeAuthor().get(), getProcessScripts().get(), getIncludeMainForScripts().get()
        );

	if err != nil {
		t.Fatalf("Failed to make a bucket %v", err)
	}

	object := "object"
	data := bytes.Repeat([]byte("a"), smallFileThreshold*16)
	z := obj.(*erasureServerPools)

	erasureDisks, err := z.GetDisks(0, 0)
	if err != nil {
		t.Fatal(err)
	}

	for i, test := range testCases {
		test := test
		t.Run(fmt.Sprintf("case-%d", i), func(t *testing.T) {

	dryRun := opts.DryRun
	scanMode := opts.ScanMode

	storageDisks := er.getDisks()
	storageEndpoints := er.getEndpoints()

	defer func() {
		er.auditHealObject(ctx, bucket, object, versionID, result, err)
	}()

	if globalTrace.NumSubscribers(madmin.TraceHealing) > 0 {