v.status = scanStateError
		m.mu.Lock()
		m.trash[k] = v
		m.mu.Unlock()
	}
}

// deleteAll will delete all caches.
func (m *metacacheManager) deleteAll() {
	m.init.Do(m.initManager)
	m.mu.Lock()
	defer m.mu.Unlock()
	for bucket, b := range m.buckets {
		b.deleteAll()
		delete(m.buckets, bucket)
	}
}

// checkMetacacheState should be used if data is not updating.

	for k, v := range b.cachesRoot {
		tmp := make([]string, len(v))
		copy(tmp, v)
		dst2[k] = tmp
	}

	return dst, dst2
}

// deleteAll will delete all on disk data for ALL caches.
// Deletes are performed concurrently.
func (b *bucketMetacache) deleteAll() {
	ctx := context.Background()

	objAPI := newObjectLayerFn()
	if objAPI == nil {
		return
	}

	ez, ok := objAPI.(deleteAllStorager)

 *   <li>{@code add(ElevateWord elevateWord)} - Adds a new elevate word to the settings.</li>
 *   <li>{@code delete(String elevateWord)} - Deletes an elevate word from the settings.</li>
 *   <li>{@code deleteAll()} - Deletes all elevate words from the settings.</li>
 * </ul>
 *
 * <p>Protected Constructor:</p>
 * <ul>

	}

	if !e.DeleteMarker.set && !e.DeleteAll.set && e.IsDaysNull() && e.IsDateNull() {
		return errXMLNotWellFormed
	}

	// Both expiration days and date are specified
	if !e.IsDaysNull() && !e.IsDateNull() {
		return errLifecycleInvalidExpiration
	}

	// DeleteAll set without expiration days
	if e.DeleteAll.set && e.IsDaysNull() {
		return errLifecycleInvalidDeleteAll
	}

        assertEquals(elevateWord3.getElevateWord(), settings.elevateWord().get()[1].getElevateWord());

        settings.elevateWord().deleteAll();
        assertEquals(0, settings.elevateWord().get().length);
    }

        }
        arraySettings.delete(BAD_WORD_SETTINGS_KEY, badWord);
    }

    /**
     * Delete all bad words.
     */
    public void deleteAll() {
        if (logger.isInfoEnabled()) {
            logger.info("Deleting all bad words: index={}", arraySettings.arraySettingsIndexName);
        }
        arraySettings.delete(BAD_WORD_SETTINGS_KEY);
    }

     *
     * @return HTML response redirecting to the failure URL list page
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse deleteall() {
        verifyToken(this::asListHtml);
        failureUrlService.deleteAll(failureUrlPager);
        failureUrlPager.clear();
        saveInfo(messages -> messages.addSuccessFailureUrlDeleteAll(GLOBAL));
        return redirect(getClass());
    }

        assertEquals(2, settings.badword().get(false).length);
        assertEquals(value1, settings.badword().get(false)[0]);
        assertEquals(value3, settings.badword().get(false)[1]);

        settings.badword().deleteAll();
        assertEquals(0, settings.badword().get(false).length);
    }

		}
	}

	lc = Lifecycle{
		Rules: []Rule{
			{
				ID:     "AllVersionsExpiration",
				Status: "Enabled",
				Filter: Filter{},
				Expiration: Expiration{
					Days: 1,
					DeleteAll: Boolean{
						val: true,
						set: true,
					},
					set: true,
				},
			},
		},
	}

	now = time.Date(2025, time.February, 12, 23, 0, 0, 0, time.UTC)
	evaluator = NewEvaluator(lc)

    }

    /**
     * Deletes all failure URLs that match the criteria specified in the pager.
     *
     * @param failureUrlPager the pager containing deletion criteria
     */
    public void deleteAll(final FailureUrlPager failureUrlPager) {
        failureUrlBhv.queryDelete(cb -> {
            buildSearchCondition(failureUrlPager, cb);
        });
    }

    /**