for (String task : tasks) {
            if (isBeforeOrAfterPhase(task)) {
                String prevTask = task;
                task = PhaseId.of(task).phase();
                LOGGER.warn("Illegal call to phase '{}'. The main phase '{}' will be used instead.", prevTask, task);
            }
            if (isGoalSpecification(task)) {

                    }
                    continue;
                }

                final Matcher m = parsePattern.matcher(replacedLine);

                if (!m.find()) {
                    logger.warn("Failed to parse stemmer override: line={}, path={}", line, path);
                    if (updater != null) {
                        updater.write("# " + line);
                    }
                    continue;

        if (bulkRequestBuilder != null) {
            final BulkResponse response = bulkRequestBuilder.execute().actionGet(requestTimeout);
            if (response.hasFailures()) {
                logger.warn("Failed to update scores: {}", response.buildFailureMessage());
            }
            bulkRequestBuilder = null;
        }
    }

    /**
     * Gets the priority of this score booster.

            loggedExec.args("-Dscan.tag.NESTED");
            final LogLevel logLevel = project.getGradle().getStartParameter().getLogLevel();
            List<LogLevel> nonDefaultLogLevels = Arrays.asList(LogLevel.QUIET, LogLevel.WARN, LogLevel.INFO, LogLevel.DEBUG);
            if (nonDefaultLogLevels.contains(logLevel)) {
                loggedExec.args("--" + logLevel.name().toLowerCase(Locale.ENGLISH));
            }

import okhttp3.internal.http2.Http2
import okhttp3.internal.platform.android.AndroidLog.androidLog

private val LogRecord.androidLevel: Int
  get() =
    when {
      level.intValue() > Level.INFO.intValue() -> Log.WARN
      level.intValue() == Level.INFO.intValue() -> Log.INFO
      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {
  override fun publish(record: LogRecord) {

        if (logger.isDebugEnabled()) {
            logger.debug("[{}] {}", errorCode, stacktraceString.get().replace("\n", "\\n"));
        } else {
            logger.warn("[{}] {}", errorCode, cause.getMessage());
        }
        return "error_code:" + errorCode;
    }

    }

    /**
     * Logs a warning with a warning icon.
     */
    public void warning(String message) {
        logger.warn(getCurrentIndent() + ConsoleIcon.WARNING.getIcon(terminal) + " " + message);
    }

    /**
     * Logs detailed information with a bullet point.
     */
    public void detail(String message) {

                } catch (final UnsupportedEncodingException e) {
                    // UTF-8 should always be supported, but log if it somehow isn't
                    logger.warn("UTF-8 encoding not supported - this should not happen: char={}", c, e);
                }
            }
        }
        configPath = convertCrawlingPath(buf.toString());

            len += 2;
            if (len > maxLen) {
                if (log.isDebugEnabled()) {
                    log.warn("Failed to find string termination with max length " + maxLen);
                    log.debug(Hexdump.toHexString(buffer, bufferIndex, len));
                }

                                return new PluginInfo(groupId, artifactId, goalPrefix, name);
                            } else {
                                logger.warn(
                                        "Artifact {}:{}"
                                                + " JAR (about to be installed/deployed) contains Maven Plugin metadata for"