Place MidnightTimer under test

uhabits-core/src/jvmMain/java/org/isoron/uhabits/core/utils/MidnightTimer.kt

@@ -39,11 +39,11 @@ open class MidnightTimer @Inject constructor() {
 
     @Synchronized fun onPause(): MutableList<Runnable>? = executor.shutdownNow()
 
-    @Synchronized fun onResume() {
+    @Synchronized fun onResume(delayOffsetInMillis: Long = DateUtils.MINUTE_LENGTH, testExecutor: ScheduledExecutorService? = null) {
-        executor = Executors.newSingleThreadScheduledExecutor()
+        executor = testExecutor ?: Executors.newSingleThreadScheduledExecutor()
         executor.scheduleAtFixedRate(
             { notifyListeners() },
-            DateUtils.millisecondsUntilTomorrowWithOffset() + 1000,
+            DateUtils.millisecondsUntilTomorrowWithOffset() + delayOffsetInMillis,
             DateUtils.DAY_LENGTH,
             TimeUnit.MILLISECONDS
         )

uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/BaseUnitTest.kt

@@ -95,15 +95,13 @@ open class BaseUnitTest {
     }
 
     fun unixTime(year: Int, month: Int, day: Int): Long {
-        val cal = getStartOfTodayCalendar()
+        return unixTime(year, month, day, 0, 0)
-        cal.set(year, month, day, 0, 0, 0)
-        return cal.timeInMillis
     }
 
-    open fun unixTime(year: Int, month: Int, day: Int, hour: Int, minute: Int): Long {
+    open fun unixTime(year: Int, month: Int, day: Int, hour: Int, minute: Int, milliseconds: Long = 0): Long {
         val cal = getStartOfTodayCalendar()
         cal.set(year, month, day, hour, minute)
-        return cal.timeInMillis
+        return cal.timeInMillis + milliseconds
     }
 
     fun timestamp(year: Int, month: Int, day: Int): Timestamp {

uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/reminders/ReminderSchedulerTest.kt

@@ -138,7 +138,7 @@ class ReminderSchedulerTest : BaseUnitTest() {
         reminderScheduler.schedule(habit)
     }
 
-    override fun unixTime(year: Int, month: Int, day: Int, hour: Int, minute: Int): Long {
+    override fun unixTime(year: Int, month: Int, day: Int, hour: Int, minute: Int, milliseconds: Long): Long {
         val cal: Calendar = getStartOfTodayCalendar()
         cal[year, month, day, hour] = minute
         return cal.timeInMillis

uhabits-core/src/jvmTest/java/org/isoron/uhabits/core/utils/MidnightTimerTest.kt

@@ -0,0 +1,45 @@
+package org.isoron.uhabits.core.utils
+
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import org.isoron.uhabits.core.BaseUnitTest
+import org.junit.Test
+import java.util.Calendar
+import java.util.TimeZone
+import java.util.concurrent.Executors
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+import kotlin.test.assertEquals
+
+class MidnightTimerTest : BaseUnitTest() {
+
+    @Test
+    fun testMidnightTimer_notifyListener_atMidnight() = runBlocking {
+        // Given
+        val executor = Executors.newSingleThreadScheduledExecutor()
+        val dispatcher = executor.asCoroutineDispatcher()
+
+        withContext(dispatcher) {
+            DateUtils.setFixedTimeZone(TimeZone.getTimeZone("GMT"))
+            DateUtils.setFixedLocalTime(unixTime(2017, Calendar.JANUARY, 1, 23, 59, DateUtils.MINUTE_LENGTH - 1))
+
+            val suspendedListener = suspendCoroutine<Boolean> { continuation ->
+                val listener = object : MidnightTimer.MidnightListener {
+                    override fun atMidnight() {
+                        continuation.resume(true)
+                    }
+                }
+
+                MidnightTimer().apply {
+                    addListener(listener)
+                    // When
+                    onResume(1, executor)
+                }
+            }
+
+            // Then
+            assertEquals(true, suspendedListener)
+        }
+    }
+}