| /* | |
| * Copyright (c) 2021, 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 | |
| * @requires vm.bits == 64 | |
| * @bug 8276766 | |
| * @summary Test jar --date source date of entries and that jars are | |
| * reproducible | |
| * @modules jdk.jartool | |
| * @run testng/othervm ReproducibleJar | |
| */ | |
| import org.testng.Assert; | |
| import org.testng.annotations.AfterMethod; | |
| import org.testng.annotations.BeforeMethod; | |
| import org.testng.annotations.Test; | |
| import org.testng.annotations.DataProvider; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.io.PrintWriter; | |
| import java.nio.file.Files; | |
| import java.nio.file.attribute.FileTime; | |
| import java.util.Date; | |
| import java.util.TimeZone; | |
| import java.util.spi.ToolProvider; | |
| import java.time.LocalDateTime; | |
| import java.time.ZonedDateTime; | |
| import java.time.ZoneId; | |
| import java.time.ZoneOffset; | |
| import java.time.format.DateTimeFormatter; | |
| import java.time.Instant; | |
| import java.util.concurrent.TimeUnit; | |
| public class ReproducibleJar { | |
| private static final ToolProvider JAR_TOOL = ToolProvider.findFirst("jar") | |
| .orElseThrow(() -> | |
| new RuntimeException("jar tool not found") | |
| ); | |
| // ZipEntry's mod date has 2 seconds precision: give extra time to | |
| // allow for e.g. rounding/truncation and networked/samba drives. | |
| private static final long PRECISION = 10000L; | |
| private static final TimeZone TZ = TimeZone.getDefault(); | |
| private static final boolean DST = TZ.inDaylightTime(new Date()); | |
| private static final String UNIX_2038_ROLLOVER_TIME = "2038-01-19T03:14:07Z"; | |
| private static final Instant UNIX_2038_ROLLOVER = Instant.parse(UNIX_2038_ROLLOVER_TIME); | |
| private static final File DIR_OUTER = new File("outer"); | |
| private static final File DIR_INNER = new File(DIR_OUTER, "inner"); | |
| private static final File FILE_INNER = new File(DIR_INNER, "foo.txt"); | |
| private static final File JAR_FILE_SOURCE_DATE1 = new File("JarEntryTimeSourceDate1.jar"); | |
| private static final File JAR_FILE_SOURCE_DATE2 = new File("JarEntryTimeSourceDate2.jar"); | |
| // Valid --date values for jar | |
| @DataProvider | |
| private Object[][] validSourceDates() { | |
| return new Object[][]{ | |
| {"1980-01-01T00:00:02+00:00"}, | |
| {"1986-06-24T01:02:03+00:00"}, | |
| {"2022-03-15T00:00:00+00:00"}, | |
| {"2022-03-15T00:00:00+06:00"}, | |
| {"2021-12-25T09:30:00-08:00[America/Los_Angeles]"}, | |
| {"2021-12-31T23:59:59Z"}, | |
| {"2024-06-08T14:24Z"}, | |
| {"2026-09-24T16:26-05:00"}, | |
| {"2038-11-26T06:06:06+00:00"}, | |
| {"2098-02-18T00:00:00-08:00"}, | |
| {"2099-12-31T23:59:59+00:00"} | |
| }; | |
| } | |
| // Invalid --date values for jar | |
| @DataProvider | |
| private Object[][] invalidSourceDates() { | |
| return new Object[][]{ | |
| {"1976-06-24T01:02:03+00:00"}, | |
| {"1980-01-01T00:00:01+00:00"}, | |
| {"2100-01-01T00:00:00+00:00"}, | |
| {"2138-02-18T00:00:00-11:00"}, | |
| {"2006-04-06T12:38:00"}, | |
| {"2012-08-24T16"} | |
| }; | |
| } | |
| @BeforeMethod | |
| public void runBefore() throws IOException { | |
| runAfter(); | |
| createOuterInnerDirs(); | |
| } | |
| @AfterMethod | |
| public void runAfter() { | |
| cleanup(DIR_INNER); | |
| cleanup(DIR_OUTER); | |
| JAR_FILE_SOURCE_DATE1.delete(); | |
| JAR_FILE_SOURCE_DATE2.delete(); | |
| TimeZone.setDefault(TZ); | |
| } | |
| /** | |
| * Test jar tool with various valid --date <timestamps> | |
| */ | |
| @Test(dataProvider = "validSourceDates") | |
| public void testValidSourceDate(String sourceDate) { | |
| if (isInTransition()) return; | |
| // Test --date source date | |
| Assert.assertEquals(JAR_TOOL.run(System.out, System.err, | |
| "--create", | |
| "--file", JAR_FILE_SOURCE_DATE1.getName(), | |
| "--date", sourceDate, | |
| DIR_OUTER.getName()), 0); | |
| Assert.assertTrue(JAR_FILE_SOURCE_DATE1.exists()); | |
| // Extract JAR_FILE_SOURCE_DATE1 and check last modified values | |
| Assert.assertEquals(JAR_TOOL.run(System.out, System.err, | |
| "--extract", | |
| "--file", JAR_FILE_SOURCE_DATE1.getName()), 0); | |
| Assert.assertTrue(DIR_OUTER.exists()); | |
| Assert.assertTrue(DIR_INNER.exists()); | |
| Assert.assertTrue(FILE_INNER.exists()); | |
| LocalDateTime expectedLdt = ZonedDateTime.parse(sourceDate, | |
| DateTimeFormatter.ISO_DATE_TIME) | |
| .withZoneSameInstant(ZoneOffset.UTC) | |
| .toLocalDateTime(); | |
| System.out.format("Checking jar entries local date time for --date %s, is %s%n", | |
| sourceDate, expectedLdt); | |
| long sourceDateEpochMillis = TimeUnit.MILLISECONDS.convert( | |
| expectedLdt.toEpochSecond(ZoneId.systemDefault().getRules() | |
| .getOffset(expectedLdt)), TimeUnit.SECONDS); | |
| checkFileTime(DIR_OUTER.lastModified(), sourceDateEpochMillis); | |
| checkFileTime(DIR_INNER.lastModified(), sourceDateEpochMillis); | |
| checkFileTime(FILE_INNER.lastModified(), sourceDateEpochMillis); | |
| } | |
| /** | |
| * Test jar tool with various invalid --date <timestamps> | |
| */ | |
| @Test(dataProvider = "invalidSourceDates") | |
| public void testInvalidSourceDate(String sourceDate) { | |
| // Negative Tests --date out of range or wrong format source date | |
| Assert.assertNotEquals(JAR_TOOL.run(System.out, System.err, | |
| "--create", | |
| "--file", JAR_FILE_SOURCE_DATE1.getName(), | |
| "--date", sourceDate, | |
| DIR_OUTER.getName()), 0); | |
| } | |
| /** | |
| * Test jar produces deterministic reproducible output | |
| */ | |
| @Test(dataProvider = "validSourceDates") | |
| public void testJarsReproducible(String sourceDate) throws IOException { | |
| // Test jars are reproducible across timezones | |
| TimeZone tzAsia = TimeZone.getTimeZone("Asia/Shanghai"); | |
| TimeZone tzLA = TimeZone.getTimeZone("America/Los_Angeles"); | |
| TimeZone.setDefault(tzAsia); | |
| Assert.assertEquals(JAR_TOOL.run(System.out, System.err, | |
| "--create", | |
| "--file", JAR_FILE_SOURCE_DATE1.getName(), | |
| "--date", sourceDate, | |
| DIR_OUTER.getName()), 0); | |
| Assert.assertTrue(JAR_FILE_SOURCE_DATE1.exists()); | |
| try { | |
| // Sleep 5 seconds to ensure jar timestamps might be different if they could be | |
| Thread.sleep(5000); | |
| } catch (InterruptedException ex) { | |
| } | |
| TimeZone.setDefault(tzLA); | |
| Assert.assertEquals(JAR_TOOL.run(System.out, System.err, | |
| "--create", | |
| "--file", JAR_FILE_SOURCE_DATE2.getName(), | |
| "--date", sourceDate, | |
| DIR_OUTER.getName()), 0); | |
| Assert.assertTrue(JAR_FILE_SOURCE_DATE2.exists()); | |
| // Check jars are identical | |
| Assert.assertEquals(Files.readAllBytes(JAR_FILE_SOURCE_DATE1.toPath()), | |
| Files.readAllBytes(JAR_FILE_SOURCE_DATE2.toPath())); | |
| } | |
| /** | |
| * Create the standard directory structure used by the test: | |
| * outer/ | |
| * inner/ | |
| * foo.txt | |
| */ | |
| static void createOuterInnerDirs() throws IOException { | |
| Assert.assertTrue(DIR_OUTER.mkdir()); | |
| Assert.assertTrue(DIR_INNER.mkdir()); | |
| try (PrintWriter pw = new PrintWriter(FILE_INNER)) { | |
| pw.println("hello, world"); | |
| } | |
| Assert.assertTrue(DIR_OUTER.exists()); | |
| Assert.assertTrue(DIR_INNER.exists()); | |
| Assert.assertTrue(FILE_INNER.exists()); | |
| } | |
| /** | |
| * Check the extracted and original millis since Epoch file times are | |
| * within the zip precision time period. | |
| */ | |
| static void checkFileTime(long now, long original) { | |
| if (isTimeSettingChanged()) { | |
| return; | |
| } | |
| if (Math.abs(now - original) > PRECISION) { | |
| // If original time is after UNIX 2038 32bit rollover | |
| // and the now time is exactly the rollover time, then assume | |
| // running on a file system that only supports to 2038 (e.g.XFS) and pass test | |
| if (FileTime.fromMillis(original).toInstant().isAfter(UNIX_2038_ROLLOVER) && | |
| FileTime.fromMillis(now).toInstant().equals(UNIX_2038_ROLLOVER)) { | |
| System.out.println("Checking file time after Unix 2038 rollover," + | |
| " and extracted file time is " + UNIX_2038_ROLLOVER_TIME + ", " + | |
| " Assuming restricted file system, pass file time check."); | |
| } else { | |
| throw new AssertionError("checkFileTime failed," + | |
| " extracted to " + FileTime.fromMillis(now) + | |
| ", expected to be close to " + FileTime.fromMillis(original)); | |
| } | |
| } | |
| } | |
| /** | |
| * Has the timezone or DST changed during the test? | |
| */ | |
| private static boolean isTimeSettingChanged() { | |
| TimeZone currentTZ = TimeZone.getDefault(); | |
| boolean currentDST = currentTZ.inDaylightTime(new Date()); | |
| if (!currentTZ.equals(TZ) || currentDST != DST) { | |
| System.out.println("Timezone or DST has changed during " + | |
| "ReproducibleJar testcase execution. Test skipped"); | |
| return true; | |
| } else { | |
| return false; | |
| } | |
| } | |
| /** | |
| * Is the Zone currently within the transition change period? | |
| */ | |
| private static boolean isInTransition() { | |
| var inTransition = false; | |
| var date = new Date(); | |
| var defZone = ZoneId.systemDefault(); | |
| if (defZone.getRules().getTransition( | |
| date.toInstant().atZone(defZone).toLocalDateTime()) != null) { | |
| System.out.println("ReproducibleJar testcase being run during Zone offset transition. Test skipped."); | |
| inTransition = true; | |
| } | |
| return inTransition; | |
| } | |
| /** | |
| * Remove the directory and its contents | |
| */ | |
| static void cleanup(File dir) { | |
| File[] x = dir.listFiles(); | |
| if (x != null) { | |
| for (File f : x) { | |
| f.delete(); | |
| } | |
| } | |
| dir.delete(); | |
| } | |
| } |