| /* |
| * Copyright (c) 2015, 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.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.time.ZoneId; |
| import java.util.Base64; |
| import java.util.Locale; |
| import java.util.TimeZone; |
| import java.util.logging.Level; |
| import java.util.logging.LogRecord; |
| import java.util.logging.SimpleFormatter; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.stream.Stream; |
| |
| /** |
| * @test |
| * @bug 8072645 |
| * @summary tests the compatibility of LogRecord serial form between |
| * JDK 8 and JDK 9. Ideally this test should be run on both platforms. |
| * (It is designed to run on both). |
| * @run main/othervm SerializeLogRecord |
| * @author danielfuchs |
| */ |
| public class SerializeLogRecord { |
| |
| /** |
| * Serializes a log record, encode the serialized bytes in base 64, and |
| * prints pseudo java code that can be cut and pasted into this test. |
| * @param record the log record to serialize, encode in base 64, and for |
| * which test data will be generated. |
| * @return A string containing the generated pseudo java code. |
| * @throws IOException Unexpected. |
| * @throws ClassNotFoundException Unexpected. |
| */ |
| public static String generate(LogRecord record) throws IOException, ClassNotFoundException { |
| |
| // Format the given logRecord using the SimpleFormatter |
| SimpleFormatter formatter = new SimpleFormatter(); |
| String str = formatter.format(record); |
| |
| // Serialize the given LogRecord |
| final ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| final ObjectOutputStream oos = new ObjectOutputStream(baos); |
| oos.writeObject(record); |
| oos.flush(); |
| oos.close(); |
| |
| // Now we're going to perform a number of smoke tests before |
| // generating the Java pseudo code. |
| // |
| // First checks that the log record can be deserialized |
| final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| final ObjectInputStream ois = new ObjectInputStream(bais); |
| final LogRecord record2 = (LogRecord)ois.readObject(); |
| |
| // Format the deserialized LogRecord using the SimpleFormatter, and |
| // check that the string representation obtained matches the string |
| // representation of the original LogRecord |
| String str2 = formatter.format(record2); |
| if (!str.equals(str2)) throw new RuntimeException("Unexpected values in deserialized object:" |
| + "\n\tExpected: " + str |
| + "\n\tRetrieved: "+str); |
| |
| // Now get a Base64 string representation of the serialized bytes. |
| final String base64 = Base64.getEncoder().encodeToString(baos.toByteArray()); |
| |
| // Check that we can deserialize a log record from the Base64 string |
| // representation we just computed. |
| final ByteArrayInputStream bais2 = new ByteArrayInputStream(Base64.getDecoder().decode(base64)); |
| final ObjectInputStream ois2 = new ObjectInputStream(bais2); |
| final LogRecord record3 = (LogRecord)ois2.readObject(); |
| |
| // Format the new deserialized LogRecord using the SimpleFormatter, and |
| // check that the string representation obtained matches the string |
| // representation of the original LogRecord |
| String str3 = formatter.format(record3); |
| if (!str.equals(str3)) throw new RuntimeException("Unexpected values in deserialized object:" |
| + "\n\tExpected: " + str |
| + "\n\tRetrieved: "+str); |
| //System.out.println(base64); |
| //System.out.println(); |
| |
| // Generates the Java Pseudo code that can be cut & pasted into |
| // this test (see Jdk8SerializedLog and Jdk9SerializedLog below) |
| final StringBuilder sb = new StringBuilder(); |
| sb.append(" /**").append('\n'); |
| sb.append(" * Base64 encoded string for LogRecord object.").append('\n'); |
| sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n'); |
| sb.append(" **/").append('\n'); |
| sb.append(" final String base64 = ").append("\n "); |
| final int last = base64.length() - 1; |
| for (int i=0; i<base64.length();i++) { |
| if (i%64 == 0) sb.append("\""); |
| sb.append(base64.charAt(i)); |
| if (i%64 == 63 || i == last) { |
| sb.append("\""); |
| if (i == last) sb.append(";\n"); |
| else sb.append("\n + "); |
| } |
| } |
| sb.append('\n'); |
| sb.append(" /**").append('\n'); |
| sb.append(" * SimpleFormatter output for LogRecord object.").append('\n'); |
| sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n'); |
| sb.append(" **/").append('\n'); |
| sb.append(" final String str = ").append("\n "); |
| sb.append("\"").append(str.replace("\n", "\\n")).append("\";\n"); |
| return sb.toString(); |
| } |
| |
| /** |
| * An abstract class to test that a log record previously serialized on a |
| * different java version can be deserialized in the current java version. |
| * (see Jdk8SerializedLog and Jdk9SerializedLog below) |
| */ |
| public abstract static class SerializedLog { |
| public abstract String getBase64(); |
| public abstract String getString(); |
| |
| /** |
| * Deserializes the Base64 encoded string returned by {@link |
| * #getBase64()}, format the obtained LogRecord using a |
| * SimpleFormatter, and checks that the string representation obtained |
| * matches the original string representation returned by {@link |
| * #getString()}. |
| */ |
| protected void dotest() { |
| try { |
| final String base64 = getBase64(); |
| final ByteArrayInputStream bais = |
| new ByteArrayInputStream(Base64.getDecoder().decode(base64)); |
| final ObjectInputStream ois = new ObjectInputStream(bais); |
| final LogRecord record = (LogRecord)ois.readObject(); |
| final SimpleFormatter formatter = new SimpleFormatter(); |
| String expected = getString(); |
| String str2 = formatter.format(record); |
| check(expected, str2); |
| System.out.println(str2); |
| System.out.println("PASSED: "+this.getClass().getName()+"\n"); |
| } catch (IOException | ClassNotFoundException x) { |
| throw new RuntimeException(x); |
| } |
| } |
| /** |
| * Check that the actual String representation obtained matches the |
| * expected String representation. |
| * @param expected Expected String representation, as returned by |
| * {@link #getString()}. |
| * @param actual Actual String representation obtained by formatting |
| * the LogRecord obtained by the deserialization of the |
| * bytes encoded in {@link #getBase64()}. |
| */ |
| protected void check(String expected, String actual) { |
| if (!expected.equals(actual)) { |
| throw new RuntimeException(this.getClass().getName() |
| + " - Unexpected values in deserialized object:" |
| + "\n\tExpected: " + expected |
| + "\n\tRetrieved: "+ actual); |
| } |
| } |
| } |
| |
| public static class Jdk8SerializedLog extends SerializedLog { |
| |
| // Generated by generate() on JDK 8. |
| // -------------------------------- |
| // BEGIN |
| |
| /** |
| * Base64 encoded string for LogRecord object. |
| * Java version: 1.8.0_11 |
| **/ |
| final String base64 = |
| "rO0ABXNyABtqYXZhLnV0aWwubG9nZ2luZy5Mb2dSZWNvcmRKjVk982lRlgMACkoA" |
| + "Bm1pbGxpc0oADnNlcXVlbmNlTnVtYmVySQAIdGhyZWFkSURMAAVsZXZlbHQAGUxq" |
| + "YXZhL3V0aWwvbG9nZ2luZy9MZXZlbDtMAApsb2dnZXJOYW1ldAASTGphdmEvbGFu" |
| + "Zy9TdHJpbmc7TAAHbWVzc2FnZXEAfgACTAAScmVzb3VyY2VCdW5kbGVOYW1lcQB+" |
| + "AAJMAA9zb3VyY2VDbGFzc05hbWVxAH4AAkwAEHNvdXJjZU1ldGhvZE5hbWVxAH4A" |
| + "AkwABnRocm93bnQAFUxqYXZhL2xhbmcvVGhyb3dhYmxlO3hwAAABSjUCgo0AAAAA" |
| + "AAAAAAAAAAFzcgAXamF2YS51dGlsLmxvZ2dpbmcuTGV2ZWyOiHETUXM2kgIAA0kA" |
| + "BXZhbHVlTAAEbmFtZXEAfgACTAAScmVzb3VyY2VCdW5kbGVOYW1lcQB+AAJ4cAAA" |
| + "AyB0AARJTkZPdAAic3VuLnV0aWwubG9nZ2luZy5yZXNvdXJjZXMubG9nZ2luZ3QA" |
| + "BHRlc3R0ABFKYXZhIFZlcnNpb246IHswfXBwcHB3BgEAAAAAAXQACDEuOC4wXzEx" |
| + "eA=="; |
| |
| /** |
| * SimpleFormatter output for LogRecord object. |
| * Java version: 1.8.0_11 |
| **/ |
| final String str = |
| "Dec 10, 2014 4:22:44.621000000 PM test - INFO: Java Version: 1.8.0_11"; |
| // ^^^ |
| // Notice the milli second resolution above... |
| |
| // END |
| // -------------------------------- |
| |
| @Override |
| public String getBase64() { |
| return base64; |
| } |
| |
| @Override |
| public String getString() { |
| return str; |
| } |
| |
| public static void test() { |
| new Jdk8SerializedLog().dotest(); |
| } |
| } |
| |
| public static class Jdk9SerializedLog extends SerializedLog { |
| |
| // Generated by generate() on JDK 9. |
| // -------------------------------- |
| // BEGIN |
| |
| /** |
| * Base64 encoded string for LogRecord object. |
| * Java version: 1.9.0-internal |
| **/ |
| final String base64 = |
| "rO0ABXNyABtqYXZhLnV0aWwubG9nZ2luZy5Mb2dSZWNvcmRKjVk982lRlgMAC0oA" |
| + "Bm1pbGxpc0kADm5hbm9BZGp1c3RtZW50SgAOc2VxdWVuY2VOdW1iZXJJAAh0aHJl" |
| + "YWRJREwABWxldmVsdAAZTGphdmEvdXRpbC9sb2dnaW5nL0xldmVsO0wACmxvZ2dl" |
| + "ck5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztMAAdtZXNzYWdlcQB+AAJMABJyZXNv" |
| + "dXJjZUJ1bmRsZU5hbWVxAH4AAkwAD3NvdXJjZUNsYXNzTmFtZXEAfgACTAAQc291" |
| + "cmNlTWV0aG9kTmFtZXEAfgACTAAGdGhyb3dudAAVTGphdmEvbGFuZy9UaHJvd2Fi" |
| + "bGU7eHAAAAFLl3u6OAAOU/gAAAAAAAAAAAAAAAFzcgAXamF2YS51dGlsLmxvZ2dp" |
| + "bmcuTGV2ZWyOiHETUXM2kgIAA0kABXZhbHVlTAAEbmFtZXEAfgACTAAScmVzb3Vy" |
| + "Y2VCdW5kbGVOYW1lcQB+AAJ4cAAAAyB0AARJTkZPdAAic3VuLnV0aWwubG9nZ2lu" |
| + "Zy5yZXNvdXJjZXMubG9nZ2luZ3QABHRlc3R0ABFKYXZhIFZlcnNpb246IHswfXBw" |
| + "cHB3BgEAAAAAAXQADjEuOS4wLWludGVybmFseA=="; |
| |
| /** |
| * SimpleFormatter output for LogRecord object. |
| * Java version: 1.9.0-internal |
| **/ |
| final String str = |
| "Feb 17, 2015 12:20:43.192939000 PM test - INFO: Java Version: 1.9.0-internal"; |
| // ^^^ |
| // Notice the micro second resolution above... |
| |
| // END |
| // -------------------------------- |
| |
| @Override |
| public String getBase64() { |
| return base64; |
| } |
| |
| @Override |
| public String getString() { |
| return str; |
| } |
| |
| @Override |
| protected void check(String expected, String actual) { |
| if (System.getProperty("java.version").startsWith("1.8")) { |
| // If we are in JDK 8 and print a log record serialized in JDK 9, |
| // then we won't be able to print anything below the millisecond |
| // precision, since that hasn't been implemented in JDK 8. |
| // Therefore - we need to replace anything below millseconds by |
| // zeroes in the expected string (which was generated on JDK 9). |
| Pattern pattern = Pattern.compile("^" |
| + "(.*\\.[0-9][0-9][0-9])" // group1: everything up to milliseconds |
| + "([0-9][0-9][0-9][0-9][0-9][0-9])" // group 2: micros and nanos |
| + "(.* - .*)$"); // group three: all the rest... |
| Matcher matcher = pattern.matcher(expected); |
| if (matcher.matches()) { |
| expected = matcher.group(1) + "000000" + matcher.group(3); |
| } |
| } |
| super.check(expected, actual); |
| } |
| |
| public static void test() { |
| new Jdk9SerializedLog().dotest(); |
| } |
| } |
| |
| public static void generate() { |
| try { |
| LogRecord record = new LogRecord(Level.INFO, "Java Version: {0}"); |
| record.setLoggerName("test"); |
| record.setParameters(new Object[] {System.getProperty("java.version")}); |
| System.out.println(generate(record)); |
| } catch (IOException | ClassNotFoundException x) { |
| throw new RuntimeException(x); |
| } |
| } |
| |
| static enum TestCase { GENERATE, TESTJDK8, TESTJDK9 }; |
| |
| public static void main(String[] args) { |
| // Set the locale and time zone to make sure we won't depend on the |
| // test env - in particular we don't want to depend on the |
| // time zone in which the test machine might be located. |
| // So we're gong to use Locale English and Time Zone UTC for this test. |
| // (Maybe that should be Locale.ROOT?) |
| Locale.setDefault(Locale.ENGLISH); |
| TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.of("UTC"))); |
| |
| // Set the format property to make sure we always have the nanos, and |
| // to make sure it's the same format than what we used when |
| // computing the formatted string for Jdk8SerializedLog and |
| // Jdk9SerializedLog above. |
| // |
| // If you change the formatting, then you will need to regenerate |
| // the data for Jdk8SerializedLog and Jdk9SerializedLog. |
| // |
| // To do that - just run this test on JDK 8, and cut & paste the |
| // pseudo code printed by generate() into Jdk8SerializedLog. |
| // Then run this test again on JDK 9, and cut & paste the |
| // pseudo code printed by generate() into Jdk9SerializedLog. |
| // [Note: you can pass GENERATE as single arg to main() to avoid |
| // running the actual test] |
| // Finally run the test again to check that it still passes after |
| // your modifications. |
| // |
| System.setProperty("java.util.logging.SimpleFormatter.format", |
| "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS.%1$tN %1$Tp %2$s - %4$s: %5$s%6$s"); |
| |
| // If no args, then run everything.... |
| if (args == null || args.length == 0) { |
| args = new String[] { "GENERATE", "TESTJDK8", "TESTJDK9" }; |
| } |
| |
| // Run the specified test case(s) |
| Stream.of(args).map(x -> TestCase.valueOf(x)).forEach((x) -> { |
| switch(x) { |
| case GENERATE: generate(); break; |
| case TESTJDK8: Jdk8SerializedLog.test(); break; |
| case TESTJDK9: Jdk9SerializedLog.test(); break; |
| } |
| }); |
| } |
| } |
