diff options
| author | Florian Zschocke <2362065+flaix@users.noreply.github.com> | 2021-10-24 01:48:39 +0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-10-24 01:48:39 +0200 |
| commit | 583e15eb3f0f3a565b031dc554b420e28c50baae (patch) | |
| tree | acf5d2ddc5939311ba92beca4909fede35c2901b /src/test/java/com/gitblit/utils/TimeUtilsTest.java | |
| parent | 4f04ab8ec402dd51bbdb7121d89da2d9a385f1a8 (diff) | |
| parent | 920fc522b47b90c534848dc926af1bbc5f517592 (diff) | |
| download | gitblit-583e15eb3f0f3a565b031dc554b420e28c50baae.tar.gz gitblit-583e15eb3f0f3a565b031dc554b420e28c50baae.zip | |
Merge pull request #1382 from flaix/wip-fix-daysAgo
Fix incorrect display of "days ago" on activity page
Diffstat (limited to 'src/test/java/com/gitblit/utils/TimeUtilsTest.java')
| -rw-r--r-- | src/test/java/com/gitblit/utils/TimeUtilsTest.java | 690 |
1 files changed, 690 insertions, 0 deletions
diff --git a/src/test/java/com/gitblit/utils/TimeUtilsTest.java b/src/test/java/com/gitblit/utils/TimeUtilsTest.java new file mode 100644 index 00000000..0e58a364 --- /dev/null +++ b/src/test/java/com/gitblit/utils/TimeUtilsTest.java @@ -0,0 +1,690 @@ +/*
+ * Copyright 2011 gitblit.com.
+ *
+ * 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 com.gitblit.utils;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+import com.gitblit.tests.GitblitUnitTest;
+import org.junit.Test;
+
+
+public class TimeUtilsTest extends GitblitUnitTest
+{
+
+ private Date offset(long subtract) {
+ return new Date(System.currentTimeMillis() - subtract);
+ }
+
+ private Date offset(long now, long subtract) {
+ return new Date(now - subtract);
+ }
+
+ @Test
+ public void testBasicTimeFunctions() throws Exception {
+ assertEquals(2, TimeUtils.minutesAgo(offset(2 * TimeUtils.MIN), false));
+ assertEquals(3, TimeUtils.minutesAgo(offset((2 * TimeUtils.MIN) + (35 * 1000L)), true));
+
+ assertEquals(2, TimeUtils.hoursAgo(offset(2 * TimeUtils.ONEHOUR), false));
+ assertEquals(3, TimeUtils.hoursAgo(offset(5 * TimeUtils.HALFHOUR), true));
+
+ assertEquals(4, TimeUtils.daysAgo(offset(4 * TimeUtils.ONEDAY)));
+ }
+
+ @Test
+ public void testToday() throws Exception {
+ assertTrue(TimeUtils.isToday(new Date(), null));
+ }
+
+ @Test
+ public void testYesterday() throws Exception {
+ assertTrue(TimeUtils.isYesterday(offset(TimeUtils.ONEDAY), null));
+ }
+
+ @Test
+ public void testDurations() throws Exception {
+ TimeUtils timeUtils = new TimeUtils();
+ assertEquals("1 day", timeUtils.duration(1));
+ assertEquals("5 days", timeUtils.duration(5));
+ assertEquals("3 months", timeUtils.duration(75));
+ assertEquals("12 months", timeUtils.duration(364));
+ assertEquals("1 year", timeUtils.duration(365 + 0));
+ assertEquals("1 year", timeUtils.duration(365 + 10));
+ assertEquals("1 year, 1 month", timeUtils.duration(365 + 15));
+ assertEquals("1 year, 1 month", timeUtils.duration(365 + 30));
+ assertEquals("1 year, 1 month", timeUtils.duration(365 + 44));
+ assertEquals("1 year, 2 months", timeUtils.duration(365 + 45));
+ assertEquals("1 year, 2 months", timeUtils.duration(365 + 60));
+
+ assertEquals("2 years", timeUtils.duration(2 * 365 + 0));
+ assertEquals("2 years", timeUtils.duration(2 * 365 + 10));
+ assertEquals("2 years, 1 month", timeUtils.duration(2 * 365 + 15));
+ assertEquals("2 years, 1 month", timeUtils.duration(2 * 365 + 30));
+ assertEquals("2 years, 1 month", timeUtils.duration(2 * 365 + 44));
+ assertEquals("2 years, 2 months", timeUtils.duration(2 * 365 + 45));
+ assertEquals("2 years, 2 months", timeUtils.duration(2 * 365 + 60));
+ }
+
+ @Test
+ public void testTimeAgo() throws Exception {
+ // standard time ago tests
+ TimeUtils timeUtils = new TimeUtils();
+ assertEquals("just now", timeUtils.timeAgo(offset(1 * TimeUtils.MIN)));
+ assertEquals("60 mins ago", timeUtils.timeAgo(offset(60 * TimeUtils.MIN)));
+ assertEquals("2 hours ago", timeUtils.timeAgo(offset(120 * TimeUtils.MIN)));
+ assertEquals("15 hours ago", timeUtils.timeAgo(offset(15 * TimeUtils.ONEHOUR)));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(24 * TimeUtils.ONEHOUR)));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(2 * TimeUtils.ONEDAY)));
+ assertEquals("5 weeks ago", timeUtils.timeAgo(offset(35 * TimeUtils.ONEDAY)));
+ assertEquals("3 months ago", timeUtils.timeAgo(offset(84 * TimeUtils.ONEDAY)));
+ assertEquals("3 months ago", timeUtils.timeAgo(offset(95 * TimeUtils.ONEDAY)));
+ assertEquals("4 months ago", timeUtils.timeAgo(offset(104 * TimeUtils.ONEDAY)));
+ assertEquals("1 year ago", timeUtils.timeAgo(offset(365 * TimeUtils.ONEDAY)));
+ assertEquals("13 months ago", timeUtils.timeAgo(offset(395 * TimeUtils.ONEDAY)));
+ assertEquals("2 years ago", timeUtils.timeAgo(offset((2 * 365 + 30) * TimeUtils.ONEDAY)));
+ }
+
+ @Test
+ public void testTimeAgoCss() throws Exception {
+ // css class tests
+ TimeUtils timeUtils = new TimeUtils();
+ assertEquals("age0", timeUtils.timeAgoCss(offset(1 * TimeUtils.MIN)));
+ assertEquals("age0", timeUtils.timeAgoCss(offset(60 * TimeUtils.MIN)));
+ assertEquals("age1", timeUtils.timeAgoCss(offset(120 * TimeUtils.MIN)));
+ assertEquals("age1", timeUtils.timeAgoCss(offset(24 * TimeUtils.ONEHOUR)));
+ assertEquals("age2", timeUtils.timeAgoCss(offset(2 * TimeUtils.ONEDAY)));
+ }
+
+
+ @Test
+ public void testTimeAgoYesterday() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("GMT");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 12);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,23 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (29 * TimeUtils.MIN)), false, now));
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (31 * TimeUtils.MIN)), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,35 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,36 * TimeUtils.ONEHOUR), false, now));
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,37 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,44 * TimeUtils.ONEHOUR), false, now));
+ }
+
+ @Test
+ public void testTimeAgoYesterdayCET() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("CET");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 22);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,23 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (29 * TimeUtils.MIN)), false, now));
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (31 * TimeUtils.MIN)), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,36 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,46 * TimeUtils.ONEHOUR), false, now));
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,47 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,56 * TimeUtils.ONEHOUR), false, now));
+ }
+
+
+ @Test
+ public void testTimeAgoYesterdayPST() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("PST");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 8);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,23 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (29 * TimeUtils.MIN)), false, now));
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,(23 * TimeUtils.ONEHOUR) + (31 * TimeUtils.MIN)), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,30 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,32 * TimeUtils.ONEHOUR), false, now));
+
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,33 * TimeUtils.ONEHOUR), false, now));
+ assertNotEquals("yesterday", timeUtils.timeAgo(offset(now,48 * TimeUtils.ONEHOUR), false, now));
+ }
+
+ @Test
+ public void testFrequency() {
+ assertEquals(5, TimeUtils.convertFrequencyToMinutes("2 mins", 5));
+ assertEquals(10, TimeUtils.convertFrequencyToMinutes("10 mins", 5));
+ assertEquals(600, TimeUtils.convertFrequencyToMinutes("10 hours", 5));
+ assertEquals(14400, TimeUtils.convertFrequencyToMinutes(" 10 days ", 5));
+ }
+
+
+ @Test
+ public void testTimeAgoDaysAgo() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("GMT");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 12);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,36 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,37 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,48 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,60 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,61 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,72 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,84 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("4 days ago", timeUtils.timeAgo(offset(now,85 * TimeUtils.ONEHOUR), false, now));
+ }
+
+
+
+ @Test
+ public void testTimeAgoDaysAgoCET() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("CET");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 8);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,32 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,33 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,48 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,56 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,57 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,72 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,80 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("4 days ago", timeUtils.timeAgo(offset(now,81 * TimeUtils.ONEHOUR), false, now));
+ }
+
+
+
+ @Test
+ public void testTimeAgoDaysAgoPST() throws Exception {
+ TimeZone myTimezone = TimeZone.getTimeZone("PST");
+ TimeUtils timeUtils = new TimeUtils(null, myTimezone);
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(Calendar.HOUR_OF_DAY, 22);
+ myCal.set(Calendar.MINUTE, 0);
+ long now = myCal.getTime().getTime();
+
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,24 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("yesterday", timeUtils.timeAgo(offset(now,46 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,47 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,48 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("2 days ago", timeUtils.timeAgo(offset(now,70 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,71 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,72 * TimeUtils.ONEHOUR), false, now));
+ assertEquals("3 days ago", timeUtils.timeAgo(offset(now,94 * TimeUtils.ONEHOUR), false, now));
+
+ assertEquals("4 days ago", timeUtils.timeAgo(offset(now,95 * TimeUtils.ONEHOUR), false, now));
+ }
+
+
+
+ /*
+ * Test if time difference is correctly calculated in full calendar days relative to GMT.
+ */
+ @Test
+ public void testCalendarDaysAgoToGmt() {
+ TimeZone myTimezone = TimeZone.getTimeZone("GMT");
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(2021, Calendar.AUGUST, 19, 12, 0, 5);
+ long now = myCal.getTime().getTime();
+ // Date from the same time zone
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 11 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR + 1 * TimeUtils.MIN), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 24 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR + 10 * 1000), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 48 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 60 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(3, TimeUtils.calendarDaysAgo(offset(now, 61 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+
+ // What if we get passed a date created from a UTC timestamp that came from a different time zone?
+ // CET in August is +2 hours from GMT (CEST). So the day border is shifted two hours forward
+
+ Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("CET"));
+
+ cal.set(2021, Calendar.AUGUST, 19, 8, 0, 5);
+ Date date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 19, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 19, 1, 30, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 18, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 18, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 18, 0, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 17, 23, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 17, 3, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 17, 1, 0, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ // Now we travel westwards.
+ // PST in August is -7 hours from GMT (PDT). So the day border is shifted seven hours back
+
+ cal = Calendar.getInstance(TimeZone.getTimeZone("PST"));
+ cal.clear();
+
+ cal.set(2021, Calendar.AUGUST, 19, 5, 0, 0);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 19, 0, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 18, 17, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 18, 16, 55, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 18, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 17, 17, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 17, 16, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 17, 1, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2021, Calendar.AUGUST, 16, 17, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2021, Calendar.AUGUST, 16, 14, 0, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+ }
+
+
+ /*
+ * Test if time difference is correctly calculated in full calendar days relative to CET.
+ */
+ @Test
+ public void testCalendarDaysAgoToCet() {
+ TimeZone myTimezone = TimeZone.getTimeZone("CET");
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(2020, Calendar.JUNE, 5, 12, 0, 5);
+ long now = myCal.getTime().getTime();
+
+ // Date from the same time zone
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 11 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR + 1 * TimeUtils.MIN), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 24 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR + 10 * 1000), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 48 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 60 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(3, TimeUtils.calendarDaysAgo(offset(now, 61 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+
+ // What if we get passed a date created from a UTC timestamp that came from a different time zone?
+ // IST in June is +3:30 hours from CEST. So the day border is shifted three and a half hours forward
+
+ Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
+
+ cal.set(2020, Calendar.JUNE, 5, 13, 0, 5);
+ Date date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 5, 3, 30, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 5, 3, 29, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 5, 0, 0, 0);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 4, 10, 0, 0);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 4, 4, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 4, 3, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 3, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 3, 4, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 3, 3, 20, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ // Now we travel westwards to New York.
+ // EST in June is -6 hours from CEST (EDT). So the day border is shifted six hours back
+
+ cal = Calendar.getInstance(TimeZone.getTimeZone("EST5EDT"));
+ cal.clear();
+
+ cal.set(2020, Calendar.JUNE, 5, 5, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 5, 0, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 4, 18, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 4, 17, 59, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 4, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 3, 19, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 3, 17, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 3, 8, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2020, Calendar.JUNE, 2, 18, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2020, Calendar.JUNE, 2, 17, 20, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+ }
+
+
+ /*
+ * Test if time difference is correctly calculated in full calendar days relative to AET (Australia).
+ */
+ @Test
+ public void testCalendarDaysAgoToAet() {
+ TimeZone myTimezone = TimeZone.getTimeZone("AET");
+
+ Calendar myCal = Calendar.getInstance(myTimezone);
+ myCal.set(2022, Calendar.FEBRUARY, 22, 12, 0, 5);
+ long now = myCal.getTime().getTime();
+
+ // Date from the same time zone
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 11 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(0, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 12 * TimeUtils.ONEHOUR + 1 * TimeUtils.MIN), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 24 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(1, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 36 * TimeUtils.ONEHOUR + 10 * 1000), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 48 * TimeUtils.ONEHOUR ), myTimezone, now));
+ assertEquals(2, TimeUtils.calendarDaysAgo(offset(now, 60 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+ assertEquals(3, TimeUtils.calendarDaysAgo(offset(now, 61 * TimeUtils.ONEHOUR ), myTimezone, now));
+
+
+ // What if we get passed a date created from a UTC timestamp that came from a different time zone?
+ // NZ in February is +2 hours from AEDT. So the day border is shifted two hours forward
+
+ Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("NZ"));
+
+ cal.set(2022, Calendar.FEBRUARY, 22, 12, 0, 5);
+ Date date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 22, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 22, 1, 45, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 22, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 1, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 10, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 1, 0, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ // Now we travel westwards to Europe.
+ // CET in February is -10 hours from AEDT. So the day border is shifted ten hours back
+
+ cal = Calendar.getInstance(TimeZone.getTimeZone("CET"));
+ cal.clear();
+
+ cal.set(2022, Calendar.FEBRUARY, 22, 2, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 22, 0, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 14, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 13, 30, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 7, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 15, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 13, 59, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 1, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 19, 14, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 19, 9, 0, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ // Lets continue even further west.
+ // AST in February is -15 hours from AEDT. So the day border is shifted fifteen hours back
+
+ cal = Calendar.getInstance(TimeZone.getTimeZone("America/Curacao"));
+ cal.clear();
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 21, 0, 0);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 12, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 9, 0, 5);
+ date = cal.getTime();
+ assertEquals(0, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 21, 8, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 19, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 10, 0, 5);
+ date = cal.getTime();
+ assertEquals(1, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 20, 8, 50, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 19, 17, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+ cal.set(2022, Calendar.FEBRUARY, 19, 9, 0, 5);
+ date = cal.getTime();
+ assertEquals(2, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+
+
+ cal.set(2022, Calendar.FEBRUARY, 19, 7, 0, 5);
+ date = cal.getTime();
+ assertEquals(3, TimeUtils.calendarDaysAgo(date, myTimezone, now));
+ }
+
+}
|