Fix ZIP entries last modification time is rounded down

Zip archives store file modification times with a granularity of
two seconds, so the times will either be rounded up or down.
Plexus Archiver chooses to round up, but it assumes that Java 7
round the seconds down and Java 8 round them up.
In reality that is not true. On Java 8 java.util.zip.ZipEntry.getTime()
returns the same value set with java.util.zip.ZipEntry.setTime(), but
that does not matter as the last modification time is again rounded down
(if the seconds are odd value) when the entry is added to the archive.
As a result Plexus Archiver rounds the seconds up or Java 7 and
rounds them down on Java 8 or newer.

Remove the Java version check so Plexus Archiver rounds up the
last modification time on both Java 7 and Java 8+.

Fixes #95

Author: plamentotev

src/main/java/org/codehaus/plexus/archiver/zip/AbstractZipArchiver.java

@@ -100,29 +100,6 @@ public abstract class AbstractZipArchiver
      */
     protected boolean addingNewFiles = false;
 
-    /**
-     * Whether the file modification times will be rounded up to the
-     * next even number of seconds.
-     * <p/>
-     * <p>
-     * Zip archives store file modification times with a
-     * granularity of two seconds, so the times will either be rounded
-     * up or down. If you round down, the archive will always seem
-     * out-of-date when you rerun the task, so the default is to round
-     * up. Rounding up may lead to a different type of problems like
-     * JSPs inside a web archive that seem to be slightly more recent
-     * than precompiled pages, rendering precompilation useless.</p>
-     *
-     * <p/>
-     * plexus-archiver chooses to round up.
-     * <p/>
-     * Java versions up to java7 round timestamp down, which means we add a heuristic value (which is slightly
-     * questionable)
-     * Java versions from 8 and up round timestamp up.
-     * s
-     */
-    private static final boolean isJava7OrLower = getJavaVersion() <= 7;
-
     // Renamed version of original file, if it exists
     private File renamedFile = null;
 
@@ -134,19 +111,6 @@ public abstract class AbstractZipArchiver
 
     protected ZipArchiveOutputStream zipArchiveOutputStream;
 
-    private static int getJavaVersion()
-    {
-        String javaSpecVersion = System.getProperty( "java.specification.version" );
-        if ( javaSpecVersion.contains( "." ) )
-        {//before jdk 9
-            return Integer.parseInt( javaSpecVersion.split( "\\." )[1] );
-        }
-        else
-        {
-            return Integer.parseInt( javaSpecVersion );
-        }
-    }
-
     public String getComment()
     {
         return comment;
@@ -569,7 +533,15 @@ public InputStream get()
 
     private void setTime( java.util.zip.ZipEntry zipEntry, long lastModified )
     {
-        zipEntry.setTime( lastModified + ( isJava7OrLower ? 1999 : 0 ) );
+        // Zip archives store file modification times with a
+        // granularity of two seconds, so the times will either be rounded
+        // up or down. If you round down, the archive will always seem
+        // out-of-date when you rerun the task, so the default is to round
+        // up. Rounding up may lead to a different type of problems like
+        // JSPs inside a web archive that seem to be slightly more recent
+        // than precompiled pages, rendering precompilation useless.
+        // plexus-archiver chooses to round up.
+        zipEntry.setTime( lastModified + 1999 );
 
         /*   Consider adding extended file stamp support.....
 

src/test/java/org/codehaus/plexus/archiver/zip/ZipArchiverTest.java

@@ -30,6 +30,8 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.attribute.FileTime;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Enumeration;
@@ -627,6 +629,33 @@ public void testSymlinkArchivedFileSet()
         ArchiveFileComparator.assertEquals( cmp1, cmp2, "" );
     }
 
+    /*
+     * Zip archives store file modification times with a granularity of two seconds.
+     * Verify that ZipArchiver rounds up the last modified time.
+     */
+    public void testLastModifiedTimeRounding()
+        throws Exception
+    {
+        File oddSecondsTimestampFile = File.createTempFile( "odd-seconds-timestamp", null );
+        oddSecondsTimestampFile.deleteOnExit();
+        // The milliseconds part is set to zero as not all filesystem support timestamp more granular than second.
+        Files.setLastModifiedTime( oddSecondsTimestampFile.toPath(), FileTime.fromMillis( 1534189011_000L ) );
+        File evenSecondsTimestampFile = File.createTempFile( "even-seconds-timestamp", null );
+        evenSecondsTimestampFile.deleteOnExit();
+        Files.setLastModifiedTime( evenSecondsTimestampFile.toPath(), FileTime.fromMillis( 1534189012_000L ) );
+
+        File destFile = getTestFile( "target/output/last-modified-time.zip" );
+        ZipArchiver archiver = getZipArchiver( destFile );
+        archiver.addFile( oddSecondsTimestampFile, "odd-seconds" );
+        archiver.addFile( evenSecondsTimestampFile, "even-seconds" );
+        archiver.createArchive();
+
+        // verify that the last modified time of the entry is equal or newer than the original file
+        ZipFile resultingZipFile = new ZipFile( destFile );
+        assertEquals( 1534189012_000L, resultingZipFile.getEntry( "odd-seconds" ).getTime() );
+        assertEquals( 1534189012_000L, resultingZipFile.getEntry( "even-seconds" ).getTime() );
+    }
+
     /*
      */
     public void testForced()