1 /*
   2  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug 7159567
  27  * @summary Test of configuring a MemoryHandler sub-class handler target via logging.properties
  28  * @run main/othervm MemoryHandlerTest
  29  */
  30 import java.io.File;
  31 import java.io.IOException;
  32 import java.util.logging.Handler;
  33 import java.util.logging.Level;
  34 import java.util.logging.LogManager;
  35 import java.util.logging.LogRecord;
  36 import java.util.logging.Logger;
  37 import java.util.logging.MemoryHandler;
  38 
  39 public class MemoryHandlerTest {
  40 
  41     static final String CFG_FILE_PROP = "java.util.logging.config.file";
  42     static final String LM_PROP_FNAME = "MemoryHandlerTest.props";
  43     static Logger logger;
  44 
  45     public static void main(String... args) throws IOException {
  46         // load logging.propertes for the test
  47         String tstSrc = System.getProperty("test.src", ".");
  48         File fname = new File(tstSrc, LM_PROP_FNAME);
  49         String prop = fname.getCanonicalPath();
  50         System.setProperty(CFG_FILE_PROP, prop);
  51         LogManager.getLogManager();
  52         // create a logger
  53         logger = Logger.getLogger(MemoryHandlerTest.class.getName());
  54         // don't have parent handlers get log messages
  55         logger.setUseParentHandlers(false);
  56         //
  57         // Test 1,2: create a CustomMemoryHandler which in the config has
  58         // specified a target of CustomTargetHandler.  (1) Make sure that it
  59         // is created and (2) that the target handler is loaded.
  60         //
  61         CustomMemoryHandler cmh = new CustomMemoryHandler();
  62         try {
  63             logger.addHandler(cmh);
  64         } catch (RuntimeException rte) {
  65             throw new RuntimeException(
  66                 "Test Failed: did not load java.util.logging.ConsoleHandler as expected",
  67                 rte);
  68         }
  69         // if we get here and our config has been processed properly, then we
  70         // should have loaded our target handler
  71         if (CustomTargetHandler.numLoaded !=1) {
  72             throw new RuntimeException(
  73                 "Test failed: did not load CustomTargetHandler as expected");
  74         }
  75         //
  76         // Test 3: try to add a handler with no target.  This should fail with
  77         // an exception
  78         CustomMemoryHandlerNoTarget cmhnt = null;
  79         try {
  80             cmhnt = new CustomMemoryHandlerNoTarget();
  81         } catch (RuntimeException re) {
  82             // expected -- no target specified
  83             System.out.println("Info: " + re.getMessage() + " as expected.");
  84         }
  85         if (cmhnt != null) {
  86             throw new RuntimeException(
  87                 "Test Failed: erroneously loaded CustomMemoryHandlerNoTarget");
  88         }
  89 
  90         // Test 4: log a message and check that the target handler is actually used
  91         logger.log(Level.WARNING, "Unused");
  92         if (CustomTargetHandler.numPublished != 1) {
  93             throw new RuntimeException("Test failed: CustomTargetHandler was not used");
  94         }
  95 
  96         // Test 5: make sure that SimpleTargetHandler hasn't been erroneously called
  97         if (SimpleTargetHandler.numPublished != 0) {
  98             throw new RuntimeException("Test failed: SimpleTargetHandler has been used");
  99         }
 100 
 101         // Test 6: try using SimpleTargetHanlder via standard MemoryHandler
 102         // (which has target set to SimpleTargetHandler)
 103         MemoryHandler mh = new MemoryHandler();
 104         mh.publish(new LogRecord(Level.INFO, "Unused msg to MemoryHandler"));
 105         // see if it made it to the SimpleTargetHandler
 106         if (SimpleTargetHandler.numPublished != 1) {
 107             throw new RuntimeException("Test failed: SimpleTargetHandler was not used");
 108         }
 109     }
 110 
 111     public static class CustomMemoryHandler extends MemoryHandler {
 112     }
 113 
 114     public static class CustomMemoryHandlerNoTarget extends MemoryHandler {
 115     }
 116 
 117     public static class CustomTargetHandler extends Handler {
 118 
 119         public static int numPublished;
 120         public static int numLoaded;
 121 
 122         public CustomTargetHandler() {
 123             numLoaded++;
 124         }
 125 
 126         @Override
 127         public void publish(LogRecord unused) {
 128             numPublished++;
 129         }
 130 
 131         @Override
 132         public void flush() {
 133         }
 134 
 135         @Override
 136         public void close() throws SecurityException {
 137         }
 138     }
 139 
 140     public static class SimpleTargetHandler extends Handler {
 141         public static int numPublished;
 142 
 143         @Override
 144         public void publish(LogRecord unused) {
 145             numPublished++;
 146         }
 147 
 148         @Override
 149         public void flush() {
 150         }
 151 
 152         @Override
 153         public void close() throws SecurityException {
 154         }
 155     }
 156 }