1 /*
2 * Copyright (c) 2015, 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 import java.io.ByteArrayInputStream;
24 import java.io.ByteArrayOutputStream;
25 import java.io.IOException;
26 import java.io.ObjectInputStream;
27 import java.io.ObjectOutputStream;
28 import java.time.ZoneId;
29 import java.util.Base64;
30 import java.util.Locale;
31 import java.util.TimeZone;
32 import java.util.logging.Level;
33 import java.util.logging.LogRecord;
34 import java.util.logging.SimpleFormatter;
35 import java.util.regex.Matcher;
36 import java.util.regex.Pattern;
37 import java.util.stream.Stream;
38
39 /**
40 * @test
41 * @bug 8072645
42 * @summary tests the compatibility of LogRecord serial form between
43 * JDK 8 and JDK 9. Ideally this test should be run on both platforms.
44 * (It is designed to run on both).
45 * @run main/othervm SerializeLogRecord
46 * @author danielfuchs
47 */
48 public class SerializeLogRecord {
49
50 /**
51 * Serializes a log record, encode the serialized bytes in base 64, and
52 * prints pseudo java code that can be cut and pasted into this test.
53 * @param record the log record to serialize, encode in base 64, and for
54 * which test data will be generated.
55 * @return A string containing the generated pseudo java code.
56 * @throws IOException Unexpected.
57 * @throws ClassNotFoundException Unexpected.
58 */
59 public static String generate(LogRecord record) throws IOException, ClassNotFoundException {
60
61 // Format the given logRecord using the SimpleFormatter
62 SimpleFormatter formatter = new SimpleFormatter();
63 String str = formatter.format(record);
64
65 // Serialize the given LogRecord
66 final ByteArrayOutputStream baos = new ByteArrayOutputStream();
67 final ObjectOutputStream oos = new ObjectOutputStream(baos);
68 oos.writeObject(record);
69 oos.flush();
70 oos.close();
71
72 // Now we're going to perform a number of smoke tests before
73 // generating the Java pseudo code.
74 //
75 // First checks that the log record can be deserialized
76 final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
77 final ObjectInputStream ois = new ObjectInputStream(bais);
78 final LogRecord record2 = (LogRecord)ois.readObject();
79
80 // Format the deserialized LogRecord using the SimpleFormatter, and
81 // check that the string representation obtained matches the string
82 // representation of the original LogRecord
83 String str2 = formatter.format(record2);
84 if (!str.equals(str2)) throw new RuntimeException("Unexpected values in deserialized object:"
85 + "\n\tExpected: " + str
86 + "\n\tRetrieved: "+str);
87
88 // Now get a Base64 string representation of the serialized bytes.
89 final String base64 = Base64.getEncoder().encodeToString(baos.toByteArray());
90
91 // Check that we can deserialize a log record from the Base64 string
92 // representation we just computed.
93 final ByteArrayInputStream bais2 = new ByteArrayInputStream(Base64.getDecoder().decode(base64));
94 final ObjectInputStream ois2 = new ObjectInputStream(bais2);
95 final LogRecord record3 = (LogRecord)ois2.readObject();
96
97 // Format the new deserialized LogRecord using the SimpleFormatter, and
98 // check that the string representation obtained matches the string
99 // representation of the original LogRecord
100 String str3 = formatter.format(record3);
101 if (!str.equals(str3)) throw new RuntimeException("Unexpected values in deserialized object:"
102 + "\n\tExpected: " + str
103 + "\n\tRetrieved: "+str);
104 //System.out.println(base64);
105 //System.out.println();
106
107 // Generates the Java Pseudo code that can be cut & pasted into
108 // this test (see Jdk8SerializedLog and Jdk9SerializedLog below)
109 final StringBuilder sb = new StringBuilder();
110 sb.append(" /**").append('\n');
111 sb.append(" * Base64 encoded string for LogRecord object.").append('\n');
112 sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n');
113 sb.append(" **/").append('\n');
114 sb.append(" final String base64 = ").append("\n ");
115 final int last = base64.length() - 1;
116 for (int i=0; i<base64.length();i++) {
117 if (i%64 == 0) sb.append("\"");
118 sb.append(base64.charAt(i));
119 if (i%64 == 63 || i == last) {
120 sb.append("\"");
121 if (i == last) sb.append(";\n");
122 else sb.append("\n + ");
123 }
124 }
125 sb.append('\n');
126 sb.append(" /**").append('\n');
127 sb.append(" * SimpleFormatter output for LogRecord object.").append('\n');
128 sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n');
129 sb.append(" **/").append('\n');
130 sb.append(" final String str = ").append("\n ");
131 sb.append("\"").append(str.replace("\n", "\\n")).append("\";\n");
132 return sb.toString();
133 }
134
135 /**
136 * An abstract class to test that a log record previously serialized on a
137 * different java version can be deserialized in the current java version.
138 * (see Jdk8SerializedLog and Jdk9SerializedLog below)
139 */
140 public static abstract class SerializedLog {
141 public abstract String getBase64();
142 public abstract String getString();
143
144 /**
145 * Deserializes the Base64 encoded string returned by {@link
146 * #getBase64()}, format the obtained LogRecord using a
147 * SimpleFormatter, and checks that the string representation obtained
148 * matches the original string representation returned by {@link
149 * #getString()}.
150 */
151 protected void dotest() {
152 try {
153 final String base64 = getBase64();
154 final ByteArrayInputStream bais =
155 new ByteArrayInputStream(Base64.getDecoder().decode(base64));
156 final ObjectInputStream ois = new ObjectInputStream(bais);
157 final LogRecord record = (LogRecord)ois.readObject();
158 final SimpleFormatter formatter = new SimpleFormatter();
159 String expected = getString();
160 String str2 = formatter.format(record);
161 check(expected, str2);
162 System.out.println(str2);
163 System.out.println("PASSED: "+this.getClass().getName()+"\n");
164 } catch (IOException | ClassNotFoundException x) {
165 throw new RuntimeException(x);
166 }
167 }
168 /**
169 * Check that the actual String representation obtained matches the
170 * expected String representation.
171 * @param expected Expected String representation, as returned by
172 * {@link #getString()}.
173 * @param actual Actual String representation obtained by formatting
174 * the LogRecord obtained by the deserialization of the
175 * bytes encoded in {@link #getBase64()}.
176 */
177 protected void check(String expected, String actual) {
178 if (!expected.equals(actual)) {
179 throw new RuntimeException(this.getClass().getName()
180 + " - Unexpected values in deserialized object:"
181 + "\n\tExpected: " + expected
182 + "\n\tRetrieved: "+ actual);
183 }
184 }
185 }
186
187 public static class Jdk8SerializedLog extends SerializedLog {
188
189 // Generated by generate() on JDK 8.
190 // --------------------------------
191 // BEGIN
192
193 /**
194 * Base64 encoded string for LogRecord object.
195 * Java version: 1.8.0_11
196 **/
197 final String base64 =
198 "rO0ABXNyABtqYXZhLnV0aWwubG9nZ2luZy5Mb2dSZWNvcmRKjVk982lRlgMACkoA"
199 + "Bm1pbGxpc0oADnNlcXVlbmNlTnVtYmVySQAIdGhyZWFkSURMAAVsZXZlbHQAGUxq"
200 + "YXZhL3V0aWwvbG9nZ2luZy9MZXZlbDtMAApsb2dnZXJOYW1ldAASTGphdmEvbGFu"
201 + "Zy9TdHJpbmc7TAAHbWVzc2FnZXEAfgACTAAScmVzb3VyY2VCdW5kbGVOYW1lcQB+"
202 + "AAJMAA9zb3VyY2VDbGFzc05hbWVxAH4AAkwAEHNvdXJjZU1ldGhvZE5hbWVxAH4A"
203 + "AkwABnRocm93bnQAFUxqYXZhL2xhbmcvVGhyb3dhYmxlO3hwAAABSjUCgo0AAAAA"
204 + "AAAAAAAAAAFzcgAXamF2YS51dGlsLmxvZ2dpbmcuTGV2ZWyOiHETUXM2kgIAA0kA"
205 + "BXZhbHVlTAAEbmFtZXEAfgACTAAScmVzb3VyY2VCdW5kbGVOYW1lcQB+AAJ4cAAA"
206 + "AyB0AARJTkZPdAAic3VuLnV0aWwubG9nZ2luZy5yZXNvdXJjZXMubG9nZ2luZ3QA"
207 + "BHRlc3R0ABFKYXZhIFZlcnNpb246IHswfXBwcHB3BgEAAAAAAXQACDEuOC4wXzEx"
208 + "eA==";
209
210 /**
211 * SimpleFormatter output for LogRecord object.
212 * Java version: 1.8.0_11
213 **/
214 final String str =
215 "Dec 10, 2014 4:22:44.621000000 PM test - INFO: Java Version: 1.8.0_11";
216 // ^^^
217 // Notice the milli second resolution above...
218
219 // END
220 // --------------------------------
221
222 @Override
223 public String getBase64() {
224 return base64;
225 }
226
227 @Override
228 public String getString() {
229 return str;
230 }
231
232 public static void test() {
233 new Jdk8SerializedLog().dotest();
234 }
235 }
236
237 public static class Jdk9SerializedLog extends SerializedLog {
238
239 // Generated by generate() on JDK 9.
240 // --------------------------------
241 // BEGIN
242
243 /**
244 * Base64 encoded string for LogRecord object.
245 * Java version: 1.9.0-internal
246 **/
247 final String base64 =
248 "rO0ABXNyABtqYXZhLnV0aWwubG9nZ2luZy5Mb2dSZWNvcmRKjVk982lRlgMAC0oA"
249 + "Bm1pbGxpc0kADm5hbm9BZGp1c3RtZW50SgAOc2VxdWVuY2VOdW1iZXJJAAh0aHJl"
250 + "YWRJREwABWxldmVsdAAZTGphdmEvdXRpbC9sb2dnaW5nL0xldmVsO0wACmxvZ2dl"
251 + "ck5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztMAAdtZXNzYWdlcQB+AAJMABJyZXNv"
252 + "dXJjZUJ1bmRsZU5hbWVxAH4AAkwAD3NvdXJjZUNsYXNzTmFtZXEAfgACTAAQc291"
253 + "cmNlTWV0aG9kTmFtZXEAfgACTAAGdGhyb3dudAAVTGphdmEvbGFuZy9UaHJvd2Fi"
254 + "bGU7eHAAAAFLl3u6OAAOU/gAAAAAAAAAAAAAAAFzcgAXamF2YS51dGlsLmxvZ2dp"
255 + "bmcuTGV2ZWyOiHETUXM2kgIAA0kABXZhbHVlTAAEbmFtZXEAfgACTAAScmVzb3Vy"
256 + "Y2VCdW5kbGVOYW1lcQB+AAJ4cAAAAyB0AARJTkZPdAAic3VuLnV0aWwubG9nZ2lu"
257 + "Zy5yZXNvdXJjZXMubG9nZ2luZ3QABHRlc3R0ABFKYXZhIFZlcnNpb246IHswfXBw"
258 + "cHB3BgEAAAAAAXQADjEuOS4wLWludGVybmFseA==";
259
260 /**
261 * SimpleFormatter output for LogRecord object.
262 * Java version: 1.9.0-internal
263 **/
264 final String str =
265 "Feb 17, 2015 12:20:43.192939000 PM test - INFO: Java Version: 1.9.0-internal";
266 // ^^^
267 // Notice the micro second resolution above...
268
269 // END
270 // --------------------------------
271
272 @Override
273 public String getBase64() {
274 return base64;
275 }
276
277 @Override
278 public String getString() {
279 return str;
280 }
281
282 @Override
283 protected void check(String expected, String actual) {
284 if (System.getProperty("java.version").startsWith("1.8")) {
285 // If we are in JDK 8 and print a log record serialized in JDK 9,
286 // then we won't be able to print anything below the millisecond
287 // precision, since that hasn't been implemented in JDK 8.
288 // Therefore - we need to replace anything below millseconds by
289 // zeroes in the expected string (which was generated on JDK 9).
290 Pattern pattern = Pattern.compile("^"
291 + "(.*\\.[0-9][0-9][0-9])" // group1: everything up to milliseconds
292 + "([0-9][0-9][0-9][0-9][0-9][0-9])" // group 2: micros and nanos
293 + "(.* - .*)$"); // group three: all the rest...
294 Matcher matcher = pattern.matcher(expected);
295 if (matcher.matches()) {
296 expected = matcher.group(1) + "000000" + matcher.group(3);
297 }
298 }
299 super.check(expected, actual);
300 }
301
302 public static void test() {
303 new Jdk9SerializedLog().dotest();
304 }
305 }
306
307 public static void generate() {
308 try {
309 LogRecord record = new LogRecord(Level.INFO, "Java Version: {0}");
310 record.setLoggerName("test");
311 record.setParameters(new Object[] {System.getProperty("java.version")});
312 System.out.println(generate(record));
313 } catch (IOException | ClassNotFoundException x) {
314 throw new RuntimeException(x);
315 }
316 }
317
318 static enum TestCase { GENERATE, TESTJDK8, TESTJDK9 };
319
320 public static void main(String[] args) {
321 // Set the locale and time zone to make sure we won't depend on the
322 // test env - in particular we don't want to depend on the
323 // time zone in which the test machine might be located.
324 // So we're gong to use Locale English and Time Zone UTC for this test.
325 // (Maybe that should be Locale.ROOT?)
326 Locale.setDefault(Locale.ENGLISH);
327 TimeZone.setDefault(TimeZone.getTimeZone(ZoneId.of("UTC")));
328
329 // Set the format property to make sure we always have the nanos, and
330 // to make sure it's the same format than what we used when
331 // computing the formatted string for Jdk8SerializedLog and
332 // Jdk9SerializedLog above.
333 //
334 // If you change the formatting, then you will need to regenerate
335 // the data for Jdk8SerializedLog and Jdk9SerializedLog.
336 //
337 // To do that - just run this test on JDK 8, and cut & paste the
338 // pseudo code printed by generate() into Jdk8SerializedLog.
339 // Then run this test again on JDK 9, and cut & paste the
340 // pseudo code printed by generate() into Jdk9SerializedLog.
341 // [Note: you can pass GENERATE as single arg to main() to avoid
342 // running the actual test]
343 // Finally run the test again to check that it still passes after
344 // your modifications.
345 //
346 System.setProperty("java.util.logging.SimpleFormatter.format",
347 "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS.%1$tN %1$Tp %2$s - %4$s: %5$s%6$s");
348
349 // If no args, then run everything....
350 if (args == null || args.length == 0) {
351 args = new String[] { "GENERATE", "TESTJDK8", "TESTJDK9" };
352 }
353
354 // Run the specified test case(s)
355 Stream.of(args).map(x -> TestCase.valueOf(x)).forEach((x) -> {
356 switch(x) {
357 case GENERATE: generate(); break;
358 case TESTJDK8: Jdk8SerializedLog.test(); break;
359 case TESTJDK9: Jdk9SerializedLog.test(); break;
360 }
361 });
362 }
363 }