if (!warnings.isEmpty()) {
            warningReporter.recordValidationWarnings(work, warnings);
        }

        if (!errors.isEmpty()) {
            throwValidationException(work, validationContext, errors);
        }

        if (!warnings.isEmpty()) {
            LOGGER.info("Invalidating VFS because {} failed validation", work.getDisplayName());

    @Override
    public String getLocation() {
        return "";
    }

    @Override
    public String getMessage() {
        String msg = null;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else if (exception != null) {
            msg = exception.getMessage();
        }

        if (msg == null) {
            msg = "";
        }

        this.fromLock = fromLock;
        this.reason = reason;
    }

    private static List<IvyArtifactName> asImmutable(List<IvyArtifactName> artifactNames) {
        return artifactNames.isEmpty() ? Collections.emptyList() : artifactNames instanceof ImmutableList ? artifactNames : ImmutableList.copyOf(artifactNames);
    }

    @Override
    public String toString() {

        CacheOperationStack stack = stackForThread.get();
        if (stack == null) {
            throw new IllegalStateException("Operation stack is empty.");
        }
        stack.popCacheAction();
        if (stack.isEmpty()) {
            stackForThread.remove();
        }
    }

    public boolean isInCacheAction() {
        CacheOperationStack stack = stackForThread.get();
        return stack != null && stack.isInCacheAction();

        builder.append(defaultValue);
        builder.append("): ");
        return builder.toString();
    }

    @Override
    public PromptResult<Integer> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultValue);
        }
        String trimmed = text.trim();
        try {
            int result = Integer.parseInt(trimmed);
            if (result >= minValue) {

        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    @Override
    public void transferFailed(TransferEvent event) {
        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    private static class Exchange {
        private final TransferEvent event;

                    .setMessage("Unknown packaging: " + packaging)
                    .setLocation(model.getLocation("packaging")));
        } else if (!defaultPlugins.isEmpty()) {
            List<Plugin> plugins = defaultPlugins.stream()
                    .map(org.apache.maven.model.Plugin::getDelegate)
                    .collect(Collectors.toList());

    protected CompositeSpec(Iterable<? extends Spec<? super T>> specs) {
        if (specs instanceof Collection) {
            Collection<Spec<? super T>> specCollection = uncheckedCast(specs);
            if (specCollection.isEmpty()) {
                this.specs = uncheckedCast(EMPTY);
            } else {
                this.specs = uncheckedCast(specCollection.toArray(EMPTY));
            }
        } else {

        builder.append(options.size());
        builder.append("] ");
        return builder.toString();
    }

    @Override
    public PromptResult<Integer> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultOption);
        }
        String trimmed = text.trim();
        if (trimmed.matches("\\d+")) {
            int value = Integer.parseInt(trimmed);

                PluginContainer source,
                boolean sourceDominant,
                Map<Object, Object> context) {
            List<Plugin> src = source.getPlugins();
            if (!src.isEmpty()) {
                List<Plugin> tgt = target.getPlugins();

                Map<Object, Plugin> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (Plugin element : tgt) {