| /* |
| * Copyright (c) 2013, 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. |
| */ |
| |
| /* |
| * @test |
| * @bug 8029781 8030801 |
| * @summary Test which verifies that various JDK logging Handlers are |
| * configured correctly from defaults and/or LogManager properties |
| * as specified in javadoc and that no special |
| * logging permission is required for instantiating them. |
| * @modules java.logging/java.util.logging:open |
| * @run main/othervm HandlersConfigTest default |
| * @run main/othervm HandlersConfigTest configured |
| */ |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.lang.reflect.Field; |
| import java.net.ServerSocket; |
| import java.net.URL; |
| import java.util.Objects; |
| import java.util.logging.ConsoleHandler; |
| import java.util.logging.Filter; |
| import java.util.logging.Formatter; |
| import java.util.logging.Handler; |
| import java.util.logging.Level; |
| import java.util.logging.LogManager; |
| import java.util.logging.LogRecord; |
| import java.util.logging.MemoryHandler; |
| import java.util.logging.SimpleFormatter; |
| import java.util.logging.SocketHandler; |
| import java.util.logging.StreamHandler; |
| import java.util.logging.XMLFormatter; |
| |
| public abstract class HandlersConfigTest implements Runnable { |
| |
| public static void main(String[] args) { |
| switch (args.length == 1 ? args[0] : "usage") { |
| case "default": |
| new Default().run(); |
| break; |
| case "configured": |
| new Configured().run(); |
| break; |
| default: |
| System.err.println("Usage: HandlersConfigTest [default|configured]"); |
| break; |
| } |
| } |
| |
| static final String CONFIG_FILE_PROPERTY = "java.util.logging.config.file"; |
| final Field memoryHandlerTarget, memoryHandlerSize, streamHandlerOutput; |
| final ServerSocket serverSocket; |
| |
| HandlersConfigTest() { |
| // establish access to private fields |
| try { |
| memoryHandlerTarget = MemoryHandler.class.getDeclaredField("target"); |
| memoryHandlerTarget.setAccessible(true); |
| memoryHandlerSize = MemoryHandler.class.getDeclaredField("size"); |
| memoryHandlerSize.setAccessible(true); |
| streamHandlerOutput = StreamHandler.class.getDeclaredField("output"); |
| streamHandlerOutput.setAccessible(true); |
| } catch (NoSuchFieldException e) { |
| throw new AssertionError(e); |
| } |
| |
| // load logging.propertes for the test |
| String rname = getClass().getName().replace('.', '/') + ".props"; |
| URL url = getClass().getClassLoader().getResource(rname); |
| if (url == null || !"file".equals(url.getProtocol())) { |
| throw new IllegalStateException("Resource: " + rname + " not found or not on file: " + url); |
| } |
| System.setProperty(CONFIG_FILE_PROPERTY, url.getFile()); |
| |
| // create ServerSocket as a target for SocketHandler |
| try { |
| serverSocket = new ServerSocket(0); // auto allocated port |
| } catch (IOException e) { |
| throw new AssertionError(e); |
| } |
| |
| // activate security |
| System.setSecurityManager(new SecurityManager() { |
| @Override |
| public void checkConnect(String host, int port) { |
| // allow socket connections |
| } |
| }); |
| |
| // initialize logging system |
| LogManager.getLogManager(); |
| } |
| |
| // check that defaults are used as specified by javadoc |
| |
| public static class Default extends HandlersConfigTest { |
| public static void main(String[] args) { |
| new Default().run(); |
| } |
| |
| @Override |
| public void run() { |
| // MemoryHandler |
| |
| check(new MemoryHandler(), |
| Level.ALL, null, null, SimpleFormatter.class, |
| ConfiguredHandler.class, 1000, Level.SEVERE); |
| |
| check(new MemoryHandler(new SpecifiedHandler(), 100, Level.WARNING), |
| Level.ALL, null, null, SimpleFormatter.class, |
| SpecifiedHandler.class, 100, Level.WARNING); |
| |
| // StreamHandler |
| |
| check(new StreamHandler(), |
| Level.INFO, null, null, SimpleFormatter.class, |
| null); |
| |
| check(new StreamHandler(System.out, new SpecifiedFormatter()), |
| Level.INFO, null, null, SpecifiedFormatter.class, |
| System.out); |
| |
| // ConsoleHandler |
| |
| check(new ConsoleHandler(), |
| Level.INFO, null, null, SimpleFormatter.class, |
| System.err); |
| |
| // SocketHandler (use the ServerSocket's port) |
| |
| try { |
| check(new SocketHandler("localhost", serverSocket.getLocalPort()), |
| Level.ALL, null, null, XMLFormatter.class); |
| } catch (IOException e) { |
| throw new RuntimeException("Can't connect to localhost:" + serverSocket.getLocalPort(), e); |
| } |
| } |
| } |
| |
| // check that LogManager properties configuration is respected |
| |
| public static class Configured extends HandlersConfigTest { |
| public static void main(String[] args) { |
| new Configured().run(); |
| } |
| |
| @Override |
| public void run() { |
| // MemoryHandler |
| |
| check(new MemoryHandler(), |
| Level.FINE, null, ConfiguredFilter.class, ConfiguredFormatter.class, |
| ConfiguredHandler.class, 123, Level.FINE); |
| |
| check(new MemoryHandler(new SpecifiedHandler(), 100, Level.WARNING), |
| Level.FINE, null, ConfiguredFilter.class, ConfiguredFormatter.class, |
| SpecifiedHandler.class, 100, Level.WARNING); |
| |
| // StreamHandler |
| |
| check(new StreamHandler(), |
| Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class, |
| null); |
| |
| check(new StreamHandler(System.out, new SpecifiedFormatter()), |
| Level.FINE, "ASCII", ConfiguredFilter.class, SpecifiedFormatter.class, |
| System.out); |
| |
| // ConsoleHandler |
| |
| check(new ConsoleHandler(), |
| Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class, |
| System.err); |
| |
| // SocketHandler (use the ServerSocket's port) |
| |
| try { |
| check(new SocketHandler("localhost", serverSocket.getLocalPort()), |
| Level.FINE, "ASCII", ConfiguredFilter.class, ConfiguredFormatter.class); |
| } catch (Exception e) { |
| throw new RuntimeException("Can't connect to localhost:" + serverSocket.getLocalPort(), e); |
| } |
| } |
| } |
| |
| // test infrastructure |
| |
| void check(Handler handler, |
| Level expectedLevel, |
| String expectedEncoding, |
| Class<? extends Filter> expectedFilterType, |
| Class<? extends Formatter> expectedFormatterType) { |
| checkEquals(handler, "level", handler.getLevel(), expectedLevel); |
| checkEquals(handler, "encoding", handler.getEncoding(), expectedEncoding); |
| checkType(handler, "filter", handler.getFilter(), expectedFilterType); |
| checkType(handler, "formatter", handler.getFormatter(), expectedFormatterType); |
| } |
| |
| void check(MemoryHandler handler, |
| Level expectedLevel, |
| String expectedEncoding, |
| Class<? extends Filter> expectedFilterType, |
| Class<? extends Formatter> expectedFormatterType, |
| Class<? extends Handler> expextedTargetType, |
| int expextedSize, |
| Level expectedPushLevel) { |
| checkType(handler, "target", getTarget(handler), expextedTargetType); |
| checkEquals(handler, "size", getSize(handler), expextedSize); |
| checkEquals(handler, "pushLevel", handler.getPushLevel(), expectedPushLevel); |
| check(handler, expectedLevel, expectedEncoding, expectedFilterType, expectedFormatterType); |
| } |
| |
| void check(StreamHandler handler, |
| Level expectedLevel, |
| String expectedEncoding, |
| Class<? extends Filter> expectedFilterType, |
| Class<? extends Formatter> expectedFormatterType, |
| OutputStream expectedOutputStream) { |
| checkEquals(handler, "outputStream", getOutput(handler), expectedOutputStream); |
| check(handler, expectedLevel, expectedEncoding, expectedFilterType, expectedFormatterType); |
| } |
| |
| <T> void checkEquals(Handler handler, String property, T value, T expectedValue) { |
| if (!Objects.equals(value, expectedValue)) { |
| fail(handler, property + ": " + value + ", expected " + property + ": " + expectedValue); |
| } |
| } |
| |
| <T> void checkType(Handler handler, String property, T value, Class<? extends T> expectedType) { |
| if (!(expectedType == null && value == null || expectedType != null && expectedType.isInstance(value))) { |
| Class<?> type = value == null ? null : value.getClass(); |
| fail(handler, property + " type: " + type + ", expected " + property + " type: " + expectedType); |
| } |
| } |
| |
| void fail(Handler handler, String message) { |
| throw new AssertionError("Handler: " + handler.getClass().getName() + |
| ", configured with: " + getClass().getName() + |
| ", " + message); |
| } |
| |
| Handler getTarget(MemoryHandler memoryHandler) { |
| try { |
| return (Handler) memoryHandlerTarget.get(memoryHandler); |
| } catch (IllegalAccessException e) { |
| throw new IllegalAccessError(e.getMessage()); |
| } |
| } |
| |
| int getSize(MemoryHandler memoryHandler) { |
| try { |
| return (int) memoryHandlerSize.get(memoryHandler); |
| } catch (IllegalAccessException e) { |
| throw new IllegalAccessError(e.getMessage()); |
| } |
| } |
| |
| OutputStream getOutput(StreamHandler streamHandler) { |
| try { |
| return (OutputStream) streamHandlerOutput.get(streamHandler); |
| } catch (IllegalAccessException e) { |
| throw new IllegalAccessError(e.getMessage()); |
| } |
| } |
| |
| // various independent types of Formatters, Filters, Handlers... |
| |
| public static class SpecifiedFormatter extends Formatter { |
| @Override |
| public String format(LogRecord record) { |
| return String.valueOf(record); |
| } |
| } |
| |
| public static class SpecifiedHandler extends Handler { |
| @Override |
| public void publish(LogRecord record) { } |
| |
| @Override |
| public void flush() { } |
| |
| @Override |
| public void close() throws SecurityException { } |
| } |
| |
| public static class ConfiguredFormatter extends Formatter { |
| @Override |
| public String format(LogRecord record) { |
| return String.valueOf(record); |
| } |
| } |
| |
| public static class ConfiguredFilter implements Filter { |
| @Override |
| public boolean isLoggable(LogRecord record) { |
| return true; |
| } |
| } |
| |
| public static class ConfiguredHandler extends Handler { |
| @Override |
| public void publish(LogRecord record) { } |
| |
| @Override |
| public void flush() { } |
| |
| @Override |
| public void close() throws SecurityException { } |
| } |
| } |