Update kotlintest

build.gradle

@@ -20,7 +20,9 @@ buildscript {
         gradleVersion = '4.10'
         gradleVersionsPluginVersion = '0.20.0'
         javaVersion = JavaVersion.VERSION_1_7
-        kotlinTestVersion = '2.0.7'
+        jUnitVersion = '4.12'
+        jUnitVintageVersion = '5.2.0'
+        kotlinTestVersion = '3.1.5'
         kotlinVersion = '1.3.11'
         daggerVersion = '2.17'
         kotlinxCoroutinesVersion = '1.1.0'
@@ -155,6 +157,7 @@ subprojects { project ->
     compileKotlin.kotlinOptions.freeCompilerArgs += ["-Xskip-runtime-version-check"]
 
     test {
+        useJUnitPlatform()
         testLogging {
             exceptionFormat 'full'
             events "passed", "skipped", "failed", "standardOut", "standardError"
@@ -233,15 +236,15 @@ dependencyUpdates {
             .findAll { dependency -> dependenciesToCheck.any { it == "${dependency.group}:${dependency.name}" } }
 
         final isRejected = dependencies
-            .any { dependency -> disallowedQualifiers.any(isDisallowed(dependency)) }
+                .any { dependency -> disallowedQualifiers.any(isDisallowed(dependency)) }
 
         if (isRejected) {
             final title = "\nError: Kotlin and Coroutines must depends on release version!"
             final message = dependencies
-                .inject(title) { acc, dependency ->
-                    "$acc\n${dependency.group}:${dependency.name}:${dependency.version}"
-                }
-            
+                    .inject(title) { acc, dependency ->
+                "$acc\n${dependency.group}:${dependency.name}:${dependency.version}"
+            }
+
             throw new GradleException(message)
         }
     }

gradle.properties

@@ -5,6 +5,8 @@ VERSION_NAME=0.9.0-SNAPSHOT
 org.gradle.jvmargs=-Xmx4g
 # Kotlin configuration
 kotlin.incremental=true
+# Kotlin Test configuration
+kotlintest.parallelism=2
 # Pomfile definitions
 POM_DESCRIPTION=Functional companion to Kotlin's Standard Library
 POM_URL=https://github.com/arrow-kt/arrow/

modules/ank/arrow-ank/src/main/kotlin/arrow/ank/interpreter.kt

@@ -9,9 +9,7 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentMap
-import javax.script.ScriptContext
-import javax.script.ScriptEngine
-import javax.script.ScriptEngineManager
+import javax.script.*
 
 val extensionMappings = mapOf(
   "java" to "java",
@@ -195,19 +193,19 @@ fun <F> monadDeferInterpreter(MF: MonadDefer<F>): AnkOps<F> = object : AnkOps<F>
   }
 
   override fun replaceAnkToLang(content: Sequence<String>, compiledSnippets: Sequence<Snippet>): Sequence<String> =
-    sequenceOf(compiledSnippets.foldLeft(content.joinToString("\n")) { content, snippet ->
+    sequenceOf(compiledSnippets.foldLeft(content.joinToString("\n")) { snippetContent, snippet ->
       snippet.result.fold(
-        { content.replace(snippet.fence, "{: data-executable='true'}\n\n```${snippet.lang}\n${snippet.code}\n```") },
+        { snippetContent.replace(snippet.fence, "{: data-executable='true'}\n\n```${snippet.lang}\n${snippet.code}\n```") },
         {
           when {
             // these are extensions declared in type classes that should be removed since the extension generator
             // processor is the one in charge of projecting those examples in the generated markdown files
-            snippet.isPlaygroundExtension -> content.replace(snippet.fence, it)
+            snippet.isPlaygroundExtension -> snippetContent.replace(snippet.fence, it)
             // a regular playground
-            snippet.isPlayground -> content.replace(snippet.fence, "{: data-executable='true'}\n\n```${snippet.lang}\n${snippet.code}\n$it\n```")
-            snippet.isReplace -> content.replace(snippet.fence, it)
-            snippet.isOutFile -> content.replace(snippet.fence, "")
-            else -> content.replace(snippet.fence, "```${snippet.lang}\n" + snippet.code + "\n" + it + "\n```")
+            snippet.isPlayground -> snippetContent.replace(snippet.fence, "{: data-executable='true'}\n\n```${snippet.lang}\n${snippet.code}\n$it\n```")
+            snippet.isReplace -> snippetContent.replace(snippet.fence, it)
+            snippet.isOutFile -> snippetContent.replace(snippet.fence, "")
+            else -> snippetContent.replace(snippet.fence, "```${snippet.lang}\n" + snippet.code + "\n" + it + "\n```")
           }
         }
       )

modules/aql/arrow-query-language/build.gradle

@@ -6,7 +6,9 @@ dependencies {
     kaptTest project(':arrow-meta')
     compileOnly project(':arrow-meta')
     testCompileOnly project(':arrow-meta')
-    testCompile "io.kotlintest:kotlintest:$kotlinTestVersion"
+    testRuntime("org.junit.vintage:junit-vintage-engine:$jUnitVintageVersion")
+    testCompile "io.kotlintest:kotlintest-runner-junit4:$kotlinTestVersion"
+
     testCompile project(':arrow-test')
 }
 

modules/aql/arrow-query-language/src/test/kotlin/arrow/aql/tests/AQLTests.kt

@@ -1,34 +1,33 @@
 package arrow.aql.tests
 
 import arrow.aql.Ord
-import arrow.aql.extensions.id.select.value
-import arrow.aql.extensions.list.count.count
-import arrow.aql.extensions.list.count.value
 import arrow.aql.extensions.list.from.join
 import arrow.aql.extensions.list.groupBy.groupBy
+import arrow.aql.extensions.list.select.query
 import arrow.aql.extensions.list.orderBy.orderBy
 import arrow.aql.extensions.list.orderBy.orderMap
-import arrow.aql.extensions.list.select.query
-import arrow.aql.extensions.list.select.value
+import arrow.aql.extensions.list.orderBy.value
 import arrow.aql.extensions.list.sum.sum
+import arrow.aql.extensions.list.sum.value
 import arrow.aql.extensions.list.union.union
 import arrow.aql.extensions.list.where.where
 import arrow.aql.extensions.list.where.whereSelection
+import arrow.aql.extensions.list.count.count
 import arrow.aql.extensions.listk.select.select
 import arrow.aql.extensions.listk.select.selectAll
+import arrow.aql.extensions.listk.select.value
 import arrow.aql.extensions.option.select.query
 import arrow.aql.extensions.option.select.select
 import arrow.aql.extensions.option.select.value
-import arrow.core.Id
 import arrow.core.Option
 import arrow.core.Some
 import arrow.core.extensions.order
 import arrow.test.UnitSpec
-import io.kotlintest.KTestJUnitRunner
-import io.kotlintest.matchers.shouldBe
+import io.kotlintest.shouldBe
+import io.kotlintest.runner.junit4.KotlinTestRunner
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class AQLTests : UnitSpec() {
 
   init {
@@ -47,7 +46,7 @@ class AQLTests : UnitSpec() {
 
     "AQL is able to `select count`" {
       listOf(1, 2, 3).query { select { this } }.count()
-        .value() shouldBe 3L
+        .value() shouldBe listOf(3L)
     }
 
     "AQL is able to `select`, transform and filter data with `where`" {
@@ -76,7 +75,7 @@ class AQLTests : UnitSpec() {
       val jack = Student("Jack", 32)
       listOf(john, jane, jack).query {
         selectAll() groupBy { age }
-      }.value() shouldBe Id(mapOf(30 to listOf(john), 32 to listOf(jane, jack)))
+      }.value() shouldBe mapOf(30 to listOf(john), 32 to listOf(jane, jack))
     }
 
     data class Student(val name: String, val age: Int)
@@ -86,7 +85,7 @@ class AQLTests : UnitSpec() {
     val jack = Student("Jack", 32)
     val chris = Student("Chris", 40)
 
-    "AQL is able to `groupBy`" {
+    "AQL is able to filter using `where` and then `groupBy`" {
       listOf(john, jane, jack).query {
         selectAll() where { age > 30 } groupBy { age }
       }.value() shouldBe mapOf(32 to listOf(jane, jack))

modules/core/arrow-core-data/build.gradle

@@ -5,7 +5,8 @@ dependencies {
     kaptTest project(':arrow-meta')
     compileOnly project(':arrow-meta')
     testCompileOnly project(':arrow-meta')
-    testCompile "io.kotlintest:kotlintest:$kotlinTestVersion"
+    testRuntime("org.junit.vintage:junit-vintage-engine:$jUnitVintageVersion")
+    testCompile "io.kotlintest:kotlintest-runner-junit4:$kotlinTestVersion"
     testCompile project(':arrow-test')
     testCompile project(':arrow-syntax')
     testCompile project(':arrow-core-extensions')

modules/core/arrow-core-data/src/main/kotlin/arrow/core/Id.kt

@@ -2,14 +2,14 @@ package arrow.core
 
 import arrow.higherkind
 
-fun <A> IdOf<A>.value(): A = this.fix().value()
+fun <A> IdOf<A>.value(): A = this.fix().extract()
 
 @higherkind
 data class Id<out A>(private val value: A) : IdOf<A> {
 
-  inline fun <B> map(f: (A) -> B): Id<B> = Id(f(value()))
+  inline fun <B> map(f: (A) -> B): Id<B> = Id(f(extract()))
 
-  inline fun <B> flatMap(f: (A) -> IdOf<B>): Id<B> = f(value()).fix()
+  inline fun <B> flatMap(f: (A) -> IdOf<B>): Id<B> = f(extract()).fix()
 
   fun <B> foldLeft(initial: B, operation: (B, A) -> B): B = operation(initial, value)
 
@@ -19,8 +19,6 @@ data class Id<out A>(private val value: A) : IdOf<A> {
 
   fun extract(): A = value
 
-  fun value(): A = value
-
   fun <B> ap(ff: IdOf<(A) -> B>): Id<B> = ff.fix().flatMap { f -> map(f) }.fix()
 
   companion object {

modules/core/arrow-core-data/src/test/kotlin/arrow/core/EitherTest.kt

@@ -14,14 +14,17 @@ import arrow.core.extensions.either.semigroupK.semigroupK
 import arrow.core.extensions.either.show.show
 import arrow.core.extensions.either.traverse.traverse
 import arrow.test.UnitSpec
+import arrow.test.generators.genEither
+import arrow.test.generators.genIntSmall
 import arrow.test.laws.*
 import arrow.typeclasses.Eq
 import arrow.typeclasses.Hash
-import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
+import io.kotlintest.runner.junit4.KotlinTestRunner
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class EitherTest : UnitSpec() {
   val EQ: Eq<Kind<EitherPartialOf<ForId>, Int>> = Eq { a, b ->
     a.fix() == b.fix()
@@ -36,7 +39,7 @@ class EitherTest : UnitSpec() {
     testLaws(
       BifunctorLaws.laws(Either.bifunctor(), { Right(it) }, EQ2),
       SemigroupLaws.laws(Either.semigroup(String.semigroup(), String.semigroup()), Either.right("1"), Either.right("2"), Either.right("3"), Either.eq(String.eq(), String.eq())),
-      MonoidLaws.laws(Either.monoid(MOL = String.monoid(), MOR = Int.monoid()), Either.right(1), Either.eq(String.eq(), Int.eq())),
+      MonoidLaws.laws(Either.monoid(MOL = String.monoid(), MOR = Int.monoid()), genEither(Gen.string(), Gen.int()), Either.eq(String.eq(), Int.eq())),
       ShowLaws.laws(Either.show(), Either.eq(String.eq(), Int.eq())) { Right(it) },
       MonadErrorLaws.laws(Either.monadError(), Eq.any(), Eq.any()),
       TraverseLaws.laws(Either.traverse(), Either.applicative(), { Right(it) }, Eq.any()),
@@ -64,7 +67,7 @@ class EitherTest : UnitSpec() {
 
     "combine a right and a left should return left" {
       forAll { a: String, b: String ->
-        Either.left(a) == Either.left(a).combine(String.monoid(), String.monoid(), Either.right(b))
+        Either.left(a) == Either.left(a).combine(String.monoid(), String.monoid(), Either.right(b)) &&
         Either.left(a) == Either.right(b).combine(String.monoid(), String.monoid(), Either.left(a))
       }
     }
@@ -93,7 +96,7 @@ class EitherTest : UnitSpec() {
     }
 
     "filterOrElse should filter values" {
-      forAll { a: Int, b: Int ->
+      forAll(genIntSmall(), genIntSmall()) { a: Int, b: Int ->
         val left: Either<Int, Int> = Left(a)
 
         Right(a).filterOrElse({ it > a - 1 }, { b }) == Right(a)
@@ -104,7 +107,7 @@ class EitherTest : UnitSpec() {
     }
 
     "filterOrOther should filter values" {
-      forAll { a: Int, b: Int ->
+      forAll(genIntSmall(), genIntSmall()) { a: Int, b: Int ->
         val left: Either<Int, Int> = Left(a)
 
         Right(a).filterOrOther({ it > a - 1 }, { b + a }) == Right(a)
@@ -144,15 +147,15 @@ class EitherTest : UnitSpec() {
     }
 
     "contains should check value" {
-      forAll { a: Int, b: Int ->
+      forAll(genIntSmall(), genIntSmall()) { a: Int, b: Int ->
         Right(a).contains(a)
           && !Right(a).contains(b)
           && !Left(a).contains(a)
       }
     }
 
     "mapLeft should alter left instance only" {
-      forAll { a: Int, b: Int ->
+      forAll(genIntSmall(), genIntSmall()) { a: Int, b: Int ->
         val right: Either<Int, Int> = Right(a)
         val left: Either<Int, Int> = Left(b)
         right.mapLeft { it + 1 } == right && left.mapLeft { it + 1 } == Left(b + 1)

modules/core/arrow-core-data/src/test/kotlin/arrow/core/EvalTest.kt

@@ -9,14 +9,14 @@ import arrow.test.concurrency.SideEffect
 import arrow.test.laws.ComonadLaws
 import arrow.test.laws.MonadLaws
 import arrow.typeclasses.Eq
-import io.kotlintest.KTestJUnitRunner
-import io.kotlintest.matchers.fail
-import io.kotlintest.matchers.shouldBe
+import io.kotlintest.fail
 import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
+import io.kotlintest.runner.junit4.KotlinTestRunner
+import io.kotlintest.shouldBe
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class EvalTest : UnitSpec() {
   val EQ: Eq<Kind<ForEval, Int>> = Eq { a, b ->
     a.value() == b.value()
@@ -155,7 +155,7 @@ class EvalTest : UnitSpec() {
       class Defer : O()
 
       companion object {
-        val gen = Gen.oneOf(
+        val gen = Gen.oneOf<O>(
           Gen.create { O.Map { it + 1 } },
           Gen.create { O.FlatMap { Eval.Now(it) } },
           Gen.create { O.Memoize() },
@@ -189,7 +189,7 @@ class EvalTest : UnitSpec() {
 
       val gen = Gen.create {
         val leaf = { Eval.Now(0) }
-        val eval = build(leaf, (0 until maxDepth).map { O.gen.generate() })
+        val eval = build(leaf, O.gen.random().take(maxDepth).toList())
         DeepEval(eval)
       }
     }

modules/core/arrow-core-data/src/test/kotlin/arrow/core/Function0Test.kt

@@ -13,11 +13,12 @@ import arrow.test.laws.MonadLaws
 import arrow.test.laws.MonoidLaws
 import arrow.test.laws.SemigroupLaws
 import arrow.typeclasses.Eq
-import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.properties.Gen
+import io.kotlintest.runner.junit4.KotlinTestRunner
 import io.kotlintest.properties.forAll
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class Function0Test : UnitSpec() {
   val EQ: Eq<Kind<ForFunction0, Int>> = Eq { a, b ->
     a() == b()
@@ -26,7 +27,7 @@ class Function0Test : UnitSpec() {
   init {
     testLaws(
       SemigroupLaws.laws(Function0.semigroup(Int.semigroup()), { 1 }.k(), { 2 }.k(), { 3 }.k(), EQ),
-      MonoidLaws.laws(Function0.monoid(Int.monoid()), { 1 }.k(), EQ),
+      MonoidLaws.laws(Function0.monoid(Int.monoid()), Gen.constant({ 1 }.k()), EQ),
       MonadLaws.laws(Function0.monad(), EQ),
       ComonadLaws.laws(Function0.comonad(), { { it }.k() }, EQ)
     )

modules/core/arrow-core-data/src/test/kotlin/arrow/core/Function1Test.kt

@@ -15,11 +15,12 @@ import arrow.typeclasses.Conested
 import arrow.typeclasses.Eq
 import arrow.typeclasses.conest
 import arrow.typeclasses.counnest
-import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
+import io.kotlintest.runner.junit4.KotlinTestRunner
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class Function1Test : UnitSpec() {
   val ConestedEQ: Eq<Kind<Conested<ForFunction1, Int>, Int>> = Eq { a, b ->
     a.counnest().invoke(1) == b.counnest().invoke(1)
@@ -32,7 +33,7 @@ class Function1Test : UnitSpec() {
   init {
     testLaws(
       SemigroupLaws.laws(Function1.semigroup<Int, Int>(Int.semigroup()), { a: Int -> a + 1 }.k(), { a: Int -> a + 2 }.k(), { a: Int -> a + 3 }.k(), EQ),
-      MonoidLaws.laws(Function1.monoid<Int, Int>(Int.monoid()), { a: Int -> a + 1 }.k(), EQ),
+      MonoidLaws.laws(Function1.monoid<Int, Int>(Int.monoid()), Gen.constant({ a: Int -> a + 1 }.k()), EQ),
       ContravariantLaws.laws(Function1.contravariant(), { Function1.just<Int, Int>(it).conest() }, ConestedEQ),
       ProfunctorLaws.laws(Function1.profunctor(), { Function1.just(it) }, EQ),
       MonadLaws.laws(Function1.monad(), EQ),

modules/core/arrow-core-data/src/test/kotlin/arrow/core/IdTest.kt

@@ -16,16 +16,17 @@ import arrow.core.extensions.semigroup
 import arrow.test.UnitSpec
 import arrow.test.laws.*
 import arrow.typeclasses.Eq
-import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
+import io.kotlintest.runner.junit4.KotlinTestRunner
 import org.junit.runner.RunWith
 
-@RunWith(KTestJUnitRunner::class)
+@RunWith(KotlinTestRunner::class)
 class IdTest : UnitSpec() {
   init {
     testLaws(
       SemigroupLaws.laws(Id.semigroup(Int.semigroup()), Id(1), Id(2), Id(3), Id.eq(Int.eq())),
-      MonoidLaws.laws(Id.monoid(Int.monoid()), Id(1), Id.eq(Int.eq())),
+      MonoidLaws.laws(Id.monoid(Int.monoid()), Gen.constant(Id(1)), Id.eq(Int.eq())),
       ShowLaws.laws(Id.show(), Eq.any()) { Id(it) },
       MonadLaws.laws(Id.monad(), Eq.any()),
       TraverseLaws.laws(Id.traverse(), Id.applicative(), ::Id, Eq.any()),