306 lines
13 KiB
Java
306 lines
13 KiB
Java
/*
|
|
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.PrintStream;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.nio.file.StandardCopyOption;
|
|
import java.util.Collections;
|
|
import java.util.Enumeration;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
import java.util.logging.Handler;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.LogManager;
|
|
import java.util.logging.Logger;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8191033
|
|
* @build custom.DotHandler custom.Handler
|
|
* @run main/othervm -Dlogging.properties=badlogging.properties -Dclz=1custom.DotHandler BadRootLoggerHandlers CUSTOM
|
|
* @run main/othervm -Dlogging.properties=badlogging.properties -Dclz=1custom.DotHandler BadRootLoggerHandlers DEFAULT
|
|
* @run main/othervm -Dlogging.properties=badglobal.properties -Dclz=1custom.GlobalHandler BadRootLoggerHandlers CUSTOM
|
|
* @run main/othervm -Dlogging.properties=badglobal.properties -Dclz=1custom.GlobalHandler BadRootLoggerHandlers DEFAULT
|
|
* @run main/othervm/java.security.policy==test.policy -Dlogging.properties=badlogging.properties -Dclz=1custom.DotHandler BadRootLoggerHandlers CUSTOM
|
|
* @run main/othervm/java.security.policy==test.policy -Dlogging.properties=badlogging.properties -Dclz=1custom.DotHandler BadRootLoggerHandlers DEFAULT
|
|
* @run main/othervm/java.security.policy==test.policy -Dlogging.properties=badglobal.properties -Dclz=1custom.GlobalHandler BadRootLoggerHandlers CUSTOM
|
|
* @run main/othervm/java.security.policy==test.policy -Dlogging.properties=badglobal.properties -Dclz=1custom.GlobalHandler BadRootLoggerHandlers DEFAULT
|
|
* @author danielfuchs
|
|
*/
|
|
public class BadRootLoggerHandlers {
|
|
|
|
public static final Path SRC_DIR =
|
|
Paths.get(System.getProperty("test.src", "src"));
|
|
public static final Path USER_DIR =
|
|
Paths.get(System.getProperty("user.dir", "."));
|
|
public static final Path CONFIG_FILE = Paths.get(
|
|
Objects.requireNonNull(System.getProperty("logging.properties")));
|
|
public static final String BAD_HANDLER_NAME =
|
|
Objects.requireNonNull(System.getProperty("clz"));
|
|
|
|
static enum TESTS { CUSTOM, DEFAULT}
|
|
public static final class CustomLogManager extends LogManager {
|
|
final ConcurrentMap<String, Logger> loggers = new ConcurrentHashMap<>();
|
|
@Override
|
|
public boolean addLogger(Logger logger) {
|
|
return loggers.putIfAbsent(logger.getName(), logger) == null;
|
|
}
|
|
|
|
@Override
|
|
public Enumeration<String> getLoggerNames() {
|
|
return Collections.enumeration(loggers.keySet());
|
|
}
|
|
|
|
@Override
|
|
public Logger getLogger(String name) {
|
|
return loggers.get(name);
|
|
}
|
|
}
|
|
|
|
public static class SystemErr extends OutputStream {
|
|
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
|
final OutputStream wrapped;
|
|
public SystemErr(OutputStream out) {
|
|
this.wrapped = out;
|
|
}
|
|
|
|
@Override
|
|
public void write(int b) throws IOException {
|
|
baos.write(b);
|
|
wrapped.write(b);
|
|
}
|
|
|
|
public void close() throws IOException {
|
|
flush();
|
|
super.close();
|
|
}
|
|
|
|
public void flush() throws IOException {
|
|
super.flush();
|
|
wrapped.flush();
|
|
}
|
|
|
|
}
|
|
|
|
// Uncomment this to run the test on Java 8. Java 8 does not have
|
|
// List.of(...)
|
|
// static final class List {
|
|
// static <T> java.util.List<T> of(T... items) {
|
|
// return Collections.unmodifiableList(Arrays.asList(items));
|
|
// }
|
|
// }
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
Path initialProps = SRC_DIR.resolve(CONFIG_FILE);
|
|
Path loggingProps = USER_DIR.resolve(CONFIG_FILE);
|
|
if (args.length != 1) {
|
|
throw new IllegalArgumentException("expected (only) one of " + List.of(TESTS.values()));
|
|
}
|
|
|
|
TESTS test = TESTS.valueOf(args[0]);
|
|
System.setProperty("java.util.logging.config.file", loggingProps.toString());
|
|
if (test == TESTS.CUSTOM) {
|
|
System.setProperty("java.util.logging.manager", CustomLogManager.class.getName());
|
|
}
|
|
|
|
Files.copy(initialProps, loggingProps, StandardCopyOption.REPLACE_EXISTING);
|
|
loggingProps.toFile().setWritable(true);
|
|
|
|
SystemErr err = new SystemErr(System.err);
|
|
System.setErr(new PrintStream(err));
|
|
|
|
System.out.println("Root level is: " + Logger.getLogger("").getLevel());
|
|
if (Logger.getLogger("").getLevel() != Level.INFO) {
|
|
throw new RuntimeException("Expected root level INFO, got: "
|
|
+ Logger.getLogger("").getLevel());
|
|
}
|
|
|
|
Class<? extends LogManager> logManagerClass =
|
|
LogManager.getLogManager().getClass();
|
|
Class<? extends LogManager> expectedClass =
|
|
test == TESTS.CUSTOM ? CustomLogManager.class : LogManager.class;
|
|
if (logManagerClass != expectedClass) {
|
|
throw new RuntimeException("Bad class for log manager: " + logManagerClass
|
|
+ " expected " + expectedClass + " for " + test);
|
|
}
|
|
|
|
if (test == TESTS.DEFAULT) {
|
|
// Verify that we have two handlers. One was configured with
|
|
// handlers=custom.Handler, the other with
|
|
// .handlers=custom.DotHandler
|
|
// Verify that exactly one of the two handlers is a custom.Handler
|
|
// Verify that exactly one of the two handlers is a custom.DotHandler
|
|
// Verify that the two handlers have an id of '1'
|
|
checkHandlers(Logger.getLogger(""),
|
|
Logger.getLogger("").getHandlers(),
|
|
1L,
|
|
custom.Handler.class,
|
|
custom.DotHandler.class);
|
|
} else {
|
|
// Verify that we have one handler, configured with
|
|
// handlers=custom.Handler.
|
|
// Verify that it is a custom.Handler
|
|
// Verify that the handler have an id of '1'
|
|
checkHandlers(Logger.getLogger(""),
|
|
Logger.getLogger("").getHandlers(),
|
|
1L,
|
|
custom.Handler.class);
|
|
|
|
}
|
|
|
|
// DEFAULT: The log message "hi" should appear twice on the console.
|
|
// CUSTOM: The log message "hi" should appear twice on the console.
|
|
// We don't check that. This is just for log analysis in case
|
|
// of test failure.
|
|
Logger.getAnonymousLogger().info("hi (" + test +")");
|
|
|
|
// Change the root logger level to FINE in the properties file
|
|
// and reload the configuration.
|
|
Files.write(loggingProps,
|
|
Files.lines(initialProps)
|
|
.map((s) -> s.replace("INFO", "FINE"))
|
|
.collect(Collectors.toList()));
|
|
LogManager.getLogManager().readConfiguration();
|
|
|
|
System.out.println("Root level is: " + Logger.getLogger("").getLevel());
|
|
if (Logger.getLogger("").getLevel() != Level.FINE) {
|
|
throw new RuntimeException("Expected root level FINE, got: "
|
|
+ Logger.getLogger("").getLevel());
|
|
}
|
|
|
|
// Verify that we have now only one handler, configured with
|
|
// handlers=custom.Handler, and that the other configured with
|
|
// .handlers=custom.DotHandler was ignored.
|
|
// Verify that the handler is a custom.Handler
|
|
// Verify that the handler has an id of '2'
|
|
checkHandlers(Logger.getLogger(""),
|
|
Logger.getLogger("").getHandlers(),
|
|
2L,
|
|
custom.Handler.class);
|
|
|
|
// The log message "there" should appear only once on the console.
|
|
// We don't check that. This is just for log analysis in case
|
|
// of test failure.
|
|
Logger.getAnonymousLogger().info("there!");
|
|
|
|
// Change the root logger level to FINER in the properties file
|
|
// and reload the configuration.
|
|
Files.write(loggingProps,
|
|
Files.lines(initialProps)
|
|
.map((s) -> s.replace("INFO", "FINER"))
|
|
.collect(Collectors.toList()));
|
|
LogManager.getLogManager().readConfiguration();
|
|
|
|
System.out.println("Root level is: " + Logger.getLogger("").getLevel());
|
|
if (Logger.getLogger("").getLevel() != Level.FINER) {
|
|
throw new RuntimeException("Expected root level FINER, got: "
|
|
+ Logger.getLogger("").getLevel());
|
|
}
|
|
|
|
// Verify that we have only one handler, configured with
|
|
// handlers=custom.Handler, and that the other configured with
|
|
// .handlers=custom.DotHandler was ignored.
|
|
// Verify that the handler is a custom.Handler
|
|
// Verify that the handler has an id of '3'
|
|
checkHandlers(Logger.getLogger(""),
|
|
Logger.getLogger("").getHandlers(),
|
|
3L,
|
|
custom.Handler.class);
|
|
|
|
// The log message "done" should appear only once on the console.
|
|
// We don't check that. This is just for log analysis in case
|
|
// of test failure.
|
|
Logger.getAnonymousLogger().info("done!");
|
|
|
|
byte[] errBytes = err.baos.toByteArray();
|
|
String errText = new String(errBytes);
|
|
switch(test) {
|
|
case CUSTOM:
|
|
if (errText.contains("java.lang.ClassNotFoundException: "
|
|
+ BAD_HANDLER_NAME)) {
|
|
throw new RuntimeException("Error message found on System.err");
|
|
}
|
|
System.out.println("OK: ClassNotFoundException error message not found for " + test);
|
|
break;
|
|
case DEFAULT:
|
|
if (!errText.contains("java.lang.ClassNotFoundException: "
|
|
+ BAD_HANDLER_NAME)) {
|
|
throw new RuntimeException("Error message not found on System.err");
|
|
}
|
|
System.err.println("OK: ClassNotFoundException error message found for " + test);
|
|
break;
|
|
default:
|
|
throw new InternalError("unknown test case: " + test);
|
|
}
|
|
}
|
|
|
|
static void checkHandlers(Logger logger, Handler[] handlers, Long expectedID, Class<?>... clz) {
|
|
// Verify that we have the expected number of handlers.
|
|
if (Stream.of(handlers).count() != clz.length) {
|
|
throw new RuntimeException("Expected " + clz.length + " handlers, got: "
|
|
+ List.of(logger.getHandlers()));
|
|
}
|
|
for (Class<?> cl : clz) {
|
|
// Verify that the handlers are of the expected class.
|
|
// For each class, we should have exactly one handler
|
|
// of that class.
|
|
if (Stream.of(handlers)
|
|
.map(Object::getClass)
|
|
.filter(cl::equals)
|
|
.count() != 1) {
|
|
throw new RuntimeException("Expected one " + cl +", got: "
|
|
+ List.of(logger.getHandlers()));
|
|
}
|
|
}
|
|
// Verify that all handlers have the expected ID
|
|
if (Stream.of(logger.getHandlers())
|
|
.map(BadRootLoggerHandlers::getId)
|
|
.filter(expectedID::equals)
|
|
.count() != clz.length) {
|
|
throw new RuntimeException("Expected ids to be " + expectedID + ", got: "
|
|
+ List.of(logger.getHandlers()));
|
|
}
|
|
}
|
|
|
|
static long getId(Handler h) {
|
|
if (h instanceof custom.Handler) {
|
|
return ((custom.Handler)h).id;
|
|
}
|
|
if (h instanceof custom.DotHandler) {
|
|
return ((custom.DotHandler)h).id;
|
|
}
|
|
if (h instanceof custom.GlobalHandler) {
|
|
return ((custom.GlobalHandler)h).id;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|