Kotlin 1.5.0-RC ist mit allen f\u00fcr 1.5.0 geplanten Features verf\u00fcgbar \u2013 probieren Sie den gesamten Funktionsumfang der kommenden Version aus! Neue Sprachmerkmale, stdlib-Updates, eine verbesserte Testbibliothek und viele weitere Neuerungen erhalten nun den letzten Schliff. Bis zum endg\u00fcltigen Release werden nur noch Fehlerkorrekturen vorgenommen.<\/p>\n<\/p>\n
Testen Sie mit 1.5.0-RC die modernen Kotlin-APIs in Ihren realen Projekten und helfen Sie uns mit Ihrem Feedback, die Release-Version zu verbessern! Sie k\u00f6nnen alle gefundenen Probleme in unserem YouTrack<\/a>-Issue-Tracker melden.<\/p>\n 1.5.0-RC installieren<\/a><\/p>\n In diesem Beitrag stellen wir Ihnen die \u00c4nderungen vor, die wir in 1.5.0-RC an der Kotlin-Standard- und Testbibliothek vorgenommen haben:<\/p>\n Lesen Sie weiter, um alle Details zu erfahren!<\/p>\n <\/a><\/p>\n Die Standardbibliothek enth\u00e4lt eine API f\u00fcr vorzeichenlose Ganzzahlen, die f\u00fcr den Umgang mit nicht negativen Ganzzahlen sehr praktisch ist. Zu den Neuerungen z\u00e4hlen:<\/p>\n Die Betaphase der vorzeichenlosen Ganzzahlen l\u00e4uft seit Kotlin 1.3<\/a>. Jetzt werden die vorzeichenlosen Ganzzahltypen und die dazugeh\u00f6rigen Operationen als stabil deklariert und ohne Opt-in bereitgestellt, und sie k\u00f6nnen ohne Weiteres in realen Projekten verwendet werden.<\/p>\n Die neuen stabilen APIs umfassen im Detail Folgendes:<\/p>\n Die Arrays f\u00fcr vorzeichenlose Ganzzahlen verbleiben in der Betaphase. Dasselbe gilt f\u00fcr vorzeichenlose Ganzzahl-varargs<\/a>, die auf Arrays basieren. Zu ihrer Verwendung ist ein Opt-in mithilfe der Annotation Erfahren Sie mehr \u00fcber vorzeichenlose Ganzzahlen in Kotlin<\/a>.<\/p>\n <\/a><\/p>\n Mit den Erweiterungsfunktionen f\u00fcr Ein kleines Beispiel:<\/p>\n Diese Erweiterungen wurden als experimentelles Feature in Kotlin 1.4.20<\/a> eingef\u00fchrt und sind jetzt ohne Opt-in verf\u00fcgbar. Sehen Sie sich die verf\u00fcgbaren Funktionen im Paket Die vorhandenen Erweiterungen f\u00fcr die File-API bleiben erhalten, sodass Sie Ihre bevorzugte API frei ausw\u00e4hlen k\u00f6nnen.<\/p>\n <\/a><\/p>\n Viele von Ihnen kennen die stdlib-Funktionen zum \u00c4ndern der Gro\u00df- und Kleinschreibung von Zeichenfolgen und Zeichen: Jetzt gibt es eine neue Gebietsschema-agnostische API zum \u00c4ndern der Gro\u00df- und Kleinschreibung von Zeichenfolgen und Zeichen: die Erweiterungen Die neuen Funktionen geben bei jedem Plattform-Gebietsschema identische Ergebnisse zur\u00fcck. Rufen Sie einfach diese Funktionen auf und \u00fcberlassen Sie den Rest der stdlib.<\/p>\n Die neuen Funktionen geben bei jedem Plattform-Gebietsschema identische Ergebnisse zur\u00fcck. Rufen Sie einfach diese Funktionen auf und \u00fcberlassen Sie den Rest der stdlib.<\/p>\n In der JVM k\u00f6nnen Sie eine Gebietsschema-spezifische \u00c4nderung der Gro\u00df- und Kleinschreibung vornehmen, indem Sie den neuen Funktionen das aktuelle Gebietsschema als Argument \u00fcbergeben:<\/p>\n Die neuen Funktionen werden die alten Funktionen, die wir jetzt als veraltet gekennzeichnet haben, vollst\u00e4ndig ersetzen.<\/p>\n Die Operation zum Abfragen des UTF-16-Codes eines Zeichens \u2013 die Dar\u00fcber hinaus gab es keine g\u00e4ngige Funktion, die beim Um diese Probleme zu l\u00f6sen, gibt es jetzt neue Funktionen f\u00fcr die Konvertierung zwischen Zeichen und ihren Ganzzahlcodes bzw. numerischen Werten:<\/p>\n Diese Funktionen haben eindeutige Namen und machen den Code besser lesbar:<\/p>\n Die neuen Funktionen sind seit Kotlin 1.4.30<\/a> als Preview verf\u00fcgbar und wurden jetzt als stabil markiert. Die alten Funktionen f\u00fcr die Konvertierung von Zeichen nach Zahlen ( Wir arbeiten weiterhin an der Erweiterung des Multiplattform-Teils der Standardbibliothek, um alle Funktionen der Standardbibliothek f\u00fcr den gemeinsamen Code in Multiplattform-Projekten bereitzustellen.<\/p>\n Als neueste Entwicklung haben wir eine Reihe von Die Eigenschaft Die Auch wenn dieses Verhalten selbstverst\u00e4ndlich erscheint, k\u00f6nnen sich dahinter Fehlerzust\u00e4nde verbergen. Egal was wir mit dieser Funktion konvertieren, wir erhalten immer einen booleschen Wert \u2013 auch wenn die Zeichenfolge einen unerwarteten Wert hat.<\/p>\n Die neuen, strikten Versionen von String?.toBoolean()<\/a> ber\u00fccksichtigen die Gro\u00df- und Kleinschreibung und helfen Ihnen, solche Fehler zu vermeiden:<\/p>\n <\/a><\/p>\n Die experimentelle API f\u00fcr Dauer- und Zeitmessungen<\/a> ist seit Version 1.3.50 der stdlib verf\u00fcgbar. Die API erm\u00f6glicht die pr\u00e4zise Messung von Zeitintervallen.<\/p>\n Eine der zentralen Klassen dieser API ist Wir haben auch neue Eigenschaften zum Abrufen einer Duration als Eine weitere \u00c4nderung sind neue Factory-Funktionen zum Erstellen von Angesichts dieser umfangreichen \u00c4nderungen verbleibt die gesamte Zeitmessungs-API auch in 1.5.0 im experimentellen Status und erfordert ein Opt-in mit der Annotation Bitte probieren Sie die neue Version aus und teilen Sie uns Ihr Feedback in unserem YouTrack<\/a>-Issue-Tracker mit.<\/p>\n <\/a><\/p>\n In Kotlin bewirkt der Divisionsoperator ( Bisher erforderte die abgerundete Division eine benutzerdefinierte Funktion wie diese:<\/p>\n In 1.5.0-RC stellen wir die Funktion In 1.5.0 f\u00fchren wir die neue Funktion Sie unterscheidet sich von <\/a><\/p>\n Die Collections-API von Kotlin bietet eingebaute Funktionen f\u00fcr zahlreiche g\u00e4ngige Operationen mit Collections. Bei selteneren Einsatzf\u00e4llen lassen sich normalerweise mehrere Aufrufe dieser Funktionen kombinieren. Dies funktioniert, sieht aber nicht immer elegant aus und kann Overhead verursachen.<\/p>\n Um beispielsweise das erste von null abweichende Ergebnis einer Auswahlfunktion f\u00fcr die Collection-Elemente zu erhalten, k\u00f6nnen wir Hier ist ein Beispiel, wie Sie damit Ihren Code verk\u00fcrzen k\u00f6nnen.<\/p>\n Angenommen, Sie haben eine Klasse mit einer nullf\u00e4higen Eigenschaft, und Sie ben\u00f6tigen den ersten Nicht-Null-Wert aus einer Liste von Klasseninstanzen.<\/p>\n Sie k\u00f6nnen dies implementieren, indem Sie die Collection durchlaufen und pr\u00fcfen, ob die Eigenschaft nicht null ist:<\/p>\n Eine andere M\u00f6glichkeit ist, die bestehenden Funktionen Und so sieht es bei Verwendung der neuen Funktion aus:<\/p>\n <\/a><\/p>\n In den letzten Releases haben wir keine gr\u00f6\u00dferen Updates an der Kotlin-Testbibliothek Wir arbeiten weiter am Konfigurationsprozess f\u00fcr Multiplattform-Projekte. In 1.5.0 haben wir das Einrichten einer Abh\u00e4ngigkeit von Jetzt ist die Sobald Sie wie oben beschrieben die Abh\u00e4ngigkeit des gemeinsamen Test-Quellcode-Sets von So sieht es in der Groovy-DSL aus:<\/p>\n Und in der Kotlin-DSL:<\/p>\n Sie k\u00f6nnen auch zu JUnit 5 oder TestNG wechseln, indem Sie im Test-Task einfach eine Funktion aufrufen: Dies funktioniert auch in Nur-JVM-Projekten, wenn Sie die Abh\u00e4ngigkeit von 1.5.0 enth\u00e4lt eine Reihe neuer Assertion-Funktionen sowie Verbesserungen an bestehenden Funktionen.<\/p>\n Sehen wir uns zun\u00e4chst die neuen Funktionen an:<\/p>\n Das folgende kurze Beispiel zeigt die Verwendung dieser Funktionen:<\/p>\n Und nun zu den bestehenden Assertion-Funktionen: Jetzt ist es m\u00f6glich, \n
Stabile vorzeichenlose Ganzzahltypen<\/h2>\n
\n
UInt<\/code>, ULong<\/code>, UByte<\/code> und UShort<\/code> mit dazugeh\u00f6rigen Funktionen zum Beispiel f\u00fcr die Konvertierung.<\/li>\nUIntArray<\/code>, UIntRange<\/code> und \u00e4hnliche Container f\u00fcr die anderen Typen.<\/li>\n<\/ul>\n\n
\nfun 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> erforderlich.<\/p>\nErweiterungen f\u00fcr die java.nio.file.Path-API<\/h2>\n
java.nio.file.Path<\/code><\/a> bietet Kotlin jetzt die M\u00f6glichkeit, die moderne nicht-blockierende Java-IO-API<\/a> in einem Kotlin-gem\u00e4\u00dfen Stil zu nutzen.<\/p>\n\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> an.<\/p>\nGebietsschema-agnostische API f\u00fcr Gro\u00df- und Kleinschreibung<\/h2>\n
toUpperCase()<\/code>, toLowerCase()<\/code>, toTitleCase()<\/code>. Diese versehen in der Regel einwandfrei ihren Dienst. Schwierigkeiten entstehen nur beim Umgang mit verschiedenen Plattform-Gebietsschemas \u2013 alle Funktionen sind Gebietsschema-spezifisch, sodass sich die Ergebnisse je nach Gebietsschema unterscheiden k\u00f6nnen. Wie lautet zum Beispiel der R\u00fcckgabewert von \"Kotlin\".toUpperCase()<\/code>? \u201eOffensichtlich KOTLIN<\/code>\u201c, ist man versucht zu sagen. Nicht im t\u00fcrkischen Gebietsschema, wo das i<\/code> gro\u00df geschrieben \u0130<\/code> lautet. In dem Fall lautet das Ergebnis: KOTL\u0130N<\/code>.<\/p>\nuppercase()<\/code>, lowercase()<\/code> und titlecase()<\/code> sowie ihre *Char()<\/code>-Pendants. M\u00f6glicherweise haben Sie bereits die Preview in 1.4.30<\/a> ausprobiert.<\/p>\n\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\n"Kotlin".uppercase(Locale.getDefault()) \/\/ Locale-sensitive uppercasing\n<\/pre>\n
Eindeutige Konvertierungen von Zeichen zu Code und Zeichen zu Zahl<\/h2>\n
toInt()<\/code>-Funktion \u2013 hat sich h\u00e4ufig als Stolperstein erwiesen, da sie bei Zeichenfolgen, die aus einer Ziffer bestehen, einer anderen Funktion sehr \u00e4hnlich sieht: String.toInt()<\/code>, die aus der Ziffer eine Int<\/code> produziert.<\/p>\n\n"4".toInt() \/\/ returns 4\n'4'.toInt() \/\/ returns 52\n<\/pre>\n
Char<\/code> '4'<\/code> den numerischen Wert 4<\/code> zur\u00fcckgab.<\/p>\n\n
Char(code)<\/code> und Char.code<\/code> konvertieren zwischen einem Char und seinem Code.<\/li>\nChar.digitToInt(radix: Int)<\/code> und deren *OrNull<\/code>-Version produzieren eine Ganzzahl aus einer Ziffer im angegebenen Zahlensystem.<\/li>\nInt.digitToChar(radix: Int)<\/code> erstellt aus einer Ziffer ein Zeichen, das die Ziffer im angegebenen Zahlensystem repr\u00e4sentiert.<\/li>\n<\/ul>\n\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> und \u00e4hnliche Funktionen f\u00fcr andere numerische Typen) sowie von Zahlen nach Zeichen (Long.toChar()<\/code> usw. mit der Ausnahme von Int.toChar()<\/code>) wurden jetzt als veraltet gekennzeichnet.<\/p>\nErweiterte Multiplattform-Zeichen-API<\/h2>\n
Char<\/code>-Funktionen f\u00fcr alle Plattformen und f\u00fcr gemeinsamen Code bereitgestellt. Diese Funktionen sind:<\/p>\n\n
Char.isDigit()<\/code>, Char.isLetter()<\/code>, Char.isLetterOrDigit()<\/code> \u2013 diese pr\u00fcfen, ob ein Zeichen ein Buchstabe oder eine Ziffer ist.<\/li>\nChar.isLowerCase()<\/code>, Char.isUpperCase()<\/code>, Char.isTitleCase()<\/code> \u2013 diese pr\u00fcfen die Gro\u00df- bzw. Kleinschreibung eines Zeichens.<\/li>\nChar.isDefined()<\/code> pr\u00fcft, ob ein Zeichen einer allgemeinen Unicode-Kategorie<\/a> \u2013 au\u00dfer Cn<\/code> (undefiniert<\/em>) \u2013 zugeordnet ist.<\/li>\nChar.isISOControl()<\/code> pr\u00fcft, ob ein Zeichen ein ISO-Steuerzeichen<\/a> ist, dessen Code in den Bereichen \\u0000<\/code>..\\u001F<\/code> oder \\u007F<\/code>..\\u009F<\/code> liegt.<\/li>\n<\/ul>\nChar.category<\/code> und ihr R\u00fcckgabetyp, die enum-Klasse CharCategory<\/code>, die die allgemeine Unicode-Kategorie eines Zeichens angibt, sind jetzt in Multiplattform-Projekten verf\u00fcgbar.<\/p>\n\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>\nStrikte Versionen von String?.toBoolean()<\/h2>\n
String?.toBoolean()<\/code>-Funktion von Kotlin wird h\u00e4ufig verwendet, um boolesche Werte aus Zeichenfolgen zu generieren. Die Funktionsweise ist ziemlich einfach: Bei der Zeichenfolge \u201etrue\u201c (unabh\u00e4ngig von Gro\u00df- und Kleinschreibung) wird true<\/code> und bei allen anderen Zeichenfolgen \u2013 einschlie\u00dflich null<\/code> \u2013 wird false<\/code> zur\u00fcckgegeben.<\/p>\n\n
String.toBooleanStrict()<\/code> l\u00f6st f\u00fcr alle Eingaben mit Ausnahme der Literale \u201etrue\u201c und \u201efalse\u201c eine Ausnahme aus.<\/li>\nString.toBooleanStrictOrNull()<\/code> gibt f\u00fcr alle Eingaben au\u00dfer den Literalen \u201etrue\u201c und \u201efalse\u201c null zur\u00fcck.<\/li>\n<\/ul>\n\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>\n\u00c4nderungen an der Zeitmessungs-API<\/h2>\n
Duration<\/code><\/a>. Sie repr\u00e4sentiert die Zeitspanne zwischen zwei Zeitpunkten. In 1.5.0 wurden sowohl die API als die interne Darstellung von Duration<\/code> erheblich ge\u00e4ndert.<\/p>\nDuration<\/code> verwendet jetzt Long<\/code> statt Double<\/code> f\u00fcr die interne Darstellung. Der Wertebereich von Long<\/code> erm\u00f6glicht die Darstellung von mehr als einhundert Jahren mit der Genauigkeit einer Nanosekunde oder einhundert Millionen Jahren mit der Genauigkeit einer Millisekunde. Die zuvor unterst\u00fctzten Zeitspannen im Sub-Nanosekunden-Bereich sind jedoch nicht mehr verf\u00fcgbar.<\/p>\nLong<\/code>-Wert eingef\u00fchrt. Diese sind f\u00fcr verschiedene Zeiteinheiten verf\u00fcgbar: Duration.inWholeMinutes<\/code>, Duration.inWholeSeconds<\/code> usw. Diese Funktionen ersetzen die Double<\/code>-basierten Eigenschaften wie Duration.inMinutes<\/code>.<\/p>\nDuration<\/code>-Instanzen aus ganzzahligen Werten. Sie sind direkt im Duration<\/code>-Typ definiert und ersetzen die alten Erweiterungseigenschaften von numerischen Typen wie z.\u00a0B. Int.seconds<\/code>.<\/p>\n\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>\nMathematische Operationen: abgerundete Division und Mod-Operator<\/h2>\n
\/<\/code>) bei Ganzzahlen<\/a> eine abgeschnittene Division<\/em>, bei der der nicht ganzzahlige Teil des Ergebnisses verworfen wird. In der modularen Arithmetik bietet die abgerundete Division<\/em> eine Alternative hierzu. Dabei wird das Ergebnis abgerundet (in Richtung der kleineren Ganzzahl). Bei negativen Zahlen f\u00fchrt dies zu einem anderen Ergebnis.<\/p>\n\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> vor, die eine abgerundete Division von ganzen Zahlen ausf\u00fchrt.<\/p>\n\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> ein. Diese funktioniert genau so, wie der Name erwarten l\u00e4sst \u2013 sie gibt den Rest der abgerundeten Division zur\u00fcck (Modulo<\/em>).<\/p>\nrem()<\/code> (oder dem %<\/code>-Operator) in Kotlin. Der Modulo ist der Unterschied zwischen a<\/code> und a.floorDiv(b) * b<\/code>. Ein von null abweichender Modulo hat immer das gleiche Vorzeichen wie b<\/code>, w\u00e4hrend a % b<\/code> ein anderes Vorzeichen haben kann. Dies kann zum Beispiel bei der Implementierung von zyklischen Listen hilfreich sein:<\/p>\n\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() und firstNotNullOfOrNull()<\/h2>\n
mapNotNull()<\/code> und first()<\/code> verwenden. In 1.5.0 reicht daf\u00fcr ein einziger Aufruf der neuen Funktion firstNotNullOf()<\/code>. Zusammen mit firstNotNullOf()<\/code> f\u00fchren wir auch die *orNull()<\/code>-Variante ein, die null zur\u00fcckgibt, wenn kein R\u00fcckgabewert vorhanden ist.<\/p>\n\nclass Item(val name: String?)\n<\/pre>\n
\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> und firstOrNull()<\/code> zu verwenden. Zu beachten ist dabei, dass mapNotNull()<\/code> eine tempor\u00e4re Collection mit zus\u00e4tzlichem Speicherbedarf erstellt, was insbesondere bei gro\u00dfen Collections ins Gewicht f\u00e4llt. Daher kann hier auch eine Umwandlung in eine Sequenz erforderlich sein.<\/p>\n\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\n\/\/ Option 3: new firstNotNullOfOrNull()\nreturn collection.firstNotNullOfOrNull { it.name }\n<\/pre>\n\u00c4nderungen in der Testbibliothek<\/h2>\n
kotlin-test<\/code> vorgenommen. Diesmal gibt es jedoch einige lang erwartete \u00c4nderungen. Mit 1.5.0-RC k\u00f6nnen Sie verschiedene neue Funktionen ausprobieren:<\/p>\n\n
kotlin-test<\/code>-Abh\u00e4ngigkeit in Multiplattform-Projekten.<\/li>\nAbh\u00e4ngigkeit von kotlin-test in Multiplattform-Projekten<\/h3>\n
kotlin-test<\/code> f\u00fcr alle Quellcode-Sets vereinfacht.<\/p>\nkotlin-test<\/code>-Abh\u00e4ngigkeit im gemeinsamen Test-Quellcode-Set die einzige Abh\u00e4ngigkeit, die Sie hinzuf\u00fcgen m\u00fcssen. Das Gradle-Plugin leitet daraus die entsprechende plattformspezifische Abh\u00e4ngigkeit f\u00fcr die anderen Quellcode-Sets ab:<\/p>\n\n
kotlin-test-junit<\/code> f\u00fcr JVM-Quellcode-Sets. Sie k\u00f6nnen auch zu kotlin-test-junit-5<\/code> oder kotlin-test-testng<\/code> wechseln, indem Sie diese explizit aktivieren (lesen Sie weiter, um zu erfahren, wie das geht).<\/li>\nkotlin-test-js<\/code> f\u00fcr Kotlin\/JS-Quellcode-Sets.<\/li>\nkotlin-test-common<\/code> und kotlin-test-annotations-common<\/code> f\u00fcr gemeinsame Quellcode-Sets.<\/li>\nkotlin-test<\/code>-API bereitstellt.<\/li>\n<\/ul>\nAutomatische Auswahl eines Testframeworks f\u00fcr Kotlin\/JVM-Quellcode-Sets<\/h3>\n
kotlin-test<\/code> deklariert haben, werden die JVM-Quellcode-Sets automatisch um die Abh\u00e4ngigkeit von JUnit 4 erg\u00e4nzt. Das war\u2019s! Sie k\u00f6nnen sofort mit dem Schreiben und Ausf\u00fchren von Tests loslegen!<\/p>\n\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>\n<\/p>\n\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> bzw. useTestNG()<\/code><\/a>.<\/p>\n\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> hinzuf\u00fcgen.<\/p>\nAktualisierte Assertion-Funktionen<\/h3>\n
\n
assertIs<T>()<\/code> und assertIsNot<T>()<\/code> pr\u00fcfen den Typ des Werts.<\/li>\nassertContentEquals()<\/code> vergleicht den Inhalt von Containern wie Arrays, Sequenzen und beliebigen Iterable<\/code>-Instanzen. Genauer gesagt wird gepr\u00fcft, ob expected<\/code> und actual<\/code> die gleichen Elemente in der gleichen Reihenfolge enthalten.<\/li>\nassertEquals()<\/code> und assertNotEquals()<\/code> f\u00fcr Double<\/code> und Float<\/code> haben neue \u00dcberladungen mit einem dritten Parameter: Pr\u00e4zision.<\/li>\nassertContains()<\/code> pr\u00fcft das Vorhandensein eines Elements in einem Objekt, in dem der Operator contains()<\/code> definiert ist: Array, Liste, Bereich usw.<\/li>\n<\/ul>\n\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