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));

    private final Set<String> warnings;
    private String testName;

    /**
     * @param warnings The allowed warnings to inject
     */
    public RemoveWarnings(Set<String> warnings) {
        this.warnings = warnings;
    }
    /**
     * @param warnings The allowed warnings to inject
     * @param testName The testName to inject
     */

# org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=warning
# org.eclipse.jdt.core.compiler.problem.nullReference=warning
# org.eclipse.jdt.core.compiler.problem.nullSpecViolation=warning
# org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
# org.eclipse.jdt.core.compiler.problem.potentialNullReference=warning

                if (!errors.contains(req.getMessage())) {
                    errors.add(req.getMessage());
                }
                break;
            case WARNING:
                if (!warnings.contains(req.getMessage())) {
                    warnings.add(req.getMessage());
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown severity: " + req.getSeverity());

            }
            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

    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,
    val accepted: List<ReportMessage>
) {

    val isEmpty: Boolean
        get() = errors.isEmpty() && warnings.isEmpty() && information.isEmpty()

    fun toText() =
        StringBuilder("Binary compatibility\n").apply {

Our codebase uses `null` extensively to represent an absence of value or optionality of the argument.
We utilize nullness annotations in Java code and somewhat rely on IDE warnings to guide us.
However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading
* Redundant null checks may increase binary size, hurt performance, and increase cognitive load for readers

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

		// Could not probe the kernel version
		return false
	}

	if currentKernel == 0 {
		// We could not get any valid value return false
		return false
	}

	// legacy linux indicator for printing warnings
	// about older Linux kernels and Go runtime.
	return currentKernel < kernel.Version(4, 0, 0)
}

func setMaxResources(ctx serverCtxt) (err error) {
	// Set the Go runtime max threads threshold to 90% of kernel setting.