Java Code Examples for sun.util.logging.PlatformLogger#Level

private static void checkLoggerLevel(PlatformLogger logger, Level level) {
    PlatformLogger.Level plevel = PlatformLogger.Level.valueOf(level.getName());
    if (plevel != logger.level()) {
        throw new RuntimeException("Retrieved PlatformLogger level "
                + logger.level()
                + " is not the same as set level " + plevel);
    }

    // check the level set in java.util.logging.Logger
    Logger javaLogger = LogManager.getLogManager().getLogger(logger.getName());
    Level javaLevel = javaLogger.getLevel();
    if (javaLogger.getLevel() != level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + javaLevel + " is not the expected " + level);
    }
}
 

static LogEvent valueOf(BootstrapLogger bootstrap, PlatformLogger.Level level,
                        String sourceClass, String sourceMethod,
                        ResourceBundle bundle, String msg, Object[] params) {
    return new LogEvent(Objects.requireNonNull(bootstrap),
                        Objects.requireNonNull(level), sourceClass,
                        sourceMethod, bundle, msg, null, params);
}
 

@Override
public final void logp(PlatformLogger.Level level, String sourceClass,
        String sourceMethod, Throwable thrown, Supplier<String> msgSupplier) {
    if (isLoggable(level)) {
        publish(getCallerInfo(sourceClass, sourceMethod), logLevel(level), msgSupplier.get(), thrown);
    }
}
 

@Override
public final void log(PlatformLogger.Level level, Throwable thrown,
        Supplier<String> msgSupplier) {
    if (isLoggable(level)) {
        publish(getCallerInfo(), logLevel(level), msgSupplier.get(), thrown);
    }
}
 

private static void checkPlatformLoggerLevelMapping(Level level) {
    // map the given level to PlatformLogger.Level of the same name and value
    PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
    if (platformLevel.intValue() != level.intValue()) {
        throw new RuntimeException("Mismatched level: " + level
                + " PlatformLogger.Level" + platformLevel);
    }
    if (!platformLevel.name().equals(level.getName())) {
        throw new RuntimeException("The value of PlatformLogger." + level.getName() + ".name() is "
                                   + platformLevel.name() + " but expected " + level.getName());
    }
}
 

private static void checkPlatformLoggerLevelMapping(Level level) {
    // map the given level to PlatformLogger.Level of the same name and value
    PlatformLogger.Level platformLevel = PlatformLogger.Level.valueOf(level.getName());
    if (platformLevel.intValue() != level.intValue()) {
        throw new RuntimeException("Mismatched level: " + level
                + " PlatformLogger.Level" + platformLevel);
    }
    if (!platformLevel.name().equals(level.getName())) {
        throw new RuntimeException("The value of PlatformLogger." + level.getName() + ".name() is "
                                   + platformLevel.name() + " but expected " + level.getName());
    }
}
 

@Override
public void logrb(PlatformLogger.Level level, ResourceBundle bundle,
        String msg, Object... params) {
    if (checkBootstrapping()) {
        push(LogEvent.valueOf(this, level, null, null, bundle, msg, params));
    } else {
        final PlatformLogger.Bridge spi = holder.platform();
        spi.logrb(level, bundle, msg, params);
    }
}
 

static LogEvent valueOf(BootstrapLogger bootstrap, PlatformLogger.Level level,
                        String sourceClass, String sourceMethod,
                        ResourceBundle bundle, String msg, Object[] params) {
    return new LogEvent(Objects.requireNonNull(bootstrap),
                        Objects.requireNonNull(level), sourceClass,
                        sourceMethod, bundle, msg, null, params);
}
 

@Override
public void log(PlatformLogger.Level level, String msg, Object... params) {
    if (checkBootstrapping()) {
        push(LogEvent.valueOf(this, level, msg, params));
    } else {
        final PlatformLogger.Bridge spi = holder.platform();
        spi.log(level, msg, params);
    }
}
 

static LogEvent valueOf(BootstrapLogger bootstrap, PlatformLogger.Level level,
                        String msg, Throwable thrown) {
    return new LogEvent(Objects.requireNonNull(bootstrap),
            Objects.requireNonNull(level), null, null, null, msg, thrown, null);
}
 

@Override
public final void log(PlatformLogger.Level level, Supplier<String> msgSupplier) {
    if (isLoggable(level)) {
        publish(getCallerInfo(), logLevel(level), msgSupplier.get());
    }
}
 

private static void checkJavaLoggerLevel(Logger logger, Level level) {
    // This method exercise the mapping of java level to platform level
    // when the java level is not one of the standard levels...

    System.out.println("Testing Java Level with: " + level.getName());

    // create a brand new java logger
    Logger javaLogger = (Logger) LoggingSupport.getLogger(logger.getName()+"."+level.getName());

    // Set a non standard java.util.logging.Level on the java logger
    // (except for OFF & ALL - which will remain unchanged)
    int intValue = level.intValue();
    if (level != Level.ALL && level != Level.OFF) {
        intValue -= 7;
    }
    javaLogger.setLevel(Level.parse(String.valueOf(intValue)));

    // check the level set in java.util.logging.Logger
    Level effectiveLevel = javaLogger.getLevel();
    System.out.println("Effective Java Level used is: " + effectiveLevel);

    if (effectiveLevel.intValue() != intValue) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
                + effectiveLevel.intValue() + " is not the expected " + intValue);
    }
    if (intValue != level.intValue() && javaLogger.getLevel() == level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is " + level);
    }
    if (intValue == level.intValue() && javaLogger.getLevel() != level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is not " + level);
    }

    // check the level set in the PlatformLogger
    PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
    PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
    if (plogger.level() != expected) {
        throw new RuntimeException("Retrieved backing PlatformLogger level "
                + plogger.level() + " is not the expected " + expected);

    }
}
 

private static void checkJavaLoggerLevel(Logger logger, Level level) {
    // This method exercise the mapping of java level to platform level
    // when the java level is not one of the standard levels...

    System.out.println("Testing Java Level with: " + level.getName());

    // create a brand new java logger
    Logger javaLogger = (Logger) LoggingSupport.getLogger(logger.getName()+"."+level.getName());

    // Set a non standard java.util.logging.Level on the java logger
    // (except for OFF & ALL - which will remain unchanged)
    int intValue = level.intValue();
    if (level != Level.ALL && level != Level.OFF) {
        intValue -= 7;
    }
    javaLogger.setLevel(Level.parse(String.valueOf(intValue)));

    // check the level set in java.util.logging.Logger
    Level effectiveLevel = javaLogger.getLevel();
    System.out.println("Effective Java Level used is: " + effectiveLevel);

    if (effectiveLevel.intValue() != intValue) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
                + effectiveLevel.intValue() + " is not the expected " + intValue);
    }
    if (intValue != level.intValue() && javaLogger.getLevel() == level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is " + level);
    }
    if (intValue == level.intValue() && javaLogger.getLevel() != level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is not " + level);
    }

    // check the level set in the PlatformLogger
    PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
    PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
    if (plogger.level() != expected) {
        throw new RuntimeException("Retrieved backing PlatformLogger level "
                + plogger.level() + " is not the expected " + expected);

    }
}
 

private static void checkJavaLoggerLevel(Logger logger, Level level) {
    // This method exercise the mapping of java level to platform level
    // when the java level is not one of the standard levels...

    System.out.println("Testing Java Level with: " + level.getName());

    // create a brand new java logger
    Logger javaLogger = (Logger) LoggingSupport.getLogger(logger.getName()+"."+level.getName());

    // Set a non standard java.util.logging.Level on the java logger
    // (except for OFF & ALL - which will remain unchanged)
    int intValue = level.intValue();
    if (level != Level.ALL && level != Level.OFF) {
        intValue -= 7;
    }
    javaLogger.setLevel(Level.parse(String.valueOf(intValue)));

    // check the level set in java.util.logging.Logger
    Level effectiveLevel = javaLogger.getLevel();
    System.out.println("Effective Java Level used is: " + effectiveLevel);

    if (effectiveLevel.intValue() != intValue) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
                + effectiveLevel.intValue() + " is not the expected " + intValue);
    }
    if (intValue != level.intValue() && javaLogger.getLevel() == level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is " + level);
    }
    if (intValue == level.intValue() && javaLogger.getLevel() != level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is not " + level);
    }

    // check the level set in the PlatformLogger
    PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
    PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
    if (plogger.level() != expected) {
        throw new RuntimeException("Retrieved backing PlatformLogger level "
                + plogger.level() + " is not the expected " + expected);

    }
}
 

static LogEvent valueOf(BootstrapLogger bootstrap,
                        PlatformLogger.Level level, String msg) {
    return new LogEvent(Objects.requireNonNull(bootstrap),
                        Objects.requireNonNull(level), null, null, null,
                        msg, null, null);
}
 

private static void checkJavaLoggerLevel(Logger logger, Level level) {
    // This method exercise the mapping of java level to platform level
    // when the java level is not one of the standard levels...

    System.out.println("Testing Java Level with: " + level.getName());

    // create a brand new java logger
    Logger javaLogger = (Logger) LoggingSupport.getLogger(logger.getName()+"."+level.getName());

    // Set a non standard java.util.logging.Level on the java logger
    // (except for OFF & ALL - which will remain unchanged)
    int intValue = level.intValue();
    if (level != Level.ALL && level != Level.OFF) {
        intValue -= 7;
    }
    javaLogger.setLevel(Level.parse(String.valueOf(intValue)));

    // check the level set in java.util.logging.Logger
    Level effectiveLevel = javaLogger.getLevel();
    System.out.println("Effective Java Level used is: " + effectiveLevel);

    if (effectiveLevel.intValue() != intValue) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level.intValue() "
                + effectiveLevel.intValue() + " is not the expected " + intValue);
    }
    if (intValue != level.intValue() && javaLogger.getLevel() == level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is " + level);
    }
    if (intValue == level.intValue() && javaLogger.getLevel() != level) {
        throw new RuntimeException("Retrieved backing java.util.logging.Logger level "
                + effectiveLevel + " is not " + level);
    }

    // check the level set in the PlatformLogger
    PlatformLogger plogger = PlatformLogger.getLogger(javaLogger.getName());
    PlatformLogger.Level expected = PlatformLogger.Level.valueOf(level.getName());
    if (plogger.level() != expected) {
        throw new RuntimeException("Retrieved backing PlatformLogger level "
                + plogger.level() + " is not the expected " + expected);

    }
}
 

@Override
public default void logp(PlatformLogger.Level level, String sourceClass,
                 String sourceMethod, Throwable thrown,
                 Supplier<String> msgSupplier) {
}
 

@Override
public final PlatformLogger.Level getPlatformLevel() {
    return level;
}
 

private static void checkLevel(PlatformLogger logger, PlatformLogger.Level level) {
    if (logger.level() != level) {
        throw new RuntimeException("Invalid level for logger " +
            logger.getName() + ": " + logger.level() + " != " + level);
    }
}
 

private static void checkLevel(PlatformLogger logger, PlatformLogger.Level level) {
    if (logger.level() != level) {
        throw new RuntimeException("Invalid level for logger " +
            logger.getName() + ": " + logger.level() + " != " + level);
    }
}