From 7bddfbe5a7a23bf3ba94b42ed3f7c379a7f4f7ac Mon Sep 17 00:00:00 2001 From: sgallese Date: Sun, 19 Sep 2021 21:55:00 -0700 Subject: [PATCH 1/8] Tests for DateUtils and FileExtensions --- .../isoron/uhabits/core/utils/DateUtils.kt | 8 +-- .../uhabits/core/utils/DateUtilsTest.kt | 59 +++++++++++++++++++ .../uhabits/core/utils/FileExtensionsTest.kt | 17 ++++++ 3 files changed, 80 insertions(+), 4 deletions(-) create mode 100644 uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/FileExtensionsTest.kt diff --git a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt index 8af545504..e812bc2ca 100644 --- a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt +++ b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt @@ -77,11 +77,11 @@ abstract class DateUtils { } @JvmStatic - fun getLocalTime(): Long { + fun getLocalTime(testTimeInMillis: Long? = null): Long { if (fixedLocalTime != null) return fixedLocalTime as Long val tz = getTimeZone() - val now = Date().time + val now = testTimeInMillis ?: Date().time return now + tz.getOffset(now) } @@ -100,7 +100,7 @@ abstract class DateUtils { format: Int, firstWeekDay: Int ): Array { - val calendar = GregorianCalendar() + val calendar = GregorianCalendar(getLocale()) calendar.set(DAY_OF_WEEK, firstWeekDay) val daysNullable = ArrayList() @@ -149,7 +149,7 @@ abstract class DateUtils { */ @JvmStatic fun getFirstWeekdayNumberAccordingToLocale(): Int { - return GregorianCalendar().firstDayOfWeek + return GregorianCalendar(getLocale()).firstDayOfWeek } /** diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 1b440279e..5519ff1ed 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -58,6 +58,65 @@ class DateUtilsTest : BaseUnitTest() { assertThat(formatted, equalTo("Thu\n31")) } + @Test + fun testGetLocalTime() { + setFixedLocalTime(null) + setFixedTimeZone(TimeZone.getTimeZone("Australia/Sydney")) + val utcTestTimeInMillis = unixTime(2015, Calendar.JANUARY, 11) + val localTimeInMillis = DateUtils.getLocalTime(utcTestTimeInMillis) + val expectedUnixTimeOffsetForSydney = 11 * 60 * 60 * 1000 + val expectedUnixTimeForSydney = utcTestTimeInMillis + expectedUnixTimeOffsetForSydney + assertThat(expectedUnixTimeForSydney, equalTo(localTimeInMillis)) + } + + @Test + fun testGetWeekdaySequence() { + val weekdaySequence = DateUtils.getWeekdaySequence(3) + assertThat(arrayOf(3, 4, 5, 6, 7, 1, 2), equalTo(weekdaySequence)) + } + + @Test + fun testGetFirstWeekdayNumberAccordingToLocale_germany() { + setFixedLocale(Locale.GERMANY) + val firstWeekdayNumber = DateUtils.getFirstWeekdayNumberAccordingToLocale() + assertThat(2, equalTo(firstWeekdayNumber)) + } + + @Test + fun testGetFirstWeekdayNumberAccordingToLocale_us() { + setFixedLocale(Locale.US) + val firstWeekdayNumber = DateUtils.getFirstWeekdayNumberAccordingToLocale() + assertThat(1, equalTo(firstWeekdayNumber)) + } + + @Test + fun testGetLongWeekdayNames_germany() { + setFixedLocale(Locale.GERMANY) + val longWeekdayNames = DateUtils.getLongWeekdayNames(Calendar.SATURDAY) + assertThat(arrayOf("Samstag", "Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag"), equalTo(longWeekdayNames)) + } + + @Test + fun testGetLongWeekdayNames_us() { + setFixedLocale(Locale.US) + val longWeekdayNames = DateUtils.getLongWeekdayNames(Calendar.SATURDAY) + assertThat(arrayOf("Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday"), equalTo(longWeekdayNames)) + } + + @Test + fun testGetShortWeekdayNames_germany() { + setFixedLocale(Locale.GERMANY) + val longWeekdayNames = DateUtils.getShortWeekdayNames(Calendar.SATURDAY) + assertThat(arrayOf("Sa.", "So.", "Mo.", "Di.", "Mi.", "Do.", "Fr."), equalTo(longWeekdayNames)) + } + + @Test + fun testGetShortWeekdayNames_us() { + setFixedLocale(Locale.US) + val longWeekdayNames = DateUtils.getShortWeekdayNames(Calendar.SATURDAY) + assertThat(arrayOf("Sat", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri"), equalTo(longWeekdayNames)) + } + @Test fun testTruncate_dayOfWeek() { val field = DateUtils.TruncateField.WEEK_NUMBER diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/FileExtensionsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/FileExtensionsTest.kt new file mode 100644 index 000000000..627422608 --- /dev/null +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/FileExtensionsTest.kt @@ -0,0 +1,17 @@ +package org.isoron.uhabits.core.utils + +import org.isoron.uhabits.core.BaseUnitTest +import org.junit.Test +import java.io.File +import kotlin.test.assertTrue + +class FileExtensionsTest : BaseUnitTest() { + + @Test + fun testIsSQLite3File() { + val file = File.createTempFile("asset", "") + copyAssetToFile("loop.db", file) + val isSqlite3File = file.isSQLite3File() + assertTrue(isSqlite3File) + } +} From 66c61e2e6cabe2d6f6dd614b2846386e87cd20aa Mon Sep 17 00:00:00 2001 From: sgallese Date: Mon, 20 Sep 2021 22:10:07 -0700 Subject: [PATCH 2/8] More DateUtils tests --- .../uhabits/core/utils/DateUtilsTest.kt | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 5519ff1ed..212b50508 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -117,6 +117,54 @@ class DateUtilsTest : BaseUnitTest() { assertThat(arrayOf("Sat", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri"), equalTo(longWeekdayNames)) } + @Test + fun testGetToday() { + setFixedLocalTime(FIXED_LOCAL_TIME) + val today = DateUtils.getToday() + assertThat(Timestamp(FIXED_LOCAL_TIME), equalTo(today)) + } + + @Test + fun testGetStartOfDay() { + val expectedStartOfDayUtc = unixTime(2017, Calendar.JANUARY, 1, 0, 0) + val laterInTheDayUtc = unixTime(2017, Calendar.JANUARY, 1, 20, 0) + val startOfDay = DateUtils.getStartOfDay(laterInTheDayUtc) + assertThat(expectedStartOfDayUtc, equalTo(startOfDay)) + } + + @Test + fun testGetStartOfToday() { + val expectedStartOfDayUtc = unixTime(2017, Calendar.JANUARY, 1, 0, 0) + val laterInTheDayUtc = unixTime(2017, Calendar.JANUARY, 1, 20, 0) + setFixedLocalTime(laterInTheDayUtc) + val startOfToday = DateUtils.getStartOfToday() + assertThat(expectedStartOfDayUtc, equalTo(startOfToday)) + } + + @Test + fun testGetStartOfTomorrowWithOffset_priorToOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset, 0) + val priorToOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset - 1, 0) + setFixedLocalTime(priorToOffset) + val startOfTomorrow = DateUtils.getStartOfTomorrowWithOffset() + assertThat(startOfTomorrowWithOffset, equalTo(startOfTomorrow)) + } + + @Test + fun testGetStartOfTomorrowWithOffset_afterOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset, 0) + val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) + setFixedLocalTime(afterOffset) + val startOfTomorrow = DateUtils.getStartOfTomorrowWithOffset() + assertThat(startOfTomorrowWithOffset, equalTo(startOfTomorrow)) + } + @Test fun testTruncate_dayOfWeek() { val field = DateUtils.TruncateField.WEEK_NUMBER From 9e241286751139dd8884692942620d98881d893e Mon Sep 17 00:00:00 2001 From: sgallese Date: Tue, 21 Sep 2021 21:02:49 -0700 Subject: [PATCH 3/8] DateUtils today offset tests --- .../uhabits/core/utils/DateUtilsTest.kt | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 212b50508..1e79e335c 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -165,6 +165,30 @@ class DateUtilsTest : BaseUnitTest() { assertThat(startOfTomorrowWithOffset, equalTo(startOfTomorrow)) } + @Test + fun testGetStartOfTodayWithOffset_priorToOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val startOfYesterday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) + val priorToOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset - 1, 0) + setFixedLocalTime(priorToOffset) + val startOfTodayWithOffset = DateUtils.getStartOfTodayWithOffset() + assertThat(startOfYesterday, equalTo(startOfTodayWithOffset)) + } + + @Test + fun testGetStartOfTodayWithOffset_afterOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val startOfToday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) + val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) + setFixedLocalTime(afterOffset) + val startOfTodayWithOffset = DateUtils.getStartOfTodayWithOffset() + assertThat(startOfToday, equalTo(startOfTodayWithOffset)) + } + @Test fun testTruncate_dayOfWeek() { val field = DateUtils.TruncateField.WEEK_NUMBER From b15c02adbf57b1ce24290d9623e2b49da8649a79 Mon Sep 17 00:00:00 2001 From: sgallese Date: Tue, 21 Sep 2021 21:31:37 -0700 Subject: [PATCH 4/8] Calendar tests for DateUtils --- .../uhabits/core/utils/DateUtilsTest.kt | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 1e79e335c..a3388b4f7 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -37,6 +37,7 @@ import org.isoron.uhabits.core.utils.DateUtils.Companion.truncate import org.junit.Before import org.junit.Test import java.util.Calendar +import java.util.GregorianCalendar import java.util.Locale import java.util.TimeZone @@ -297,6 +298,45 @@ class DateUtilsTest : BaseUnitTest() { ) } + @Test + fun testGetStartOfTodayCalendar() { + setFixedLocalTime(FIXED_LOCAL_TIME) + setFixedLocale(Locale.GERMANY) + val expectedStartOfDay = unixTime(2015, Calendar.JANUARY, 25, 0, 0) + val expectedCalendar = GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.GERMANY) + expectedCalendar.timeInMillis = expectedStartOfDay + val startOfTodayCalendar = DateUtils.getStartOfTodayCalendar() + assertThat(expectedCalendar, equalTo(startOfTodayCalendar)) + } + + @Test + fun testGetStartOfTodayCalendarWithOffset_priorToOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + val priorToOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset - 1, 0) + setFixedLocalTime(priorToOffset) + setFixedLocale(Locale.GERMANY) + val startOfYesterday = unixTime(2017, Calendar.JANUARY, 2, 0, 0) + val expectedCalendar = GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.GERMANY) + expectedCalendar.timeInMillis = startOfYesterday + val startOfTodayCalendar = DateUtils.getStartOfTodayCalendar() + assertThat(expectedCalendar, equalTo(startOfTodayCalendar)) + } + + @Test + fun testGetStartOfTodayCalendarWithOffset_afterOffset() { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) + setFixedLocalTime(afterOffset) + setFixedLocale(Locale.GERMANY) + val startOfToday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) + val expectedCalendar = GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.GERMANY) + expectedCalendar.timeInMillis = startOfToday + val startOfTodayCalendar = DateUtils.getStartOfTodayCalendar() + assertThat(expectedCalendar, equalTo(startOfTodayCalendar)) + } + @Test @Throws(Exception::class) fun testGetTodayWithOffset() { From c12a6c6a4d3d398d73b6889dc29f23e74d05c14b Mon Sep 17 00:00:00 2001 From: sgallese Date: Wed, 22 Sep 2021 19:48:30 -0700 Subject: [PATCH 5/8] Complete tests for DateUtils, move internal functions to private --- .../org/isoron/uhabits/core/utils/DateUtils.kt | 11 ++--------- .../isoron/uhabits/core/utils/DateUtilsTest.kt | 17 +++++++++++++++++ 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt index e812bc2ca..8fe65ce9d 100644 --- a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt +++ b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt @@ -214,13 +214,7 @@ abstract class DateUtils { @JvmStatic fun getStartOfTodayCalendarWithOffset(): GregorianCalendar = getCalendar(getStartOfTodayWithOffset()) - @JvmStatic - fun getTimeZone(): TimeZone { - return fixedTimeZone ?: TimeZone.getDefault() - } - - @JvmStatic - fun getTimezone(): TimeZone { + private fun getTimeZone(): TimeZone { return fixedTimeZone ?: TimeZone.getDefault() } @@ -236,8 +230,7 @@ abstract class DateUtils { startDayMinuteOffset = minuteOffset } - @JvmStatic - fun getLocale(): Locale { + private fun getLocale(): Locale { return fixedLocale ?: Locale.getDefault() } diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index a3388b4f7..9076c27d4 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -274,6 +274,23 @@ class DateUtilsTest : BaseUnitTest() { assertThat(truncate(field, t2, firstWeekday), equalTo(expected)) } + @Test + fun testTruncate_timestamp() { + val field = DateUtils.TruncateField.YEAR + val nonTruncatedDate = unixTime(2016, Calendar.MAY, 30) + val expected = Timestamp(unixTime(2016, Calendar.JANUARY, 1)) + assertThat(expected, equalTo(truncate(field, Timestamp(nonTruncatedDate), firstWeekday))) + } + + @Test + fun testGetUpcomingTimeInMillis() { + setFixedLocalTime(FIXED_LOCAL_TIME) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val expected = unixTime(2015, Calendar.JANUARY, 25, 10, 1) + val upcomingTimeMillis = DateUtils.getUpcomingTimeInMillis(10, 1) + assertThat(expected, equalTo(upcomingTimeMillis)) + } + @Test @Throws(Exception::class) fun testMillisecondsUntilTomorrow() { From aae85c11707e5022410df5549623304fad610ff2 Mon Sep 17 00:00:00 2001 From: sgallese Date: Sun, 3 Oct 2021 21:10:44 -0700 Subject: [PATCH 6/8] Rename variable --- .../jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt index 8fe65ce9d..7c2c0a4fd 100644 --- a/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt +++ b/uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/DateUtils.kt @@ -77,11 +77,11 @@ abstract class DateUtils { } @JvmStatic - fun getLocalTime(testTimeInMillis: Long? = null): Long { + fun getLocalTime(utcTimeInMillis: Long? = null): Long { if (fixedLocalTime != null) return fixedLocalTime as Long val tz = getTimeZone() - val now = testTimeInMillis ?: Date().time + val now = utcTimeInMillis ?: Date().time return now + tz.getOffset(now) } From 707b2b4380dc256c641d9fbc583ba4bc939560bf Mon Sep 17 00:00:00 2001 From: sgallese Date: Sun, 3 Oct 2021 21:19:04 -0700 Subject: [PATCH 7/8] Add test helper for hour offset --- .../uhabits/core/utils/DateUtilsTest.kt | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 9076c27d4..07c9dc631 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -144,9 +144,7 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTomorrowWithOffset_priorToOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val hourOffset = configureAndGetHourOffset() val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset, 0) val priorToOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset - 1, 0) setFixedLocalTime(priorToOffset) @@ -156,9 +154,7 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTomorrowWithOffset_afterOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val hourOffset = configureAndGetHourOffset() val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset, 0) val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) setFixedLocalTime(afterOffset) @@ -168,9 +164,7 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTodayWithOffset_priorToOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val hourOffset = configureAndGetHourOffset() val startOfYesterday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) val priorToOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset - 1, 0) setFixedLocalTime(priorToOffset) @@ -180,9 +174,7 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTodayWithOffset_afterOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - setFixedTimeZone(TimeZone.getTimeZone("GMT")) + val hourOffset = configureAndGetHourOffset() val startOfToday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) setFixedLocalTime(afterOffset) @@ -190,6 +182,13 @@ class DateUtilsTest : BaseUnitTest() { assertThat(startOfToday, equalTo(startOfTodayWithOffset)) } + private fun configureAndGetHourOffset(): Int { + val hourOffset = 3 + setStartDayOffset(hourOffset, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + return hourOffset + } + @Test fun testTruncate_dayOfWeek() { val field = DateUtils.TruncateField.WEEK_NUMBER From 4fbf8a8ca287c87b3d835cc646ba3dd48490dc36 Mon Sep 17 00:00:00 2001 From: sgallese Date: Sun, 3 Oct 2021 22:01:42 -0700 Subject: [PATCH 8/8] DRYer offset tests --- .../uhabits/core/utils/DateUtilsTest.kt | 113 +++++++++--------- 1 file changed, 59 insertions(+), 54 deletions(-) diff --git a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt index 07c9dc631..75280ab9b 100644 --- a/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt +++ b/uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/DateUtilsTest.kt @@ -127,16 +127,16 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfDay() { - val expectedStartOfDayUtc = unixTime(2017, Calendar.JANUARY, 1, 0, 0) - val laterInTheDayUtc = unixTime(2017, Calendar.JANUARY, 1, 20, 0) + val expectedStartOfDayUtc = fixedStartOfToday() + val laterInTheDayUtc = fixedStartOfTodayWithOffset(20) val startOfDay = DateUtils.getStartOfDay(laterInTheDayUtc) assertThat(expectedStartOfDayUtc, equalTo(startOfDay)) } @Test fun testGetStartOfToday() { - val expectedStartOfDayUtc = unixTime(2017, Calendar.JANUARY, 1, 0, 0) - val laterInTheDayUtc = unixTime(2017, Calendar.JANUARY, 1, 20, 0) + val expectedStartOfDayUtc = fixedStartOfToday() + val laterInTheDayUtc = fixedStartOfTodayWithOffset(20) setFixedLocalTime(laterInTheDayUtc) val startOfToday = DateUtils.getStartOfToday() assertThat(expectedStartOfDayUtc, equalTo(startOfToday)) @@ -144,49 +144,42 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTomorrowWithOffset_priorToOffset() { - val hourOffset = configureAndGetHourOffset() - val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset, 0) - val priorToOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset - 1, 0) - setFixedLocalTime(priorToOffset) - val startOfTomorrow = DateUtils.getStartOfTomorrowWithOffset() - assertThat(startOfTomorrowWithOffset, equalTo(startOfTomorrow)) + val priorToOffset = HOUR_OFFSET - 1 + testGetStartOfTomorrowWithOffset(priorToOffset) } @Test fun testGetStartOfTomorrowWithOffset_afterOffset() { - val hourOffset = configureAndGetHourOffset() - val startOfTomorrowWithOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset, 0) - val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) - setFixedLocalTime(afterOffset) - val startOfTomorrow = DateUtils.getStartOfTomorrowWithOffset() - assertThat(startOfTomorrowWithOffset, equalTo(startOfTomorrow)) + val afterOffset = HOUR_OFFSET + 1 - HOURS_IN_ONE_DAY + testGetStartOfTomorrowWithOffset(afterOffset) + } + + private fun testGetStartOfTomorrowWithOffset(startOfTodayOffset: Int) { + configureOffsetTest(startOfTodayOffset) + assertThat( + fixedStartOfTodayWithOffset(HOUR_OFFSET), + equalTo(DateUtils.getStartOfTomorrowWithOffset()) + ) } @Test fun testGetStartOfTodayWithOffset_priorToOffset() { - val hourOffset = configureAndGetHourOffset() - val startOfYesterday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) - val priorToOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset - 1, 0) - setFixedLocalTime(priorToOffset) - val startOfTodayWithOffset = DateUtils.getStartOfTodayWithOffset() - assertThat(startOfYesterday, equalTo(startOfTodayWithOffset)) + val priorToOffset = HOURS_IN_ONE_DAY + HOUR_OFFSET - 1 + testGetStartOfTodayWithOffset(priorToOffset) } @Test fun testGetStartOfTodayWithOffset_afterOffset() { - val hourOffset = configureAndGetHourOffset() - val startOfToday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) - val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) - setFixedLocalTime(afterOffset) - val startOfTodayWithOffset = DateUtils.getStartOfTodayWithOffset() - assertThat(startOfToday, equalTo(startOfTodayWithOffset)) + val afterOffset = HOUR_OFFSET + 1 + testGetStartOfTodayWithOffset(afterOffset) } - private fun configureAndGetHourOffset(): Int { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - setFixedTimeZone(TimeZone.getTimeZone("GMT")) - return hourOffset + private fun testGetStartOfTodayWithOffset(startOfTodayOffset: Int) { + configureOffsetTest(startOfTodayOffset) + assertThat( + fixedStartOfToday(), + equalTo(DateUtils.getStartOfTodayWithOffset()) + ) } @Test @@ -296,16 +289,16 @@ class DateUtilsTest : BaseUnitTest() { setFixedTimeZone(TimeZone.getTimeZone("GMT")) setFixedLocalTime(unixTime(2017, Calendar.JANUARY, 1, 23, 59)) assertThat(millisecondsUntilTomorrowWithOffset(), equalTo(DateUtils.MINUTE_LENGTH)) - setFixedLocalTime(unixTime(2017, Calendar.JANUARY, 1, 20, 0)) + setFixedLocalTime(fixedStartOfTodayWithOffset(20)) assertThat( millisecondsUntilTomorrowWithOffset(), equalTo(4 * DateUtils.HOUR_LENGTH) ) - setStartDayOffset(3, 30) + setStartDayOffset(HOUR_OFFSET, 30) setFixedLocalTime(unixTime(2017, Calendar.JANUARY, 1, 23, 59)) assertThat( millisecondsUntilTomorrowWithOffset(), - equalTo(3 * DateUtils.HOUR_LENGTH + 31 * DateUtils.MINUTE_LENGTH) + equalTo(HOUR_OFFSET * DateUtils.HOUR_LENGTH + 31 * DateUtils.MINUTE_LENGTH) ) setFixedLocalTime(unixTime(2017, Calendar.JANUARY, 2, 1, 0)) assertThat( @@ -327,30 +320,37 @@ class DateUtilsTest : BaseUnitTest() { @Test fun testGetStartOfTodayCalendarWithOffset_priorToOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - val priorToOffset = unixTime(2017, Calendar.JANUARY, 2, hourOffset - 1, 0) - setFixedLocalTime(priorToOffset) - setFixedLocale(Locale.GERMANY) - val startOfYesterday = unixTime(2017, Calendar.JANUARY, 2, 0, 0) - val expectedCalendar = GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.GERMANY) - expectedCalendar.timeInMillis = startOfYesterday - val startOfTodayCalendar = DateUtils.getStartOfTodayCalendar() - assertThat(expectedCalendar, equalTo(startOfTodayCalendar)) + val priorToOffset = HOUR_OFFSET - 1 + testGetStartOfTodayCalendarWithOffset(priorToOffset) } @Test fun testGetStartOfTodayCalendarWithOffset_afterOffset() { - val hourOffset = 3 - setStartDayOffset(hourOffset, 0) - val afterOffset = unixTime(2017, Calendar.JANUARY, 1, hourOffset + 1, 0) - setFixedLocalTime(afterOffset) + val afterOffset = HOUR_OFFSET + 1 + testGetStartOfTodayCalendarWithOffset(afterOffset) + } + + private fun testGetStartOfTodayCalendarWithOffset(startOfTodayOffset: Int) { + configureOffsetTest(startOfTodayOffset) setFixedLocale(Locale.GERMANY) - val startOfToday = unixTime(2017, Calendar.JANUARY, 1, 0, 0) val expectedCalendar = GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.GERMANY) - expectedCalendar.timeInMillis = startOfToday - val startOfTodayCalendar = DateUtils.getStartOfTodayCalendar() - assertThat(expectedCalendar, equalTo(startOfTodayCalendar)) + expectedCalendar.timeInMillis = fixedStartOfToday() + assertThat( + expectedCalendar, + equalTo(DateUtils.getStartOfTodayCalendar()) + ) + } + + private fun configureOffsetTest(startOfTodayOffset: Int) { + setStartDayOffset(HOUR_OFFSET, 0) + setFixedTimeZone(TimeZone.getTimeZone("GMT")) + setFixedLocalTime(fixedStartOfTodayWithOffset(startOfTodayOffset)) + } + + private fun fixedStartOfToday() = fixedStartOfTodayWithOffset(0) + + private fun fixedStartOfTodayWithOffset(hourOffset: Int): Long { + return unixTime(2017, Calendar.JANUARY, 1, hourOffset, 0) } @Test @@ -656,4 +656,9 @@ class DateUtilsTest : BaseUnitTest() { unixTime(2018, Calendar.APRIL, 1, 18, 0) ) } + + companion object { + const val HOUR_OFFSET = 3 + const val HOURS_IN_ONE_DAY = 24 + } }