import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;

public class FessFileTransformer extends AbstractFessFileTransformer {
    private static final Logger logger = LogManager.getLogger(FessFileTransformer.class);

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }

        //(SF) checking if the logger level was not overridden.
        //this gives some confidence that the LogManager was not reset
        given:
        LogManager.getLogManager().getLogger("").setLevel(OFF);
        buildFile << "task hey"

        when:
        assertJavaUtilLoggingNotModified()

     */
    val buildscript: ScriptHandler
        get() = host.scriptHandler

    private
    class SettingsScriptHost(val host: KotlinScriptHost<Settings>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Settings::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations

    }

    @Override
    public LoggingManager getLogging() {
        return getScriptTarget().getLogging();
    }

    @Override
    public Logger getLogger() {
        return getScriptTarget().getLogger();
    }

    @Override
    public String toString() {
        return getScriptTarget().toString();
    }

    @Override
    public ProjectInternal getScriptTarget() {

            import org.testng.annotations.*;

            public class FooTest {
                private final static org.slf4j.Logger SLF4J = org.slf4j.LoggerFactory.getLogger(FooTest.class);
                private final static java.util.logging.Logger JUL = java.util.logging.Logger.getLogger(FooTest.class.getName());

                @Test public void foo() {
                  SLF4J.info("slf4j info");
                  JUL.info("jul info");

def slf4jLogger = org.slf4j.LoggerFactory.getLogger('some-logger')
slf4jLogger.warn('A warning using SLF4j')

def jclLogger = org.apache.commons.logging.LogFactory.getLog('some-logger')
jclLogger.warn('A warning using JCL')

def log4jLogger = org.apache.log4j.Logger.getLogger('some-logger')
log4jLogger.warn('A warning using Log4j')

def julLogger = java.util.logging.Logger.getLogger('some-logger')

                } else {
                    message += " from local repository";
                }
                getLogger().debug(message);
            } else {
                // Locally installed file is newer, don't use the resolved version
                getLogger().debug(artifact.getArtifactId() + ": using locally installed snapshot");
            }
        }
        return version;
    }

            ${testFrameworkImports}
            public class FooTest {
                private final static org.slf4j.Logger SLF4J = org.slf4j.LoggerFactory.getLogger(FooTest.class);
                private final static java.util.logging.Logger JUL = java.util.logging.Logger.getLogger(FooTest.class.getName());

                @Test
                public void foo() {
                  SLF4J.info("slf4j info");

    public Slf4jLoggerManager() {
        loggerFactory = LoggerFactory.getILoggerFactory();
    }

    public Logger getLoggerForComponent(String role) {
        return new Slf4jLogger(loggerFactory.getLogger(role));
    }

    /**
     * The logger name for a component with a non-null hint is <code>role.hint</code>.
     * <b>Warning</b>: this does not conform to logger name as class name convention.

  public void apply(Project project) {
    Task hello = project.getTasks().create("hello");
    hello.doLast(new Action<Task>() {
      @Override
      public void execute(Task task) {
        task.getLogger().lifecycle("Hello!");
      }
    });
  }