Restore jdk8 examples after project structure changes

Author: qwwdfsad

integration/kotlinx-coroutines-jdk8/test/ChannelsTest.kt renamed to integration/kotlinx-coroutines-jdk8/test/channels8/ChannelsTest.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.delay
+import kotlinx.coroutines.experimental.future.future
+
+
+fun main(args: Array<String>) {
+    val f = future {
+        try {
+            log("Started f")
+            delay(500)
+            log("Slept 500 ms #1")
+            delay(500)
+            log("Slept 500 ms #2")
+            delay(500)
+            log("Slept 500 ms #3")
+            delay(500)
+            log("Slept 500 ms #4")
+            delay(500)
+            log("Slept 500 ms #5")
+        } catch(e: Exception) {
+            log("Aborting because of $e")
+        }
+    }
+    Thread.sleep(1200)
+    f.cancel(false)
+}

integration/kotlinx-coroutines-jdk8/test/examples/CancelFuture-example.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.Job
+import kotlinx.coroutines.experimental.delay
+import kotlinx.coroutines.experimental.future.future
+import java.util.concurrent.CancellationException
+
+fun main(args: Array<String>) {
+    val job = Job()
+    log("Starting futures f && g")
+    val f = future(job) {
+        log("Started f")
+        delay(500)
+        log("f should not execute this line")
+    }
+    val g = future(job) {
+        log("Started g")
+        try {
+            delay(500)
+        } finally {
+            log("g is executing finally!")
+        }
+        log("g should not execute this line")
+    }
+    log("Started futures f && g... will not wait -- cancel them!!!")
+    job.cancel(CancellationException("I don't want it"))
+    check(f.isCancelled)
+    check(g.isCancelled)
+    log("f result = ${Try<Unit> { f.get() }}")
+    log("g result = ${Try<Unit> { g.get() }}")
+    Thread.sleep(1000L)
+    log("Nothing executed!")
+}

integration/kotlinx-coroutines-jdk8/test/examples/ExplicitJob-example.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.CommonPool
+import kotlinx.coroutines.experimental.async
+import kotlinx.coroutines.experimental.delay
+import kotlinx.coroutines.experimental.future.asCompletableFuture
+import java.util.concurrent.TimeUnit
+
+fun main(args: Array<String>)  {
+    log("Started")
+    val deferred = async(CommonPool) {
+        log("Busy...")
+        delay(1, TimeUnit.SECONDS)
+        log("Done...")
+        42
+    }
+    val future = deferred.asCompletableFuture()
+    log("Got ${future.get()}")
+}
+
+

integration/kotlinx-coroutines-jdk8/test/examples/ToFuture-example.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import java.text.*
+import java.util.*
+
+public class Try<out T> private constructor(private val _value: Any?) {
+    private class Fail(val exception: Throwable) {
+        override fun toString(): String = "Failure[$exception]"
+    }
+    public companion object {
+        public operator fun <T> invoke(block: () -> T): Try<T> =
+            try { Success(block()) } catch(e: Throwable) { Failure<T>(e) }
+        public fun <T> Success(value: T) = Try<T>(value)
+        public fun <T> Failure(exception: Throwable) = Try<T>(Fail(exception))
+    }
+    @Suppress("UNCHECKED_CAST")
+    public val value: T get() = if (_value is Fail) throw _value.exception else _value as T
+    public val exception: Throwable? get() = (_value as? Fail)?.exception
+    override fun toString(): String = _value.toString()
+}
+
+fun log(msg: String) = println("${SimpleDateFormat("yyyyMMdd-HHmmss.sss").format(Date())} [${Thread.currentThread().name}] $msg")

integration/kotlinx-coroutines-jdk8/test/examples/Try.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.future.await
+import kotlinx.coroutines.experimental.runBlocking
+import java.util.concurrent.CompletableFuture
+
+fun main(args: Array<String>) {
+    // Let's assume that we have a future coming from some 3rd party API
+    val future: CompletableFuture<Int> = CompletableFuture.supplyAsync {
+        Thread.sleep(1000L) // imitate some long-running computation, actually
+        42
+    }
+    // now let's launch a coroutine and await for this future inside it
+    runBlocking {
+        println("We can do something else, while we are waiting for future...")
+        println("We've got ${future.await()} from the future!")
+    }
+}

integration/kotlinx-coroutines-jdk8/test/examples/simple-example-1.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.delay
+import kotlinx.coroutines.experimental.future.future
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+
+// this function returns a CompletableFuture using Kotlin coroutines
+fun supplyTheAnswerAsync(): CompletableFuture<Int> = future {
+    println("We might be doing some asynchronous IO here or something else...")
+    delay(1, TimeUnit.SECONDS) // just do a non-blocking delay
+    42 // The answer!
+}
+
+fun main(args: Array<String>) {
+    // We can use `supplyTheAnswerAsync` just like any other future-supplier function
+    val future = supplyTheAnswerAsync()
+    println("The answer is ${future.get()}")
+}

integration/kotlinx-coroutines-jdk8/test/examples/simple-example-2.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.future.await
+import kotlinx.coroutines.experimental.future.future
+import java.util.concurrent.CompletableFuture
+
+fun main(args: Array<String>) {
+    // this example shows how easy it is to perform multiple async operations with coroutines
+    val future = future {
+        (1..5).map { // loops are no problem at all
+            startLongAsyncOperation(it).await() // suspend while the long method is running
+        }.joinToString("\n")
+    }
+    println("We have a long-running computation in background, let's wait for its result...")
+    println(future.get())
+}
+
+fun startLongAsyncOperation(num: Int): CompletableFuture<String> =
+    CompletableFuture.supplyAsync {
+        Thread.sleep(1000L) // imitate some long-running computation, actually
+        "$num" // and return a number converted to string
+}

integration/kotlinx-coroutines-jdk8/test/examples/simple-example-3.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental.examples
+
+import kotlinx.coroutines.experimental.*
+import kotlinx.coroutines.experimental.future.*
+
+fun main(args: Array<String>) {
+    fun slow(s: String) = future {
+        delay(500L)
+        s
+    }
+    val f = future<String> {
+        log("Started f")
+        val a = slow("A").await()
+        log("a = $a")
+        withTimeout(1000L) {
+            val b = slow("B").await()
+            log("b = $b")
+        }
+        try {
+            withTimeout(750L) {
+                val c = slow("C").await()
+                log("c = $c")
+                val d = slow("D").await()
+                log("d = $d")
+            }
+        } catch (ex: CancellationException) {
+            log("timed out with $ex")
+        }
+        val e = slow("E").await()
+        log("e = $e")
+        "done"
+    }
+    log("f.get() = ${f.get()}")
+}