Use nanosleep in runBlocking's delay on Native (#1228)

Fixes #1225

Author: qwwdfsad

kotlinx-coroutines-core/native/src/Builders.kt

@@ -4,6 +4,8 @@
 
 package kotlinx.coroutines
 
+import kotlinx.cinterop.*
+import platform.posix.*
 import kotlin.coroutines.*
 
 /**
@@ -56,21 +58,24 @@ private class BlockingCoroutine<T>(
         get() = false // it throws exception to parent instead of cancelling it
 
     @Suppress("UNCHECKED_CAST")
-    fun joinBlocking(): T {
+    fun joinBlocking(): T = memScoped {
         try {
             eventLoop?.incrementUseCount()
+            val timespec = alloc<timespec>()
             while (true) {
                 val parkNanos = eventLoop?.processNextEvent() ?: Long.MAX_VALUE
                 // note: process next even may loose unpark flag, so check if completed before parking
                 if (isCompleted) break
-                // todo: LockSupport.parkNanos(this, parkNanos)
+                timespec.tv_sec = parkNanos / 1000000000L // 1e9 ns -> sec
+                timespec.tv_nsec = (parkNanos % 1000000000L).convert() // % 1e9
+                nanosleep(timespec.ptr, null)
             }
         } finally { // paranoia
             eventLoop?.decrementUseCount()
         }
         // now return result
-        val state = this.state
+        val state = state
         (state as? CompletedExceptionally)?.let { throw it.cause }
-        return state as T
+        state as T
     }
 }

kotlinx-coroutines-core/native/test/DelayExceptionTest.kt

@@ -5,10 +5,9 @@
 package kotlinx.coroutines
 
 import kotlin.coroutines.*
-import kotlin.test.Test
-import kotlin.test.assertTrue
+import kotlin.test.*
 
-class DelayExceptionTest {
+class DelayExceptionTest : TestBase() {
     private object Dispatcher : CoroutineDispatcher() {
         override fun isDispatchNeeded(context: CoroutineContext): Boolean = true
         override fun dispatch(context: CoroutineContext, block: Runnable) { block.run() }
@@ -25,4 +24,16 @@ class DelayExceptionTest {
 
         assertTrue(exception is IllegalStateException)
     }
+
+    @Test
+    fun testMaxDelay() = runBlocking {
+        expect(1)
+        val job = launch {
+            expect(2)
+            delay(Long.MAX_VALUE)
+        }
+        yield()
+        job.cancel()
+        finish(3)
+    }
 }