Adding a test-helper class TestCoroutineContext.

README.md

@@ -92,6 +92,14 @@ buildscript {
 }
 ```
 
+Make sure that you have either `jcenter()` or `mavenCentral()` in the list of repositories:
+
+```
+repository {
+    jcenter()
+}
+```
+
 ### Kotlin/JS
 
 Use `org.jetbrains.kotlinx:kotlinx-coroutines-core-js:<version>` artifact in your Gradle/Maven dependencies 
@@ -109,11 +117,22 @@ To avoid field overloading by type during obfuscation, add this to your config:
 }
 ```
 
+## Building 
+
+This library is built with Gradle. To build it, use `./gradlew build`. 
+You can import this project into IDEA, but you have to delegate build actions
+to Gradle (in Preferences -> Build, Execution, Deployment -> Build Tools -> Gradle -> Runner)
+
+### Requirements
+
+* JDK >= 1.8 referred to by the `JAVA_HOME` environment variable.
+* JDK 1.6 referred to by the `JDK_16` environment variable.
+
 ## Contributions and releases
 
 All development (both new features and bug fixes) is performed in `develop` branch. 
 This way `master` sources always contain sources of the most recently released version.
-Please send PRs with bug fixes to `develop` branch
+Please send PRs with bug fixes to `develop` branch.
 Fixes to documentation in markdown files are an exception to this rule. They are updated directly in `master`.
 
 The `develop` branch is pushed to `master` during release.

benchmarks/build.gradle

@@ -8,6 +8,7 @@ repositories {
 
 dependencies {
     jmh 'com.typesafe.akka:akka-actor:2.0.2'
+    jmh project(':kotlinx-coroutines-core-common')
     jmh project(':kotlinx-coroutines-core')
     jmh project(':kotlinx-coroutines-core').sourceSets.test.output
     jmh project(':kotlinx-coroutines-io')

benchmarks/src/jmh/kotlin/benchmarks/CancellableContinuationBenchmark.kt

@@ -0,0 +1,52 @@
+package benchmarks
+
+import kotlinx.coroutines.experimental.*
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+@Fork(2)
+open class CancellableContinuationBenchmark {
+
+    @Benchmark
+    fun awaitWithSuspension(): Int {
+        val deferred = CompletableDeferred<Int>()
+        return run(allowSuspend = true) { deferred.await() }
+    }
+
+    @Benchmark
+    fun awaitNoSuspension(): Int {
+        val deferred = CompletableDeferred(1)
+        return run { deferred.await() }
+    }
+
+    private fun run(allowSuspend: Boolean = false, block: suspend () -> Int): Int {
+        val value = block.startCoroutineUninterceptedOrReturn(EmptyContinuation)
+        if (value === COROUTINE_SUSPENDED) {
+            if (!allowSuspend) {
+                throw IllegalStateException("Unexpected suspend")
+            } else {
+                return -1
+            }
+        }
+
+        return value as Int
+    }
+
+    object EmptyContinuation : Continuation<Int> {
+        override val context: CoroutineContext
+            get() = EmptyCoroutineContext
+
+        override fun resume(value: Int) {
+        }
+
+        override fun resumeWithException(exception: Throwable) {
+        }
+    }
+}

benchmarks/src/jmh/kotlin/benchmarks/ChannelCopyBenchmark.kt

@@ -169,7 +169,7 @@ open class ChannelCopyBenchmark {
         val pIn = ByteChannel(true)
         val pOut = ByteChannel(true)
 
-        launch(coroutineContext) {
+        launch(this.coroutineContext) {
             pOut.joinTo(pIn, true)
         }
 
@@ -193,7 +193,7 @@ open class ChannelCopyBenchmark {
         val pIn = ByteChannel(true)
         val pOut = ByteChannel(true)
 
-        launch(coroutineContext) {
+        launch(this.coroutineContext) {
             pOut.joinTo(pIn, true)
         }
 
@@ -217,7 +217,7 @@ open class ChannelCopyBenchmark {
         val pIn = ByteChannel(true)
         val pOut = ByteChannel(true)
 
-        launch(coroutineContext) {
+        launch(this.coroutineContext) {
             pOut.copyTo(pIn)
             pIn.close()
         }
@@ -242,7 +242,7 @@ open class ChannelCopyBenchmark {
         val pIn = ByteChannel(true)
         val pOut = ByteChannel(true)
 
-        launch(coroutineContext) {
+        launch(this.coroutineContext) {
             pOut.copyTo(pIn)
             pIn.close()
         }
@@ -298,7 +298,7 @@ open class ChannelCopyBenchmark {
 
     @Benchmark
     fun runBlockingAndLaunch() = runBlocking {
-        launch(coroutineContext) {
+        launch(this.coroutineContext) {
             yield()
         }
 

build.gradle

@@ -1,31 +1,49 @@
-allprojects {
-    group = 'org.jetbrains.kotlinx'
-    def deployVersion = properties['DeployVersion']
-    if (deployVersion != null) version = deployVersion
-}
-
 buildscript {
-    if (rootProject.properties['kotlinSnapshot'] != null) {
+    ext.useKotlinSnapshot = rootProject.properties['kotlinSnapshot'] != null
+    if (useKotlinSnapshot) {
         ext.kotlin_version = '1.2-SNAPSHOT'
         repositories {
             maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
         }
     }
     repositories {
         jcenter()
-        maven { url "http://kotlin.bintray.com/kotlinx" }
-        maven { url "http://kotlin.bintray.com/kotlin-dev" }
+        maven { url "https://kotlin.bintray.com/kotlinx" }
+        maven { url "https://kotlin.bintray.com/kotlin-dev" }
+        maven { url "https://jetbrains.bintray.com/kotlin-native-dependencies" }
         maven { url "https://plugins.gradle.org/m2/" }
     }
+    configurations.classpath {
+        resolutionStrategy {
+            eachDependency { DependencyResolveDetails details ->
+                if (details.requested.group == 'org.jetbrains.kotlin' && details.requested.name != 'kotlin-native-gradle-plugin') {
+                    // fix version of all dependencies from org.jetbrains.kotlin group
+                    // even when other dependencies require other versions indirectly,
+                    // except kotlin-native, which has its own pre-release versioning
+                    details.useVersion kotlin_version
+                }
+            }
+        }
+    }
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-native-gradle-plugin:$kotlin_native_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
         classpath "org.jetbrains.kotlinx:atomicfu-gradle-plugin:$atomicFU_version"
         classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$bintray_version"
         classpath "com.moowork.gradle:gradle-node-plugin:$gradle_node_version"
     }
 }
 
+allprojects {
+    def deployVersion = properties['DeployVersion']
+    if (deployVersion != null) version = deployVersion
+    if (useKotlinSnapshot) {
+        kotlin_version = '1.2-SNAPSHOT'
+    }
+}
+
+
 // Report Kotlin compiler version when building project
 println("Using Kotlin compiler version: $org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION")
 
@@ -36,6 +54,7 @@ def sourceless = ['site']
 static def platformOf(project) {
     if (project.name.endsWith("-common")) return "common"
     if (project.name.endsWith("-js")) return "js"
+    if (project.name.endsWith("-native")) return "native"
     return "jvm"
 }
 
@@ -44,95 +63,36 @@ static def platformLib(base, platform) {
     return "$base-$platform"
 }
 
-configure(subprojects.findAll { !sourceless.contains(it.name)  }) {
-    def platform = platformOf(it)
-    apply plugin: "kotlin-platform-$platform"
-
-    if (platform == "jvm") {
-        sourceCompatibility = 1.6
-        targetCompatibility = 1.6
-    }
-
-    kotlin.experimental.coroutines "enable"
-
-    if (platform == "js") {
-        tasks.withType(compileKotlin2Js.getClass()) {
-            kotlinOptions {
-                moduleKind = "umd"
-                sourceMap = true
-                metaInfo = true
-                // drop -js suffix from outputFile
-                def baseName = project.name - "-js"
-                outputFile = new File(outputFile.parent, baseName + ".js")
-            }
-        }
-    }
-
-    tasks.withType(Test) {
-        testLogging {
-            showStandardStreams = true
-            events "passed", "failed"
+subprojects {
+    if (useKotlinSnapshot) {
+        repositories {
+            maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
         }
-        def stressTest = project.properties['stressTest']
-        if (stressTest != null) systemProperties['stressTest'] = stressTest
     }
-
-    repositories {
-        jcenter()
-        maven { url "http://kotlin.bintray.com/kotlinx" }
-        maven { url "https://dl.bintray.com/devexperts/Maven/" }
-    }
-
-    def kotlin_stdlib = platformLib("kotlin-stdlib", platform)
-    def kotlin_test = platformLib("kotlin-test", platform)
-
-    dependencies {
-        compile "org.jetbrains.kotlin:$kotlin_stdlib:$kotlin_version"
-        testCompile "org.jetbrains.kotlin:$kotlin_test:$kotlin_version"
-    }
-
-    if (platform == "common") {
-        dependencies {
-            testCompile "org.jetbrains.kotlin:kotlin-test-annotations-common:$kotlin_version"
+    configurations.all {
+        resolutionStrategy {
+            eachDependency { DependencyResolveDetails details ->
+                if (details.requested.group == 'org.jetbrains.kotlin') {
+                    details.useVersion kotlin_version
+                }
+            }
         }
     }
+}
 
-    if (platform == "jvm") {
-        dependencies {
-            testCompile "junit:junit:$junit_version"
-            testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
-        }
-    }
+configure(subprojects.findAll { !sourceless.contains(it.name)  }) {
+    def platform = platformOf(it)
+    apply from: rootProject.file("gradle/compile-${platform}.gradle")
 }
 
 // --------------- Configure sub-projects that are part of the library ---------------
 
 def internal = sourceless + ['benchmarks', 'knit', 'js-stub']
 
-// configure atomicfu for JVM modules
-configure(subprojects.findAll { !internal.contains(it.name) && platformOf(it) == "jvm" }) {
-    apply plugin: 'kotlinx-atomicfu'
-
-    dependencies {
-        compileOnly "org.jetbrains.kotlinx:atomicfu:$atomicFU_version"
-        testCompile "org.jetbrains.kotlinx:atomicfu:$atomicFU_version"
-    }
-
-    atomicFU {
-        inputFiles = sourceSets.main.output.classesDirs
-        outputDir = file("$buildDir/classes-atomicfu/main")
-        classPath = sourceSets.main.runtimeClasspath
-    }
-
-    jar {
-        mainSpec.sourcePaths.clear() // hack to clear existing paths
-        from files(atomicFU.outputs, sourceSets.main.output.resourcesDir)
-    }
-
-    test {
-        classpath = files(configurations.testRuntime, atomicFU.outputs, sourceSets.test.output.classesDirs,
-                sourceSets.main.output.resourcesDir)
-    }
+// configure atomicfu
+configure(subprojects.findAll { !internal.contains(it.name) }) {
+    def platform = platformOf(it)
+    apply from: rootProject.file("gradle/atomicfu-${platform}.gradle")
 }
 
 // configure dependencies on core
@@ -155,7 +115,8 @@ configure(subprojects.findAll { !internal.contains(it.name) && it.name != 'kotli
 
 // --------------- Configure sub-projects that are published ---------------
 
-def unpublished = internal + ['kotlinx-coroutines-rx-example', 'example-frontend-js']
+// todo: native is not published yet
+def unpublished = internal + ['kotlinx-coroutines-rx-example', 'example-frontend-js', 'kotlinx-coroutines-core-native']
 
 def core_docs_url = "https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/"
 def core_docs_file = "$projectDir/core/kotlinx-coroutines-core/build/dokka/kotlinx-coroutines-core/package-list"