task.addWarning("one", "warning1", "warning2")
              task.addWarningRegex("two", "regex warning here .* [a-z]")
              task.addAllowedWarning("added allowed warning")
              task.addAllowedWarningRegex("added allowed warning regex .* [0-9]")
              task.removeWarning("one", "warning to remove")
              task.replaceIsTrue("value_to_replace", "replaced_value")

        transformations.add(new RemoveWarnings(Set.copyOf(Arrays.asList(warnings))));
    }

    /**
     * Removes one or more warnings
     *
     * @param warnings the warning(s) to remove
     * @param testName the test name to remove the warning
     */
    public void removeWarningForTest(String warnings, String testName) {
        transformations.add(new RemoveWarnings(Set.copyOf(Arrays.asList(warnings)), testName));

            }
            if (false == warnings.isEmpty()) {
                current.println("      warnings:")
                for (String warning in warnings) {
                    // Escape " because we're going to quote the warning
                    String escaped = warning.replaceAll('"', '\\\\"')
                    /* Quote the warning in case it starts with [ which makes

                }
                if (teardown) {
                    result += "[teardown:$teardown]"
                }
                for (String warning in warnings) {
                    result += "[warning:$warning]"
                }
                if (skipShardsFailures) {
                    result += '[skip_shard_failures]'
                }
            }
            if (testResponse) {

                warnings << "Return nullability changed from nullable to null-unmarked"
            }
        }

        if (!errors.isEmpty()) {
            def changes = errors + warnings
            return acceptOrReject(member, changes, Violation.error(member, changes.join(" ")))
        }
        if (!warnings.isEmpty()) {
            return Violation.warning(member, warnings.join(" "))
        }

            assertThat("Has errors", richReport.errors.map { it.message }, inAnyOrder(errors))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, inAnyOrder(warnings))
        }

        fun assertHasInformation(vararg information: String) {

     * This avoids the warning about not being able to find the root directory.
     */
    protected void createMvnDirectoryIfNeeded(UpgradeContext context) {
        context.info("");
        context.info("Creating .mvn directory if needed to avoid root directory warnings...");

        // Find the root directory (starting directory)

        if (ageMillis + minFreshMillis >= freshMillis) {
          builder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"")
        }
        val oneDayMillis = 24 * 60 * 60 * 1000L
        if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
          builder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"")
        }
        return CacheStrategy(null, builder.build())

		printStartupMessage(getAPIEndpoints(), err)

		// Print a warning at the end of the startup banner so it is more noticeable
		if newObject.BackendInfo().StandardSCParity == 0 && !globalIsErasureSD {
			warnings = append(warnings, color.YellowBold("The standard parity is set to 0. This can lead to data loss."))
		}

		for _, warn := range warnings {
			logger.Warning(warn)
		}
	}()

	region := globalSite.Region()

                warnings.simplefilter(
                    "ignore", category=UnsupportedFieldAttributeWarning
                )
            # TODO: remove after setting the min Pydantic to v2.12.3
            # that adds asdict(), and use self.field_info.asdict() instead
            field_dict = asdict(self.field_info)
            annotated_args = (