1 files changed, 153 insertions, 0 deletions
diff --git a/integration/kotlinx-coroutines-play-services/test/TaskTest.kt b/integration/kotlinx-coroutines-play-services/test/TaskTest.kt
new file mode 100644
index 00000000..b87a2954
--- /dev/null
+++ b/integration/kotlinx-coroutines-play-services/test/TaskTest.kt
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.tasks
+
+import com.google.android.gms.tasks.*
+import kotlinx.coroutines.*
+import org.junit.*
+import org.junit.Test
+import java.util.concurrent.locks.*
+import kotlin.concurrent.*
+import kotlin.test.*
+
+class TaskTest : TestBase() {
+    @Before
+    fun setup() {
+        ignoreLostThreads("ForkJoinPool.commonPool-worker-")
+    }
+
+    @Test
+    fun testCompletedDeferredAsTask() = runTest {
+        expect(1)
+        val deferred = async(start = CoroutineStart.UNDISPATCHED) {
+            expect(2) // Completed immediately
+            "OK"
+        }
+        expect(3)
+        val task = deferred.asTask()
+        assertEquals("OK", task.await())
+        finish(4)
+    }
+
+    @Test
+    fun testDeferredAsTask() = runTest {
+        expect(1)
+        val deferred = async {
+            expect(3) // Completed later
+            "OK"
+        }
+        expect(2)
+        val task = deferred.asTask()
+        assertEquals("OK", task.await())
+        finish(4)
+    }
+
+    @Test
+    fun testCancelledAsTask() {
+        val deferred = GlobalScope.async {
+            delay(100)
+        }.apply { cancel() }
+
+        val task = deferred.asTask()
+        try {
+            runTest { task.await() }
+        } catch (e: Exception) {
+            assertTrue(e is CancellationException)
+            assertTrue(task.isCanceled)
+        }
+    }
+
+    @Test
+    fun testThrowingAsTask() {
+        val deferred = GlobalScope.async {
+            throw TestException("Fail")
+        }
+
+        val task = deferred.asTask()
+        runTest(expected = { it is TestException }) {
+            task.await()
+        }
+    }
+
+    @Test
+    fun testStateAsTask() = runTest {
+        val lock = ReentrantLock().apply { lock() }
+
+        val deferred: Deferred<Int> = Tasks.call {
+            lock.withLock { 42 }
+        }.asDeferred()
+
+        assertFalse(deferred.isCompleted)
+        lock.unlock()
+
+        assertEquals(42, deferred.await())
+        assertTrue(deferred.isCompleted)
+    }
+
+    @Test
+    fun testTaskAsDeferred() = runTest {
+        val deferred = Tasks.forResult(42).asDeferred()
+        assertEquals(42, deferred.await())
+    }
+
+    @Test
+    fun testNullResultTaskAsDeferred() = runTest {
+        assertNull(Tasks.forResult(null).asDeferred().await())
+    }
+
+    @Test
+    fun testCancelledTaskAsDeferred() = runTest {
+        val deferred = Tasks.forCanceled<Int>().asDeferred()
+
+        assertTrue(deferred.isCancelled)
+        try {
+            deferred.await()
+            fail("deferred.await() should be cancelled")
+        } catch (e: Exception) {
+            assertTrue(e is CancellationException)
+        }
+    }
+
+    @Test
+    fun testFailedTaskAsDeferred() = runTest {
+        val deferred = Tasks.forException<Int>(TestException("something went wrong")).asDeferred()
+
+        assertTrue(deferred.isCancelled && deferred.isCompleted)
+        val completionException = deferred.getCompletionExceptionOrNull()!!
+        assertTrue(completionException is TestException)
+        assertEquals("something went wrong", completionException.message)
+
+        try {
+            deferred.await()
+            fail("deferred.await() should throw an exception")
+        } catch (e: Exception) {
+            assertTrue(e is TestException)
+            assertEquals("something went wrong", e.message)
+        }
+    }
+
+    @Test
+    fun testFailingTaskAsDeferred() = runTest {
+        val lock = ReentrantLock().apply { lock() }
+
+        val deferred: Deferred<Int> = Tasks.call {
+            lock.withLock { throw TestException("something went wrong") }
+        }.asDeferred()
+
+        assertFalse(deferred.isCompleted)
+        lock.unlock()
+
+        try {
+            deferred.await()
+            fail("deferred.await() should throw an exception")
+        } catch (e: Exception) {
+            assertTrue(e is TestException)
+            assertEquals("something went wrong", e.message)
+            assertSame(e.cause, deferred.getCompletionExceptionOrNull()) // debug mode stack augmentation
+        }
+    }
+
+    class TestException(message: String) : Exception(message)
+}