: EnumSet.of(IssueLocality.EXTERNAL);

        if (hasAnythingToReport(issuesMap, issueLocalitiesToReport)) {
            logger.warn("");
            logger.warn("Plugin {} validation issues were detected in following plugin(s)", issueLocalitiesToReport);
            logger.warn("");
            for (Map.Entry<String, PluginValidationIssues> entry : issuesMap.entrySet()) {

                    LOGGER.warn("{}{}", problem.getMessage(), ((loc != null && !loc.isEmpty()) ? " @ " + loc : ""));
                }

                problems = true;
            }
        }

        if (problems) {
            LOGGER.warn("");
            LOGGER.warn("It is highly recommended to fix these problems"

        if (logger.isDebugEnabled()) {
            logger.warn(msg, event.getArtifact(), event.getException().getMessage());
        } else {
            logger.warn(msg, event.getArtifact(), "enable verbose output (-X) for more details");
        }
    }

    @Override
    public void artifactDescriptorMissing(RepositoryEvent event) {

    @Override
    public void warn(CharSequence content) {
        if (isWarnEnabled()) {
            logger.warn(toString(content));
        }
    }

    @Override
    public void warn(CharSequence content, Throwable error) {
        if (isWarnEnabled()) {
            logger.warn(toString(content), error);
        }
    }

    @Override
    public void warn(Throwable error) {

                    logger.info("Register {} to {}", path, indexName);
                    return true;
                }
                logger.warn("Invalid request for {}", path);
            }
        } catch (final Exception e) {
            logger.warn("Failed to register {}", filePath, e);
        }
        return false;
    }

	if l.LogLevel >= Info {
		l.Printf(l.infoStr+msg, append([]interface{}{utils.FileWithLineNum()}, data...)...)
	}
}

// Warn print warn messages
func (l *logger) Warn(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Warn {
		l.Printf(l.warnStr+msg, append([]interface{}{utils.FileWithLineNum()}, data...)...)
	}
}

// Error print error messages

                        logger.warn("  " + unsafeGoal.getId());
                    }
                } else {
                    logger.warn("The following plugins are not marked as thread-safe in " + project.getName() + ":");
                    for (Plugin unsafePlugin : unsafePlugins) {
                        logger.warn("  " + unsafePlugin.getId());
                    }
                    logger.warn("");

        }
    }

    /**
     * WARN情報を出力します。
     *
     * @param message
     *            メッセージ
     * @param throwable
     *            例外
     */
    public void warn(final Object message, final Throwable throwable) {
        log.warn(toString(message), throwable);
    }

    /**
     * WARN情報を出力します。
     *
     * @param message
     *            メッセージ

    @Override
    public boolean isWarnEnabled() {
        return logger.isWarnEnabled();
    }

    @Override
    public void warn(final String message) {
        logger.warn(message);
    }

    @Override
    public void warn(final String message, final Throwable t) {
        logger.warn(message, t);
    }

    @Override
    public boolean isInfoEnabled() {
        return logger.isInfoEnabled();
    }

            if (!p.waitFor(commandTimeout + commandDestroyTimeout, TimeUnit.MILLISECONDS)) {
                logger.warn("Destroying {} because of the process timeout.", getName());
                p.destroy();
            }

            final int exitValue = p.exitValue();
            if (exitValue != 0) {
                logger.warn("{} is failed (exit code:{}, timeout:{}): {}", getName(), exitValue, task.isExecuted(), commandList);
            }