La version Release Candidate de Kotlin 1.5.0 est disponible et comprend toutes les fonctionnalit\u00e9s pr\u00e9vues pour la version 1.5.0. finale ! De nouvelles fonctionnalit\u00e9s de langage, des mises \u00e0 jour de stdlib, une biblioth\u00e8que de tests am\u00e9lior\u00e9e et bien d’autres changements. Les seuls modifications suppl\u00e9mentaires pour la version 1.5.0 finale \u00e0 venir seront des correctifs.<\/p>\n
Essayez les API de Kotlin dans vos projets avec la version 1.5.0-RC et contribuez \u00e0 peaufiner la version finale ! Vous pouvez nous signaler tout probl\u00e8me via notre outil de suivi YouTrack<\/a>.<\/p>\n Installer la version 1.5.0-RC<\/a><\/p>\n Dans cet article, nous vous pr\u00e9sentons les modifications apport\u00e9es aux biblioth\u00e8ques standard et de tests de Kotlin dans la version 1.5.0-RC :<\/p>\n Lisez ce qui suit pour conna\u00eetre tous les d\u00e9tails !<\/p>\n <\/a><\/p>\n La biblioth\u00e8que standard comprend l’API des entiers non sign\u00e9s, utile pour traiter les op\u00e9rations sur les entiers non n\u00e9gatifs. Elle comprend :<\/p>\n Les types d’entiers non sign\u00e9s sont disponibles en b\u00eata depuis la version Kotlin 1.3<\/a>. Nous classons maintenant les types et les op\u00e9rations des entiers non sign\u00e9s comme stables, les rendant disponibles sans opt-in et utilisables en toute s\u00e9curit\u00e9 dans des projets r\u00e9els.<\/p>\n Les nouvelles API stables sont :<\/p>\n Les tableaux d’entiers non sign\u00e9s restent en b\u00eata. Il en va de m\u00eame pour les entiers non sign\u00e9s varargs<\/a> qui sont support\u00e9s par des tableaux. Si vous souhaitez les utiliser dans votre code, vous pouvez le faire avec l’annotation En savoir plus sur les entiers non sign\u00e9s dans Kotlin<\/a>.<\/p>\n <\/a><\/p>\n Kotlin fournit maintenant un moyen d’utiliser l’entr\u00e9e\/sortie Java non bloquante<\/a> moderne dans un style idiomatique Kotlin pr\u00eat \u00e0 l’emploi via les fonctions d’extension pour Voici un petit exemple :<\/p>\n Ces extensions ont \u00e9t\u00e9 introduites en tant que fonctionnalit\u00e9 exp\u00e9rimentale dans Kotlin 1.4.20<\/a> et sont maintenant disponibles sans opt-in. Consultez le paquet Les extensions existantes pour File API restent disponibles, vous \u00eates donc libre de choisir l’API que vous pr\u00e9f\u00e9rez.<\/p>\n <\/a><\/p>\n Beaucoup d’entre vous sont familiers avec les fonctions stdlib permettant de changer la casse des cha\u00eenes et des caract\u00e8res : Il existe d\u00e9sormais une nouvelle API ind\u00e9pendante des param\u00e8tres de localisation pour changer la casse des cha\u00eenes et des caract\u00e8res : les extensions Les nouvelles fonctions agissent de la m\u00eame mani\u00e8re, quels que soient les param\u00e8tres de localisation de la plateforme. Appelez simplement ces fonctions et laissez le reste \u00e0 la stdlib.<\/p>\n Les nouvelles fonctions agissent de la m\u00eame mani\u00e8re, quels que soient les param\u00e8tres de localisation de la plateforme. Appelez simplement ces fonctions et laissez le reste \u00e0 la stdlib.<\/p>\n Sur la JVM, vous pouvez effectuer un changement de casse sensible \u00e0 la localisation en appelant les nouvelles fonctions avec la localisation actuelle comme argument :<\/p>\n Les nouvelles fonctions remplaceront compl\u00e8tement les anciennes, qui sont maintenant obsol\u00e8tes.<\/p>\n L’op\u00e9ration permettant d’obtenir le code UTF-16 d’un caract\u00e8re, la fonction De plus, il n’existait pas de fonction g\u00e9n\u00e9rale permettant de renvoyer la valeur num\u00e9rique Pour r\u00e9soudre ces probl\u00e8mes, il existe d\u00e9sormais un ensemble de nouvelles fonctions de conversion entre les caract\u00e8res et leurs codes entiers et valeurs num\u00e9riques :<\/p>\n Ces fonctions ont des noms clairs et rendent le code plus lisible :<\/p>\n Les nouvelles fonctions \u00e9tait disponibles en avant-premi\u00e8re depuis Kotlin 1.4.30<\/a> et sont maintenant stables. Les anciennes fonctions de conversion de caract\u00e8res en nombres ( Nous continuons \u00e0 \u00e9tendre la partie multiplateforme de la biblioth\u00e8que standard afin de fournir toutes ses capacit\u00e9s au code commun du projet multiplateforme.<\/p>\n Nous avons rendu un certain nombre de fonctions La propri\u00e9t\u00e9 La fonction Si ce comportement semble naturel, il peut cacher des erreurs potentielles. Quoi que vous convertissiez avec cette fonction, vous obtenez un bool\u00e9en m\u00eame si la cha\u00eene a une valeur inattendue.<\/p>\n De nouvelles versions strictes sensibles \u00e0 la casse de String?.toBoolean()<\/a> sont l\u00e0 pour \u00e9viter de telles erreurs :<\/p>\n <\/a><\/p>\n L’API exp\u00e9rimentale mesure de la dur\u00e9e et du temps<\/a> est disponible dans la stdlib depuis la version 1.3.50. Elle fournit une API pour la mesure pr\u00e9cise d’intervalles de temps.<\/p>\n L’une des principales classes de cette API est Nous introduisons \u00e9galement de nouvelles propri\u00e9t\u00e9s pour r\u00e9cup\u00e9rer une dur\u00e9e sous forme de valeur Il y a \u00e9galement un ensemble de nouvelles fonctions d’usine pour cr\u00e9er des instances Compte tenu de ces changements majeurs, l’ensemble de l’API de mesure de la dur\u00e9e et du temps reste exp\u00e9rimentale dans la version 1.5.0 et requiert un opt-in avec l’annotation Essayez la nouvelle version et partagez vos commentaires sur notre outil de suivi, YouTrack<\/a>.<\/p>\n <\/a><\/p>\n Dans Kotlin, l’op\u00e9rateur division ( Auparavant, la division enti\u00e8re n\u00e9cessitait une fonction personnalis\u00e9e, comme :<\/p>\n Dans la version 1.5.0-RC, nous pr\u00e9sentons la fonction Dans la version 1.5.0, nous introduisons la nouvelle fonction Cela diff\u00e8re de l’op\u00e9rateur <\/a><\/p>\n L’API de collections de Kotlin couvre un ensemble d’op\u00e9rations populaires sur les collections avec des fonctions int\u00e9gr\u00e9es. Pour les cas qui ne sont pas courants, vous combinez g\u00e9n\u00e9ralement les appels de ces fonctions. Cette m\u00e9thode fonctionne, mais n’est pas toujours tr\u00e8s \u00e9l\u00e9gante et peut causer une surcharge.<\/p>\n Par exemple, pour obtenir le premier r\u00e9sultat non nul d’une fonction de s\u00e9lecteur sur les \u00e9l\u00e9ments de la collection, vous pouvez appeler Voici un exemple montrant comment raccourcir votre code avec ces fonctions.<\/p>\n Supposons que vous ayez une classe avec une propri\u00e9t\u00e9 de valeur null et que vous ayez besoin de sa premi\u00e8re valeur non null dans une liste d’instances de classe.<\/p>\n You can implement this by iterating the collection and checking if a property is not null:<\/p>\n Il est \u00e9galement possible d’utiliser les fonctions pr\u00e9c\u00e9demment existantes Voici le r\u00e9sultat avec la nouvelle fonction :<\/p>\n <\/a><\/p>\n Nous n’avions pas fourni de mises \u00e0 jour majeures de la biblioth\u00e8que de tests Kotlin Nous poursuivons le d\u00e9veloppement du processus de configuration pour les projets multiplateformes. Dans la version 1.5.0, la mise en place d’une d\u00e9pendance sur D\u00e9sormais, la d\u00e9pendance Une fois que vous avez sp\u00e9cifi\u00e9 la d\u00e9pendance Voici ce que cela donne dans le DSL Groovy :<\/p>\n Et dans le DSL Kotlin :<\/p>\n Vous pouvez \u00e9galement passer \u00e0 JUnit 5 ou TestNG en appelant simplement une fonction dans la t\u00e2che de test : Il en va de m\u00eame dans les projets limit\u00e9s \u00e0 JVM lorsque vous ajoutez la d\u00e9pendance La version 1.5.0 apportera plusieurs nouvelles fonctions d’assertion, ainsi que des am\u00e9liorations des fonctions existantes.<\/p>\n Passons d’abord rapidement en revue les nouvelles fonctions :<\/p>\n Voici un bref exemple qui illustre l’utilisation de ces fonctions :<\/p>\n En ce qui concerne les fonctions d’assertion existantes, il est maintenant possible d’appeler des suspending functions<\/a> au sein du lambda pass\u00e9 \u00e0 \n
Types d’entiers non sign\u00e9s stables<\/h2>\n
\n
UInt<\/code>, ULong<\/code>, UByte<\/code>, UShort<\/code> et fonctions associ\u00e9es telles que les conversions.<\/li>\nUIntArray<\/code>, UIntRange<\/code> et conteneurs similaires pour d’autres types.<\/li>\n<\/ul>\n\n
fun main() {\n\/\/sampleStart\n val zero = 0U \/\/ Define unsigned numbers with literal suffixes\n val ten = 10.toUInt() \/\/ or by converting non-negative signed numbers\n \/\/val minusOne: UInt = -1U \/\/ Error: unary minus is not defined\n val range: UIntRange = zero..ten \/\/ Separate types for ranges and progressions\n\n for (i in range) print(i)\n println()\n println(\"UInt covers the range from ${UInt.MIN_VALUE} to ${UInt.MAX_VALUE}\") \/\/ UInt covers the range from 0 to 4294967295\n\/\/sampleEnd\n}\n<\/pre>\n@ExperimentalUnsignedTypes<\/code>.<\/p>\nExtensions pour l’API java.nio.file.Path<\/h2>\n
java.nio.file.Path<\/code><\/a>.<\/p>\nimport kotlin.io.path.*\nimport java.nio.file.Path\n\nfun main() {\n \/\/ construct path with the div (\/) operator\n val baseDir = Path(\"\/base\")\n val subDir = baseDir \/ \"subdirectory\"\n\n \/\/ list files in a directory\n val kotlinFiles = Path(\"\/home\/user\").listDirectoryEntries(\"*.kt\")\n \/\/ count lines in all kotlin files\n val totalLines = kotlinFiles.sumOf { file -> file.useLines { lines -> lines.count() } }\n}\n<\/pre>\nkotlin.io.path<\/code><\/a> pour la liste des fonctions que vous pouvez utiliser.<\/p>\nAPI ind\u00e9pendante des param\u00e8tres de localisation pour les majuscules et les minuscules<\/h2>\n
toUpperCase()<\/code>, toLowerCase()<\/code>, toTitleCase()<\/code>. Elles fonctionnent g\u00e9n\u00e9ralement bien, mais peuvent devenir un v\u00e9ritable casse-t\u00eate lorsqu’il s’agit de g\u00e9rer diff\u00e9rentes localisations de plateformes. Elles sont toutes sensibles aux param\u00e8tres de localisation, leur r\u00e9sultat peut donc varier en fonction de la localisation. Par exemple, que retourne \"Kotlin\".toUpperCase()<\/code> ? \u00ab Bien \u00e9videmment KOTLIN<\/code> \u00bb, diriez-vous. Mais dans les param\u00e8tres r\u00e9gionaux turcs, le i<\/code> majuscule est \u0130<\/code>, donc le r\u00e9sultat est diff\u00e9rent : KOTL\u0130N<\/code>.<\/p>\nuppercase()<\/code>, lowercase()<\/code>, titlecase()<\/code>, et leurs \u00e9quivalents *Char()<\/code> Vous l’avez peut-\u00eatre d\u00e9j\u00e0 essay\u00e9e en avant-premi\u00e8re dans la version 1.4.30<\/a>.<\/p>\nfun main() {\n\/\/sampleStart\n \/\/ replace the old API\n println(\"Kotlin\".toUpperCase()) \/\/ KOTLIN or KOTL\u0130N or?..\n\n \/\/ with the new API\n println(\"Kotlin\".uppercase()) \/\/ Always KOTLIN\n\/\/sampleEnd\n}\n<\/pre>\n\"Kotlin\".uppercase(Locale.getDefault()) \/\/ Locale-sensitive uppercasing\n<\/pre>\n
Conversion claire des caract\u00e8res en codes et des caract\u00e8res en chiffres<\/h2>\n
toInt()<\/code>, constituait un pi\u00e8ge courant car sur des cha\u00eenes \u00e0 un chiffre elle ressemble assez \u00e0 String.toInt()<\/code> qui produit un Int<\/code> pr\u00e9sent\u00e9 par ce chiffre.<\/p>\n\"4\".toInt() \/\/ returns 4\n'4'.toInt() \/\/ returns 52\n<\/pre>\n
4<\/code> pour Char<\/code> '4'<\/code>.<\/p>\n\n
Char(code)<\/code> et Char.code<\/code> effectuent la conversion ente un caract\u00e8re et son code.<\/li>\nChar.digitToInt(radix: Int)<\/code> et sa version *OrNull<\/code> cr\u00e9ent un entier \u00e0 partir d’un chiffre dans la base sp\u00e9cifi\u00e9e.<\/li>\nInt.digitToChar(radix: Int)<\/code> cr\u00e9e un caract\u00e8re \u00e0 partir d’un chiffre qui repr\u00e9sente un entier dans la base sp\u00e9cifi\u00e9e.<\/li>\n<\/ul>\nfun main() {\n\/\/sampleStart\n val capsK = Char(75) \/\/ \u2018K\u2019\n val one = '1'.digitToInt(10) \/\/ 1\n val digitC = 12.digitToChar(16) \/\/ hexadecimal digit \u2018C\u2019\n\n println(\"${capsK}otlin ${one}.5.0-R${digitC}\") \/\/ \u201cKotlin 1.5.0-RC\u201d\n println(capsK.code) \/\/ 75\n\/\/sampleEnd\n}\n<\/pre>\nChar.toInt()<\/code> et fonctions similaires pour les autres types num\u00e9riques) et de conversion de nombres en caract\u00e8res (Long.toChar()<\/code> et fonctions similaires sauf pour Int.toChar()<\/code>) sont maintenant obsol\u00e8tes.<\/p>\nAPI de caract\u00e8res multiplateforme \u00e9tendue<\/h2>\n
Char<\/code> disponibles sur toutes les plateformes et dans le code commun. Ces fonctions sont :<\/p>\n\n
Char.isDigit()<\/code>, Char.isLetter()<\/code>, Char.isLetterOrDigit()<\/code> qui v\u00e9rifient si un caract\u00e8re est une lettre ou un chiffre.<\/li>\nChar.isLowerCase()<\/code>, Char.isUpperCase()<\/code>, Char.isTitleCase()<\/code> qui v\u00e9rifient la casse d’un caract\u00e8re.<\/li>\nChar.isDefined()<\/code> qui v\u00e9rifie si un caract\u00e8re a une cat\u00e9gorie g\u00e9n\u00e9rale Unicode<\/a> autre que Cn<\/code> (non d\u00e9fini<\/em>).<\/li>\nChar.isISOControl()<\/code> qui v\u00e9rifie si un caract\u00e8re est un caract\u00e8re de contr\u00f4le ISO<\/a>, dont le code est compris dans les plages \\u0000<\/code>..\\u001F<\/code> ou \\u007F<\/code>..\\u009F<\/code>.<\/li>\n<\/ul>\nChar.category<\/code> et son type de retour de classe enum CharCategory<\/code>, qui indique la cat\u00e9gorie g\u00e9n\u00e9rale d’un caract\u00e8re selon Unicode, sont d\u00e9sormais disponibles dans les projets multiplateformes.<\/p>\nfun main() {\n\/\/sampleStart\n val array = \"Kotlin 1.5.0-RC\".toCharArray()\n val (letterOrDigit, punctuation) = array.partition { it.isLetterOrDigit() }\n val (upperCase, notUpperCase ) = array.partition { it.isUpperCase() }\n\n println(\"$letterOrDigit, $punctuation\") \/\/ [K, o, t, l, i, n, 1, 5, 0, R, C], [ , ., ., -]\n println(\"$upperCase, $notUpperCase\") \/\/ [K, R, C], [o, t, l, i, n, , 1, ., 5, ., 0, -]\n\n if (array[0].isDefined()) println(array[0].category)\n\/\/sampleEnd\n}\n<\/pre>\nVersions strictes de String?.toBoolean()<\/h2>\n
String?.toBoolean()<\/code> de Kotlin est tr\u00e8s utilis\u00e9e pour cr\u00e9er des valeurs bool\u00e9ennes \u00e0 partir de cha\u00eenes. Cela fonctionne assez simplement : c’est true<\/code> sur une cha\u00eene “true” quelle que soit sa casse et false<\/code> sur toutes les autres cha\u00eenes, y compris null<\/code>.<\/p>\n\n
String.toBooleanStrict()<\/code> lance une exception pour toutes les entr\u00e9es sauf les litt\u00e9raux “true” et “false”.<\/li>\nString.toBooleanStrictOrNull()<\/code> renvoie null pour toutes les entr\u00e9es sauf les litt\u00e9raux “true” et “false”.<\/li>\n<\/ul>\nfun main() {\n\/\/sampleStart\n println(\"true\".toBooleanStrict()) \/\/ True\n \/\/ println(\"1\".toBooleanStrict()) \/\/ Exception\n println(\"1\".toBooleanStrictOrNull()) \/\/ null\n println(\"True\".toBooleanStrictOrNull()) \/\/ null: the function is case-sensitive\n\/\/sampleEnd\n}\n<\/pre>\nModifications dans l’API Duration<\/h2>\n
Duration<\/code><\/a>. Elle repr\u00e9sente la dur\u00e9e entre deux instants de temps. Dans la version 1.5.0, Duration<\/code> fait l’objet de modifications importantes, tant au niveau de l’API que de la repr\u00e9sentation interne.<\/p>\nDuration<\/code> utilise d\u00e9sormais une valeur Long<\/code> pour la repr\u00e9sentation interne au lieu de Double<\/code>. La plage de valeurs Long<\/code> permet de repr\u00e9senter plus de cent ans avec une pr\u00e9cision de l’ordre de la nanoseconde ou cent millions d’ann\u00e9es avec une pr\u00e9cision de l’ordre de la milliseconde. Cependant, les dur\u00e9es inf\u00e9rieures \u00e0 la nanoseconde pr\u00e9c\u00e9demment prises en charge ne sont plus disponibles.<\/p>\nLong<\/code>. Elles sont disponibles pour diverses unit\u00e9s de temps, notamment Duration.inWholeMinutes<\/code> et Duration.inWholeSeconds<\/code>. Ces fonctions viennent remplacer les propri\u00e9t\u00e9s bas\u00e9es sur Double<\/code>, telles que Duration.inMinutes<\/code>.<\/p>\nDuration<\/code> \u00e0 partir de valeurs enti\u00e8res. Elles sont d\u00e9finies directement dans le type Duration<\/code> et remplacent les anciennes propri\u00e9t\u00e9s d’extension des types num\u00e9riques telles que Int.seconds<\/code>.<\/p>\nimport kotlin.time.ExperimentalTime\nimport kotlin.time.Duration\n\n@ExperimentalTime\nfun main() {\n val duration = Duration.milliseconds(120000)\n println(\"There are ${duration.inWholeSeconds} seconds in ${duration.inWholeMinutes} minutes\")\n}\n<\/pre>\n@ExperimentalTime<\/code>.<\/p>\nOp\u00e9rations math\u00e9matiques : division enti\u00e8re et op\u00e9rateur mod<\/h2>\n
\/<\/code>) sur les entiers<\/a> repr\u00e9sente la division tronqu\u00e9e<\/em>, qui ne prend pas en compte la partie fractionnaire du r\u00e9sultat. En arithm\u00e9tique modulaire, il existe \u00e9galement une alternative : la division enti\u00e8re<\/em> qui arrondit le r\u00e9sultat par le bas (vers le plus petit entier), ce qui produit un r\u00e9sultat diff\u00e9rent sur les nombres n\u00e9gatifs.<\/p>\nfun floorDivision(i: Int, j: Int): Int {\n var result = i \/ j\n if (i != 0 && result <= 0) result--\n return result\n}\n<\/pre>\nfloorDiv()<\/code> qui effectue des divisions enti\u00e8res sur les entiers.<\/p>\nfun main() {\n\/\/sampleStart\n println(\"Truncated division -5\/3: ${-5 \/ 3}\")\n println(\"Floored division -5\/3: ${(-5).floorDiv(3)}\")\n\/\/sampleEnd\n}\n<\/pre>\nmod()<\/code>. Elle fonctionne maintenant exactement comme son nom l’indique : elle renvoie le modulo<\/em>, qui est le reste de la division enti\u00e8re.<\/p>\nrem()<\/code> (ou %<\/code>) de Kotlin. Le modulo est la diff\u00e9rence entre a<\/code> et a.floorDiv(b) * b<\/code>. Le modulo non nul a toujours le m\u00eame signe que b<\/code> alors que a % b<\/code> peut en avoir un diff\u00e9rent. Cela peut \u00eatre utile lors de I’ impl\u00e9mentation de listes cycliques par exemple :<\/p>\nfun main() {\n\/\/sampleStart\n fun getNextIndexCyclic(current: Int, size: Int ) = (current + 1).mod(size)\n fun getPreviousIndexCyclic(current: Int, size: Int ) = (current - 1).mod(size)\n \/\/ unlike %, mod() produces the expected non-negative value even if (current - 1) is less than 0\n\n val size = 5\n for (i in 0..(size * 2)) print(getNextIndexCyclic(i, size))\n println()\n for (i in 0..(size * 2)) print(getPreviousIndexCyclic(i, size))\n\/\/sampleEnd\n}\n<\/pre>\nCollections : firstNotNullOf() et firstNotNullOfOrNull()<\/h2>\n
mapNotNull()<\/code> et first()<\/code>. Dans la version 1.5.0, vous pouvez le faire avec un seul appel d’une nouvelle fonction firstNotNullOf()<\/code>. Avec firstNotNullOf()<\/code>, nous ajoutons sa contrepartie *orNull()<\/code> qui produit null s’il n’y a pas de valeur \u00e0 retourner.<\/p>\nclass Item(val name: String?)\n<\/pre>\n
\/\/ Option 1: manual implementation\nfor (element in collection) {\n val itemName = element.name\n if (itemName != null) return itemName\n}\nreturn null\n<\/pre>\nmapNotNull()<\/code> et firstOrNull()<\/code>. Notez que mapNotNull()<\/code> construit une collection interm\u00e9diaire, ce qui n\u00e9cessite de la m\u00e9moire suppl\u00e9mentaire, surtout pour les grandes collections. Ainsi, une transformation en une s\u00e9quence peut \u00e9galement \u00eatre n\u00e9cessaire ici.<\/p>\n\/\/ Option 2: old stdlib functions\nreturn collection\n \/\/ .asSequence() \/\/ Avoid creating intermediate list for big collections\n .mapNotNull { it.name }\n .firstOrNull()\n<\/pre>\n\/\/ Option 3: new firstNotNullOfOrNull()\nreturn collection.firstNotNullOfOrNull { it.name }\n<\/pre>\nModifications dans la biblioth\u00e8que de tests<\/h2>\n
kotlin-test<\/code> depuis plusieurs versions, mais nous apportons aujourd’hui des modifications tr\u00e8s attendues. Avec la version 1.5.0-RC, vous pouvez essayer plusieurs nouvelles fonctionnalit\u00e9s :<\/p>\n\n
kotlin-test<\/code> unique dans les projets multiplateformes.<\/li>\nD\u00e9pendance kotlin-test dans les projets multiplateformes<\/h3>\n
kotlin-test<\/code> pour tous les ensembles de sources est facilit\u00e9e.<\/p>\nkotlin-test<\/code> dans l’ensemble de sources de tests commun est la seule que vous ayez \u00e0 ajouter. Le plugin Gradle d\u00e9duira la d\u00e9pendance de la plateforme correspondante pour les autres ensembles de sources :<\/p>\n\n
kotlin-test-junit<\/code> pour les ensembles de sources JVM. Vous pouvez \u00e9galement passer \u00e0 kotlin-test-junit-5<\/code> ou kotlin-test-testng<\/code> si vous les activez explicitement (consultez la suite pour savoir comment).<\/li>\nkotlin-test-js<\/code> pour les ensembles de sources Kotlin\/JS.<\/li>\nkotlin-test-common<\/code> et kotlin-test-annotations-common<\/code> pour les ensembles de sources communs.<\/li>\nkotlin-test<\/code>.<\/li>\n<\/ul>\nChoix automatique d’un framework de test pour les ensembles de sources Kotlin\/JVM<\/h3>\n
kotlin-test<\/code> dans l’ensemble de sources de tests commun tel que d\u00e9crit ci-dessus, les jeux de sources JVM re\u00e7oivent automatiquement la d\u00e9pendance sur JUnit 4. C’est tout ! Vous pouvez \u00e9crire et ex\u00e9cuter des tests imm\u00e9diatement !<\/p>\nkotlin {\n sourceSets {\n commonTest {\n dependencies {\n \/\/ This brings the dependency\n \/\/ on JUnit 4 transitively\n implementation kotlin('test')\n }\n }\n }\n}\n<\/pre>\nkotlin {\n sourceSets {\n val commonTest by getting {\n dependencies {\n \/\/ This brings the dependency\n \/\/ on JUnit 4 transitively\n implementation(kotlin(\"test\"))\n }\n }\n }\n}\n<\/pre>\nuseJUnitPlatform()<\/code><\/a> ou useTestNG()<\/code><\/a>.<\/p>\nkotlin {\n jvm {\n testRuns[\"test\"].executionTask.configure {\n \/\/ enable TestNG support\n useTestNG()\n \/\/ or\n \/\/ enable JUnit Platform (a.k.a. JUnit 5) support\n useJUnitPlatform()\n }\n }\n}\n<\/pre>\nkotlin-test<\/code>.<\/p>\nMises \u00e0 jour des fonctions d’assertion<\/h3>\n
\n
assertIs<T>()<\/code> et assertIsNot<T>()<\/code> v\u00e9rifient le type de la valeur.<\/li>\nassertContentEquals()<\/code> compare le contenu du conteneur pour les tableaux, les s\u00e9quences et tout Iterable<\/code>. Plus pr\u00e9cis\u00e9ment, elle v\u00e9rifie si expected<\/code> et actual<\/code> contiennent les m\u00eames \u00e9l\u00e9ments dans le m\u00eame ordre.<\/li>\nassertEquals()<\/code> et assertNotEquals()<\/code> pour Double<\/code> et Float<\/code> ont de nouvelles surcharges avec un troisi\u00e8me param\u00e8tre : la pr\u00e9cision.<\/li>\nassertContains()<\/code> v\u00e9rifie la pr\u00e9sence d’un \u00e9l\u00e9ment dans tout objet dont l’op\u00e9rateur contains()<\/code> est d\u00e9fini : tableau, liste, plage, et ainsi de suite.<\/li>\n<\/ul>\n@Test\nfun test() {\n val expectedArray = arrayOf(1, 2, 3)\n val actualArray = Array(3) { it + 1 }\n\n val first: Any = actualArray[0]\n assertIs<Int>(first)\n \/\/ first is smart-cast to Int now\n println(\"${first + 1}\")\n\n assertContentEquals(expectedArray, actualArray)\n assertContains(expectedArray, 2)\n\n val x = sin(PI)\n\n \/\/ precision parameter\n val tolerance = 0.000001\n\n assertEquals(0.0, x, tolerance)\n}\n<\/pre>\n