Issue 534 fix date utils test

src/test/java/org/javarosa/core/model/utils/test/DateUtilsParseTimeTests.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2009 JavaRosa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.javarosa.core.model.utils.test;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.Instant;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZoneId;
+import java.time.temporal.Temporal;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.TimeZone;
+import java.util.stream.Stream;
+import org.javarosa.core.model.utils.DateUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class DateUtilsParseTimeTests {
+    private Locale backupLocale;
+    private TimeZone backupZone;
+
+    @Parameterized.Parameter(value = 0)
+    public String input;
+
+    @Parameterized.Parameter(value = 1)
+    public Temporal expectedTime;
+
+    @Parameterized.Parameters(name = "Input: {0}")
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][]{
+            {"14:00", LocalTime.parse("14:00")},
+            {"14:00Z", OffsetTime.parse("14:00Z")},
+            {"14:00+02", OffsetTime.parse("14:00+02:00")},
+            {"14:00-02", OffsetTime.parse("14:00-02:00")},
+            {"14:00+02:30", OffsetTime.parse("14:00+02:30")},
+            {"14:00-02:30", OffsetTime.parse("14:00-02:30")},
+        });
+    }
+
+    @Before
+    public void setUp() {
+        backupLocale = Locale.getDefault();
+        backupZone = TimeZone.getDefault();
+    }
+
+    @After
+    public void tearDown() {
+        TimeZone.setDefault(backupZone);
+        Locale.setDefault(backupLocale);
+    }
+
+    @Test
+    public void testTimeParses() {
+        // The tricky part of DateUtils.parseTime is that we allow for input time
+        // values to include time offset declarations, which has issues at different
+        // levels:
+        // - Conceptually, time values with offsets don't make sense until they're
+        //   paired with a date so, how can we reason about what "10:00+02:00" means,
+        //   and what should be a valid expected output for that input value?
+        // - Next, DateUtils.parseTime() produces Date values, which are a date and a
+        //   time in the system's default time zone. Then, which date would we have to
+        //   expect?
+        //
+        // To solve these issues, DateUtils.parseTime() will use the system's current
+        // date as a base for its output value whenever that is and whichever time zone
+        // the system's at.
+        //
+        // By testing parseTime under different system default time zones we're trying
+        // to have the confidence that our resulting Date objects will always translate
+        // to the same time declaration from the input string (ignoring their date part,
+        // of course).
+        Stream.of(
+            TimeZone.getTimeZone("UTC"),
+            TimeZone.getTimeZone("GMT+12"),
+            TimeZone.getTimeZone("GMT-13"),
+            TimeZone.getTimeZone("GMT+0230")
+        ).forEach(timeZone -> {
+            TimeZone backupZone = TimeZone.getDefault();
+            TimeZone.setDefault(timeZone);
+            assertThat(parseTime(input), is(expectedTime));
+            TimeZone.setDefault(backupZone);
+        });
+    }
+
+    /**
+     * Returns a LocalTime or a OffsetTime obtained from the result of
+     * calling DateUtils.parseTime() with the provided input.
+     * <p>
+     * The interim OffsetDateTime value ensures that it represents the
+     * same instant as the Date from the call to DateUtils.parseTime().
+     */
+    public Temporal parseTime(String input) {
+        Instant inputInstant = Objects.requireNonNull(DateUtils.parseTime(input)).toInstant();
+
+        // No time offset declared. Return a LocalTime
+        if (input.length() == 5)
+            return OffsetDateTime.ofInstant(inputInstant, ZoneId.systemDefault()).toLocalTime();
+
+        // The input time is at UTC
+        if (input.charAt(5) == 'Z')
+            return OffsetDateTime.ofInstant(inputInstant, ZoneId.of("Z")).toOffsetTime();
+
+        // The input declares some positive or negative time offset
+        String offsetPart = input.substring(5);
+        // Fix for unparseable short offset notations such as +02
+        String offset = offsetPart.length() == 3 ? offsetPart + ":00" : offsetPart;
+        return OffsetDateTime.ofInstant(inputInstant, ZoneId.of(offset)).toOffsetTime();
+    }
+}

src/test/java/org/javarosa/core/model/utils/test/DateUtilsTests.java

@@ -19,14 +19,15 @@
 import static org.junit.Assert.assertEquals;
 
 import java.text.DateFormat;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.Locale;
 import java.util.SimpleTimeZone;
 import java.util.TimeZone;
 import org.javarosa.core.model.utils.DateUtils;
 import org.javarosa.core.model.utils.DateUtils.DateFields;
-import org.joda.time.LocalDateTime;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -43,8 +44,8 @@ public class DateUtilsTests {
     public void setUp() {
         backupLocale = Locale.getDefault();
         backupZone = TimeZone.getDefault();
-        testLocalDateTime = new LocalDateTime(2018, 1, 1, 10, 20, 30, 400);
-        testDate = testLocalDateTime.toDate();
+        testLocalDateTime = LocalDateTime.of(2018, 1, 1, 10, 20, 30, 400);
+        testDate = Date.from(testLocalDateTime.toInstant(OffsetDateTime.now().getOffset()));
     }
 
     @After
@@ -64,7 +65,7 @@ public void testGetXMLStringValueFormat() {
         assertEquals("The date string was not of the proper length", currentDate.length(), "YYYY-MM-DD".length());
         assertEquals("The date string does not have proper year formatting", currentDate.indexOf("-"), "YYYY-".indexOf("-"));
         assertEquals(testLocalDateTime.getYear(), Integer.parseInt(currentDate.substring(0, 4)));
-        assertEquals(testLocalDateTime.getMonthOfYear(), Integer.parseInt(currentDate.substring(5, 7)));
+        assertEquals(testLocalDateTime.getMonth().getValue(), Integer.parseInt(currentDate.substring(5, 7)));
         assertEquals(testLocalDateTime.getDayOfMonth(), Integer.parseInt(currentDate.substring(8, 10)));
     }
 
@@ -121,74 +122,6 @@ private void testDateTime(String in, long test) {
         assertEquals("Fail: " + in + "(" + TimeZone.getDefault().getDisplayName() + ")", test, value);
     }
 
-    @Test
-    public void testTimeParses() {
-        //This is all kind of tricky. We need to assume J2ME level compliance, so
-        //dates won't every be assumed to have an intrinsic timezone, they'll be
-        //assumed to be in the phone's default timezone
-
-        TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
-
-        Calendar startOfDay = Calendar.getInstance();
-        startOfDay.set(Calendar.HOUR_OF_DAY, 0);
-        startOfDay.set(Calendar.MINUTE, 0);
-        startOfDay.set(Calendar.SECOND, 0);
-        startOfDay.set(Calendar.MILLISECOND, 0);
-
-        long startOfDayDate = startOfDay.getTime().getTime();
-
-        testTime("10:00", startOfDayDate + 1000 * 60 * 60 * 10 - getOffset());
-        testTime("10:00Z", startOfDayDate + 1000 * 60 * 60 * 10);
-
-        testTime("10:00+02", startOfDayDate + 1000 * 60 * 60 * 8);
-        testTime("10:00-02", startOfDayDate + 1000 * 60 * 60 * 12);
-
-        testTime("10:00+02:30", startOfDayDate + 1000 * 60 * (60 * 10 - 150));
-        testTime("10:00-02:30", startOfDayDate + 1000 * 60 * (60 * 10 + 150));
-
-        TimeZone offsetTwoHours = TimeZone.getTimeZone("GMT+02");
-
-        TimeZone.setDefault(offsetTwoHours);
-
-        testTime("10:00", startOfDayDate + 1000 * 60 * 60 * 10 - getOffset());
-        testTime("10:00Z", startOfDayDate + 1000 * 60 * 60 * 10);
-
-        testTime("10:00+02", startOfDayDate + 1000 * 60 * 60 * 8);
-        testTime("10:00-02", startOfDayDate + 1000 * 60 * 60 * 12);
-
-        testTime("10:00+02:30", startOfDayDate + 1000 * 60 * (60 * 10 - 150));
-        testTime("10:00-02:30", startOfDayDate + 1000 * 60 * (60 * 10 + 150));
-
-        TimeZone offsetMinusTwoHours = TimeZone.getTimeZone("GMT-02");
-
-        TimeZone.setDefault(offsetMinusTwoHours);
-
-        testTime("14:00", startOfDayDate + 1000 * 60 * 60 * 14 - getOffset());
-        testTime("14:00Z", startOfDayDate + 1000 * 60 * 60 * 14);
-
-        testTime("14:00+02", startOfDayDate + 1000 * 60 * 60 * 12);
-        testTime("14:00-02", startOfDayDate + 1000 * 60 * 60 * 16);
-
-        testTime("14:00+02:30", startOfDayDate + 1000 * 60 * (60 * 14 - 150));
-        testTime("14:00-02:30", startOfDayDate + 1000 * 60 * (60 * 14 + 150));
-
-
-        TimeZone offsetPlusHalf = TimeZone.getTimeZone("GMT+0230");
-
-        TimeZone.setDefault(offsetPlusHalf);
-
-        testTime("14:00", startOfDayDate + 1000 * 60 * 60 * 14 - getOffset());
-        testTime("14:00Z", startOfDayDate + 1000 * 60 * 60 * 14);
-
-        testTime("14:00+02", startOfDayDate + 1000 * 60 * 60 * 12);
-        testTime("14:00-02", startOfDayDate + 1000 * 60 * 60 * 16);
-
-        testTime("14:00+02:30", startOfDayDate + 1000 * 60 * (60 * 14 - 150));
-        testTime("14:00-02:30", startOfDayDate + 1000 * 60 * (60 * 14 + 150));
-
-        testTime("14:00+04:00", startOfDayDate + 1000 * 60 * 60 * 10);
-    }
-
     private void testTime(String in, long test) {
         Date d = DateUtils.parseTime(in);
 
@@ -197,13 +130,6 @@ private void testTime(String in, long test) {
         assertEquals("Fail: " + in + "(" + TimeZone.getDefault().getDisplayName() + ")", test, value);
     }
 
-    private long getOffset() {
-        DateFields df = new DateFields();
-        Date d = DateUtils.getDate(df);
-
-        return -d.getTime();
-    }
-
     @Test
     public void testParity() {
 
@@ -294,8 +220,8 @@ private LangJanSun(String language, String january, String sunday) {
         }
 
         LangJanSun langJanSuns[] = new LangJanSun[]{
-            new LangJanSun("en", "Jan",   "Sun"),
-            new LangJanSun("es", "ene",   "dom"),
+            new LangJanSun("en", "Jan", "Sun"),
+            new LangJanSun("es", "ene", "dom"),
             new LangJanSun("fr", "janv.", "dim.")
         };