| /* |
| * 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. |
| */ |
| import java.util.Arrays; |
| import java.util.Locale; |
| import java.util.Objects; |
| import java.util.ResourceBundle; |
| import java.util.logging.Handler; |
| import java.util.logging.Level; |
| import java.util.logging.LogRecord; |
| import java.util.logging.Logger; |
| import resources.ListBundle; |
| |
| /** |
| * @test |
| * @bug 8013839 |
| * @summary tests Logger.logrb(..., ResourceBundle); |
| * @build TestLogrbResourceBundle resources.ListBundle resources.ListBundle_fr |
| * @run main TestLogrbResourceBundle |
| * @author danielfuchs |
| */ |
| public class TestLogrbResourceBundle { |
| |
| static final String LIST_BUNDLE_NAME = "resources.ListBundle"; |
| static final String PROPERTY_BUNDLE_NAME = "resources.PropertyBundle"; |
| |
| /** |
| * A dummy handler class that we can use to check the bundle/bundle name |
| * that was present in the last LogRecord instance published. |
| */ |
| static final class TestHandler extends Handler { |
| ResourceBundle lastBundle = null; |
| String lastBundleName = null; |
| Object[] lastParams = null; |
| Throwable lastThrown = null; |
| String lastMessage = null; |
| @Override |
| public void publish(LogRecord record) { |
| lastBundle = record.getResourceBundle(); |
| lastBundleName = record.getResourceBundleName(); |
| lastParams = record.getParameters(); |
| lastThrown = record.getThrown(); |
| lastMessage = record.getMessage(); |
| } |
| |
| @Override |
| public void flush() { |
| } |
| |
| @Override |
| public void close() throws SecurityException { |
| } |
| } |
| |
| /** |
| * We're going to do the same test with each of the different new logrb |
| * forms. |
| * <ul> |
| * <li> LOGRB_NO_ARGS: calling logrb with no message argument. |
| * <li> LOGRB_SINGLE_ARG: calling logrb with a single message argument. |
| * <li> LOGRB_ARG_ARRAY: calling logrb with an array of message arguments. |
| * <li> LOGRB_VARARGS: calling logrb with a variable list of message arguments. |
| * <li> LOGRB_THROWABLE: calling logrb with an exception. |
| * </ul> |
| */ |
| private static enum TestCase { |
| LOGRB_NO_ARGS, LOGRB_SINGLE_ARG, LOGRB_ARG_ARRAY, LOGRB_VARARGS, LOGRB_THROWABLE; |
| |
| public void logrb(Logger logger, ResourceBundle bundle) { |
| switch(this) { |
| case LOGRB_NO_ARGS: |
| logger.logrb(Level.CONFIG, |
| TestLogrbResourceBundle.class.getName(), |
| "main", bundle, "dummy"); |
| break; |
| case LOGRB_SINGLE_ARG: |
| logger.logrb(Level.CONFIG, |
| TestLogrbResourceBundle.class.getName(), |
| "main", bundle, "dummy", "bar"); |
| break; |
| case LOGRB_ARG_ARRAY: |
| logger.logrb(Level.CONFIG, |
| TestLogrbResourceBundle.class.getName(), |
| "main", bundle, "dummy", |
| new Object[] { "bar", "baz"} ); |
| break; |
| case LOGRB_VARARGS: |
| logger.logrb(Level.CONFIG, |
| TestLogrbResourceBundle.class.getName(), |
| "main", bundle, "dummy", |
| "bar", "baz" ); |
| break; |
| case LOGRB_THROWABLE: |
| logger.logrb(Level.CONFIG, |
| TestLogrbResourceBundle.class.getName(), |
| "main", bundle, "dummy", |
| new Exception("dummy exception") ); |
| break; |
| default: |
| } |
| } |
| |
| /** |
| * Checks that the last published logged record had the expected data. |
| * @param handler the TestHandler through which the record was published. |
| */ |
| public void checkLogged(TestHandler handler) { |
| checkLogged(handler.lastMessage, handler.lastParams, handler.lastThrown); |
| } |
| |
| private void checkLogged(String message, Object[] parameters, Throwable thrown) { |
| switch(this) { |
| case LOGRB_NO_ARGS: |
| if ("dummy".equals(message) && thrown == null |
| && (parameters == null || parameters.length == 0)) { |
| return; // OK: all was as expected. |
| } |
| break; |
| case LOGRB_SINGLE_ARG: |
| if ("dummy".equals(message) && thrown == null |
| && parameters != null |
| && parameters.length == 1 |
| && "bar".equals(parameters[0])) { |
| return; // OK: all was as expected. |
| } |
| break; |
| case LOGRB_VARARGS: |
| case LOGRB_ARG_ARRAY: |
| if ("dummy".equals(message) && thrown == null |
| && parameters != null |
| && parameters.length > 1 |
| && Arrays.deepEquals(new Object[] { "bar", "baz"}, |
| parameters)) { |
| return; // OK: all was as expected. |
| } |
| break; |
| case LOGRB_THROWABLE: |
| if ("dummy".equals(message) && thrown != null |
| && thrown.getClass() == Exception.class |
| && "dummy exception".equals(thrown.getMessage())) { |
| return; // OK: all was as expected. |
| } |
| break; |
| default: |
| } |
| |
| // We had some unexpected stuff: throw exception. |
| throw new RuntimeException(this + ": " |
| + "Unexpected content in last published log record: " |
| + "\n\tmessage=\"" + message + "\"" |
| + "\n\tparameters=" + Arrays.toString(parameters) |
| + "\n\tthrown=" + thrown); |
| } |
| } |
| |
| static String getBaseName(ResourceBundle bundle) { |
| return bundle == null ? null : bundle.getBaseBundleName(); |
| } |
| |
| public static void main(String... args) throws Exception { |
| |
| Locale defaultLocale = Locale.getDefault(); |
| |
| final ResourceBundle bundle = ResourceBundle.getBundle(LIST_BUNDLE_NAME); |
| final ResourceBundle bundle_fr = |
| ResourceBundle.getBundle(LIST_BUNDLE_NAME, Locale.FRENCH); |
| final ResourceBundle propertyBundle = ResourceBundle.getBundle(PROPERTY_BUNDLE_NAME); |
| final ResourceBundle propertyBundle_fr = |
| ResourceBundle.getBundle(PROPERTY_BUNDLE_NAME, Locale.FRENCH); |
| Logger foobar = Logger.getLogger("foo.bar"); |
| final TestHandler handler = new TestHandler(); |
| foobar.addHandler(handler); |
| foobar.setLevel(Level.CONFIG); |
| |
| final ResourceBundle anonBundle = new ListBundle(); |
| try { |
| // First we're going to call logrb on a logger that |
| // has no bundle set... |
| |
| // For each possible logrb form... |
| for (TestCase test : TestCase.values()) { |
| // For various resource bundles |
| for (ResourceBundle b : new ResourceBundle[] { |
| anonBundle, bundle, bundle_fr, propertyBundle, |
| anonBundle, null, propertyBundle_fr, |
| }) { |
| // Prints the resource bundle base name (can be null, |
| // we don't enforce non-null names in logrb. |
| final String baseName = getBaseName(b); |
| System.out.println("Testing " + test + " with " + baseName); |
| |
| // log in the 'foobar' logger using bundle 'b' |
| test.logrb(foobar, b); |
| |
| // check that the correct bundle was set in the published |
| // LogRecord |
| if (handler.lastBundle != b) { |
| throw new RuntimeException("Unexpected bundle: " |
| + handler.lastBundle); |
| } |
| |
| // check that the correct bundle name was set in the published |
| // LogRecord |
| if (!Objects.equals(handler.lastBundleName, baseName)) { |
| throw new RuntimeException("Unexpected bundle name: " |
| + handler.lastBundleName); |
| } |
| |
| // check that calling foobar.logrb() had no side effect on |
| // the bundle used by foobar. foobar should still have no |
| // bundle set. |
| if (foobar.getResourceBundle() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobar.getResourceBundle()); |
| } |
| if (foobar.getResourceBundleName() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobar.getResourceBundleName()); |
| } |
| |
| // Test that the last published log record had all the |
| // data that this test case had logged (message, parameters, |
| // thrown... |
| test.checkLogged(handler); |
| } |
| } |
| |
| // No we're going to set a resource bundle on the foobar logger |
| // and do it all again... |
| |
| // For the same bundle in two different locales |
| for (ResourceBundle propBundle : new ResourceBundle[] { |
| propertyBundle, propertyBundle_fr, |
| }) { |
| |
| // set the bundle on foobar... |
| foobar.setResourceBundle(propBundle); |
| |
| // check the bundle was correctly set... |
| if (!propBundle.equals(foobar.getResourceBundle())) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobar.getResourceBundle()); |
| } |
| if (!Objects.equals(getBaseName(propBundle), foobar.getResourceBundleName())) { |
| throw new RuntimeException("Unexpected bundle name: " |
| + foobar.getResourceBundleName()); |
| } |
| |
| System.out.println("Configuring " + foobar.getName() + " with " |
| + propBundle); |
| |
| // for each possible logrb form... |
| for (TestCase test : TestCase.values()) { |
| |
| // for various resource bundles |
| for (ResourceBundle b : new ResourceBundle[] { |
| anonBundle, bundle, null, bundle_fr, propertyBundle, |
| anonBundle, propertyBundle_fr, |
| }) { |
| |
| final String baseName = getBaseName(b); |
| System.out.println("Testing " + test + " with " + baseName); |
| |
| // call foobar.logrb |
| test.logrb(foobar, b); |
| |
| // check which resource bundle was used (should be |
| // the one passed to logrb) |
| if (handler.lastBundle != b) { |
| throw new RuntimeException("Unexpected bundle: " |
| + handler.lastBundle); |
| } |
| if (!Objects.equals(handler.lastBundleName, baseName)) { |
| throw new RuntimeException("Unexpected bundle name: " |
| + handler.lastBundleName); |
| } |
| |
| // Verify there was no side effect on the bundle that |
| // had been previously set on the logger... |
| if (foobar.getResourceBundle() != propBundle) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobar.getResourceBundle()); |
| } |
| if (!Objects.equals(getBaseName(propBundle), |
| foobar.getResourceBundleName())) { |
| throw new RuntimeException("Unexpected bundle name: " |
| + foobar.getResourceBundleName()); |
| } |
| |
| // Checked that the published LogRecord had the |
| // expected content logged by this test case. |
| test.checkLogged(handler); |
| } |
| } |
| } |
| |
| // Now we're going to the same thing, but with a logger which |
| // has an inherited resource bundle. |
| Logger foobaz = Logger.getLogger("foo.bar.baz"); |
| |
| // check that foobaz has no bundle set locally. |
| if (foobaz.getResourceBundle() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobaz.getResourceBundle()); |
| } |
| if (foobaz.getResourceBundleName() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobaz.getResourceBundle()); |
| } |
| |
| // The current locale should have no effect on logrb. |
| Locale.setDefault(Locale.GERMAN); // shouldn't change anything... |
| |
| // for each possible logrb form |
| for (TestCase test : TestCase.values()) { |
| |
| // for various resource bundle |
| for (ResourceBundle b : new ResourceBundle[] { |
| anonBundle, bundle, bundle_fr, propertyBundle, null, |
| anonBundle, propertyBundle_fr, |
| }) { |
| final String baseName = getBaseName(b); |
| System.out.println("Testing " + test + " with " |
| + foobaz.getName() + " and " |
| + baseName); |
| |
| // call foobaz.logrb with the bundle |
| test.logrb(foobaz, b); |
| |
| // check that the bundle passed to logrb was used. |
| if (handler.lastBundle != b) { |
| throw new RuntimeException("Unexpected bundle: " |
| + handler.lastBundle); |
| } |
| if (!Objects.equals(handler.lastBundleName, baseName)) { |
| throw new RuntimeException("Unexpected bundle name: " |
| + handler.lastBundleName); |
| } |
| |
| // check that there was no effect on the bundle set |
| // on foobaz: it should still be null. |
| if (foobaz.getResourceBundle() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobaz.getResourceBundle()); |
| } |
| if (foobaz.getResourceBundleName() != null) { |
| throw new RuntimeException("Unexpected bundle: " |
| + foobaz.getResourceBundleName()); |
| } |
| |
| // check that the last published log record had all the |
| // data that was logged by this testcase. |
| test.checkLogged(handler); |
| } |
| } |
| |
| } finally { |
| Locale.setDefault(defaultLocale); |
| } |
| |
| } |
| } |
