Java Logger类代码示例

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
public void testLogger()
{
    Logger log = new DependencySilentLog();
    String text = new String( "Text" );
    Throwable e = new RuntimeException();

    log.debug( text );
    log.debug( text, e );
    log.error( text );
    log.error( text, e );
    log.warn( text );
    log.warn( text, e );
    log.info( text );
    log.info( text, e );

    log.fatalError( text );
    log.fatalError( text, e );
    log.getChildLogger( text );
    log.getName();
    log.getThreshold();
    log.isDebugEnabled();
    log.isErrorEnabled();
    log.isFatalErrorEnabled();
    log.isInfoEnabled();
    log.isWarnEnabled();
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Test
public void testAfterSessionStart_nullRevision()
        throws MavenExecutionException,
        RevisionGeneratorException {
    String revision = null;
    exceptions.expect(MavenExecutionException.class);
    exceptions.expectMessage("RevisionGenerator returned a null revision value");
    exceptions.expectCause(IsInstanceOf.any(RevisionGeneratorException.class));
    when(revisionGenerator.getRevision()).thenReturn(revision);

    try {
        item.afterSessionStart(session);
    } finally {
        verify(revisionGenerator).init(eq(session), any(Logger.class));
        verify(revisionGenerator).getRevision();
        verifyNoMoreInteractions(revisionGenerator);
        verifyZeroInteractions(session);
        verifyZeroInteractions(pluginMerger);
        verifyZeroInteractions(plugins);
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Test
public void afterSessionStart_initThrowsRevisionGeneratorException()
        throws MavenExecutionException,
        RevisionGeneratorException {

    RevisionGeneratorException exception = new RevisionGeneratorException("msg", new RuntimeException("dummy sub cause"));

    exceptions.expect(MavenExecutionException.class);
    exceptions.expectMessage(exception.getMessage());
    exceptions.expectCause(IsEqual.equalTo(exception));
    doThrow(exception).when(revisionGenerator).init(eq(session), any(Logger.class));

    try {
        item.afterSessionStart(session);
    } finally {
        verify(revisionGenerator).init(eq(session), any(Logger.class));
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Test
public void afterSessionStart_initThrowsRuntimeException()
        throws MavenExecutionException,
        RevisionGeneratorException {

    RuntimeException exception = new RuntimeException("random exception");

    exceptions.expect(MavenExecutionException.class);
    exceptions.expectMessage("Unexpected Exception during RevisionGenerator Initialisation");
    exceptions.expectCause(IsEqual.equalTo(exception));
    doThrow(exception).when(revisionGenerator).init(eq(session), any(Logger.class));

    try {
        item.afterSessionStart(session);
    } finally {
        verify(revisionGenerator).init(eq(session), any(Logger.class));
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
public SetupsMojoTestHelper( AbstractSetupsMojo mojo ) throws IOException {
   this.workingDir = new File( System.getProperty( "java.io.tmpdir" ), "unit_test_working" );

   this.mojo = mojo;

   this.mojo.workingDir = this.workingDir.getCanonicalPath();
   this.mojo.root = FitNesseHelper.DEFAULT_ROOT;
   this.mojo.project = new MavenProject();
   this.mojo.project.setFile( new File( getClass().getResource( "pom.xml" ).getPath() ) );
   this.mojo.pluginDescriptor = new PluginDescriptor();
   this.mojo.pluginManager = mock( BuildPluginManager.class );
   this.mojo.session = mock( MavenSession.class );

   this.logStream = new ByteArrayOutputStream();
   this.mojo.setLog( new DefaultLog( new PrintStreamLogger( Logger.LEVEL_INFO, "test", new PrintStream( this.logStream ) ) ) );
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
public static void execute( Commandline cl, Logger logger )
    throws NativeBuildException
{
    int ok;

    try
    {
        DefaultConsumer stdout = new DefaultConsumer();

        DefaultConsumer stderr = stdout;

        logger.info( cl.toString() );

        ok = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
    }
    catch ( CommandLineException ecx )
    {
        throw new NativeBuildException( "Error executing command line", ecx );
    }

    if ( ok != 0 )
    {
        throw new NativeBuildException( "Error executing command line. Exit code:" + ok );
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
public UnpackedLibHelper ( ArtifactResolverHelper artifactResolverHelper, MavenProject project, Logger log,
                           File unpackedLibsFolder )
{
    this.artifactResolverHelper = artifactResolverHelper;
    if ( unpackedLibsFolder != null )
    {
        // if absolute then use it.
        // if relative then make it relative to the basedir of the project.
        this.unpackedLibsDirectory = unpackedLibsFolder.isAbsolute()
                ? unpackedLibsFolder
                : new File ( project.getBasedir(), unpackedLibsFolder.getPath() );
    }
    else
    {
        // If not specified then default to target/unpacked-libs
        final File targetFolder = new File ( project.getBuild().getDirectory() );
        this.unpackedLibsDirectory = new File ( targetFolder, "unpacked-libs" );
    }
    this.log = log;
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Override
public int getThreshold()
{
    if ( delegate.isErrorEnabled() )
    {
        return Logger.LEVEL_ERROR;
    }
    else if ( delegate.isWarnEnabled() )
    {
        return Logger.LEVEL_WARN;
    }
    else if ( delegate.isInfoEnabled() )
    {
        return Logger.LEVEL_INFO;
    }

    return Logger.LEVEL_DEBUG;
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
public ArtifactResolverHelper( ArtifactResolver artifactResolver, Logger log,
                              final List<ArtifactRepository> remoteArtifactRepositories )
{
    this.artifactResolver = artifactResolver;
    this.log = log;
    this.remoteArtifactRepositories = remoteArtifactRepositories;
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
private int getMavenLogLevel()
{
    switch (logLevel)
    {
        case "DEBUG":
            return Logger.LEVEL_DEBUG;
        case "WARN":
            return Logger.LEVEL_WARN;
        case "ERROR":
            return Logger.LEVEL_ERROR;
        case "FATAL":
            return Logger.LEVEL_FATAL;
        case "DISABLED":
            return Logger.LEVEL_DISABLED;
        case "INFO":
        default:
            return Logger.LEVEL_INFO;
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
private static File tar(Set<File> files, String folder) throws IOException {
    TarArchiver tarArchive = new TarArchiver();
    tarArchive.enableLogging(new ConsoleLogger(Logger.LEVEL_DISABLED, "console"));
    for (File file : files) {
        // The starting ./ in the folder name is required for Heroku to be able to unpack the files correctly.
        if (file.isFile()) {
            tarArchive.addFile(file, "./" + folder + "/" + file.getName());
        } else if (file.isDirectory()) {
            tarArchive.addDirectory(file, "./" + folder + "/" + file.getName() + "/");
        }
    }

    File tarFile = File.createTempFile("TarGzArchive", ".tar");
    tarArchive.setDestFile(tarFile);
    tarArchive.createArchive();

    return tarFile;
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Override
public void init(MavenSession session, Logger logger) throws RevisionGeneratorException {
    Git git = null;
    try {
        if (session.getExecutionRootDirectory() == null) {
            revision = "1.0-SNAPSHOT";
            dirty = true;
        } else {
            File gitDir = new FileRepositoryBuilder()
                    .findGitDir(new F‌ile(session.getExecutionRootDirectory()))
                    .getGitDir();
            if (gitDir != null && gitDir.exists()) {
                git = Git.open(gitDir);
                init(git, logger);
            } else {
                revision = "1.0-SNAPSHOT";
                dirty = true;
            }
        }
    } catch (IOException ex) {
        throw new RevisionGeneratorException("Issue opening Git repository for the project", ex);
    } finally {
        if (git != null) {
            git.close();
        }
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
@Test
@Parameters({
    "false, 20160101-133423-abcdefg, false",
    "false, 20160101-133423-abcdefg, true",
    "true, 20160101-133423-abcdefg-SNPASHOT, false",
    "true, 20160101-133423-abcdefg-SNAPSHOT, true",})
public void testAfterSessionStart_withRevision(boolean dirty, String revision, boolean failSnapshot)
        throws MavenExecutionException,
        RevisionGeneratorException {
    Properties userProperties = new Properties();
    userProperties.put("cdversion.snapshot.fail", String.valueOf(failSnapshot));

    if (dirty && failSnapshot) {
        exceptions.expect(MavenExecutionException.class);
    }

    when(session.getUserProperties()).thenReturn(userProperties);
    when(revisionGenerator.getRevision()).thenReturn(revision);
    when(revisionGenerator.isDirty()).thenReturn(dirty);

    try {
        item.afterSessionStart(session);

        Assert.assertEquals("UserProperties.Size", 2, userProperties.size());
        Assert.assertNotNull("UserProperties[revision]", userProperties.get("revision"));
        Assert.assertEquals("UserProperties[revision]", revision, userProperties.get("revision"));
    } finally {
        verify(session).getUserProperties();
        verify(revisionGenerator).init(eq(session), any(Logger.class));
        verify(revisionGenerator).isDirty();
        verify(revisionGenerator).getRevision();
        verifyNoMoreInteractions(session);
        verifyNoMoreInteractions(revisionGenerator);
        verifyZeroInteractions(pluginMerger);
        verifyZeroInteractions(plugins);
    }
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
private static DefaultShader newShader()
{
    DefaultShader s = new DefaultShader();

    s.enableLogging( new ConsoleLogger( Logger.LEVEL_INFO, "TEST" ) );

    return s;
}
 

import org.codehaus.plexus.logging.Logger; //导入依赖的package包/类
protected void setUp()
    throws Exception
{
    super.setUp();

    LoggerManager loggerManager = (LoggerManager) lookup( LoggerManager.ROLE );

    loggerManager.setThreshold( Logger.LEVEL_DEBUG );
}