From 80493aa4e6303597988faebcae5deda04fa06f41 Mon Sep 17 00:00:00 2001 From: Denis Mekhanikov Date: Wed, 15 Oct 2014 19:48:37 +0400 Subject: [PATCH] stdlib: improve tests --- libraries/stdlib/test/io/Files.kt | 62 ++++++++++ libraries/stdlib/test/io/IoTest.kt | 156 -------------------------- libraries/stdlib/test/io/ReadWrite.kt | 149 ++++++++++++++++++++++++ 3 files changed, 211 insertions(+), 156 deletions(-) create mode 100644 libraries/stdlib/test/io/Files.kt delete mode 100644 libraries/stdlib/test/io/IoTest.kt create mode 100644 libraries/stdlib/test/io/ReadWrite.kt diff --git a/libraries/stdlib/test/io/Files.kt b/libraries/stdlib/test/io/Files.kt new file mode 100644 index 00000000000..e52b4986590 --- /dev/null +++ b/libraries/stdlib/test/io/Files.kt @@ -0,0 +1,62 @@ +package test.io + +import org.junit.Test as test +import java.io.File +import kotlin.test.assertEquals + +class FilesTest { + test fun listFilesWithFilter() { + val dir = File.createTempFile("temp", System.nanoTime().toString()) + dir.delete() + dir.mkdir() + + File.createTempFile("temp1", ".kt", dir) + File.createTempFile("temp2", ".java", dir) + File.createTempFile("temp3", ".kt", dir) + + val result = dir.listFiles { it.getName().endsWith(".kt") } + assertEquals(2, result!!.size) + } + + test fun recurse() { + val dir = File.createTempFile("temp", System.nanoTime().toString()) + dir.delete() + + var totalFiles = 0 + dir.recurse { totalFiles++ } + assertEquals(1, totalFiles) + + dir.mkdir() + + File.createTempFile("temp", "1.kt", dir) + File.createTempFile("temp", "2.java", dir) + + val subdir = File(dir, "subdir") + subdir.mkdir() + + File(subdir, "3.txt").createNewFile() + + totalFiles = 0 + dir.recurse { totalFiles++ } + + assertEquals(5, totalFiles) + + if (subdir.setReadable(false)) { + // On Windows, we can't make directory not readable, and setReadable() will return false + + totalFiles = 0 + dir.recurse { totalFiles++ } + assertEquals(4, totalFiles) + } + } + + test fun relativePath() { + val file1 = File("src") + val file2 = File(file1, "kotlin") + val file3 = File("test") + + assertEquals("kotlin", file1.relativePath(file2)) + assertEquals("", file1.relativePath(file1)) + assertEquals(file3.canonicalPath, file1.relativePath(file3)) + } +} diff --git a/libraries/stdlib/test/io/IoTest.kt b/libraries/stdlib/test/io/IoTest.kt deleted file mode 100644 index ab275c9d1ef..00000000000 --- a/libraries/stdlib/test/io/IoTest.kt +++ /dev/null @@ -1,156 +0,0 @@ -package test.io - -import kotlin.test.* - -import kotlin.io.* -import kotlin.util.* -import java.io.* -import java.util.* -import org.junit.Test as test - -class IoTest(){ - test fun testLineIteratorWithManualClose() { - val reader = sample().buffered() - try { - val list = reader.lines().toArrayList() - assertEquals(arrayListOf("Hello", "World"), list) - } finally { - reader.close() - } - } - - fun sample(): Reader { - return StringReader("Hello\nWorld"); - } - - test fun testLineIterator() { - // TODO we should maybe zap the useLines approach as it encourages - // use of iterators which don't close the underlying stream - val list1 = sample().useLines{ it.toArrayList() } - val list2 = sample().useLines>{ it.toArrayList() } - - assertEquals(arrayListOf("Hello", "World"), list1) - assertEquals(arrayListOf("Hello", "World"), list2) - } - - test fun testForEach() { - val list = ArrayList() - val reader = sample().buffered() - - reader.use{ - while (true) { - val line = it.readLine() - if (line != null) - list.add(line) - else - break - } - } - - assertEquals(arrayListOf("Hello", "World"), list) - } - - test fun testForEachLine() { - val list = ArrayList() - - /* TODO would be nicer maybe to write this as - reader.lines.forEach { ... } - - as we could one day maybe one day write that as - for (line in reader.lines) - - if the for(elem in thing) {...} statement could act as syntax sugar for - thing.forEach{ elem -> ... } - - if thing is not an Iterable/array/Iterator but has a suitable forEach method - */ - sample().forEachLine { - list.add(it) - } - - assertEquals(arrayListOf("Hello", "World"), list) - - var count = 0 - sample().forEachLine { - count += 1 - } - - assertEquals(2, count) - } - - test fun testForEachLineFile() { - val file = File.createTempFile("temp", System.nanoTime().toString()) - file.writeText("Hello\nWorld") - - - val list = ArrayList() - file.forEachLine{ - list.add(it) - } - - assertEquals(arrayListOf("Hello", "World"), list) - file.deleteOnExit() - } - - test fun testListFiles() { - val dir = File.createTempFile("temp", System.nanoTime().toString()) - dir.delete() - dir.mkdir() - - File.createTempFile("temp", "1.kt", dir) - File.createTempFile("temp", "2.java", dir) - File.createTempFile("temp", "3.kt", dir) - - val result = dir.listFiles { it.getName().endsWith(".kt") } - - assertNotNull(result) - assertEquals(result!!.size, 2) - } - - test fun relativePath() { - val file1 = File("src") - val file2 = File(file1, "kotlin") - val file3 = File("test") - - assertEquals("kotlin", file1.relativePath(file2)) - assertEquals("", file1.relativePath(file1)) - assertEquals(file3.canonicalPath, file1.relativePath(file3)) - } - - test fun listFiles() { - val dir = File.createTempFile("temp", System.nanoTime().toString()) - dir.delete() - dir.mkdir() - - File.createTempFile("temp", "1.kt", dir) - File.createTempFile("temp", "2.java", dir) - - val subdir = File(dir, "subdir") - subdir.mkdir() - - File(subdir, "3.txt").createNewFile() - - var totalFiles = 0 - dir.recurse { totalFiles++ } - - assertEquals(5, totalFiles) - - if (subdir.setReadable(false)) { - // On Windows, we can't make directory not readable, and setReadable() will return false - - var totalFilesWithUnReadableDir = 0 - dir.recurse { totalFilesWithUnReadableDir++ } - assertEquals(4, totalFilesWithUnReadableDir) - } - } - - test fun testAppendText() { - val file = File.createTempFile("temp", System.nanoTime().toString()) - file.writeText("Hello\n") - file.appendText("World") - - assertEquals("Hello\nWorld", file.readText()) - file.deleteOnExit() - } - -} diff --git a/libraries/stdlib/test/io/ReadWrite.kt b/libraries/stdlib/test/io/ReadWrite.kt new file mode 100644 index 00000000000..f171bf880fe --- /dev/null +++ b/libraries/stdlib/test/io/ReadWrite.kt @@ -0,0 +1,149 @@ +package test.io + +import org.junit.Test as test +import java.io.File +import kotlin.test.assertEquals +import java.io.Reader +import java.io.StringReader +import java.util.ArrayList + +fun sample(): Reader = StringReader("Hello\nWorld"); + +class ReadWriteTest { + test fun testAppendText() { + val file = File.createTempFile("temp", System.nanoTime().toString()) + file.writeText("Hello\n") + file.appendText("World") + + assertEquals("Hello\nWorld", file.readText()) + file.deleteOnExit() + } + + test fun reader() { + val list = ArrayList() + + /* TODO would be nicer maybe to write this as + reader.lines.forEach { ... } + + as we could one day maybe write that as + for (line in reader.lines) + + if the for(elem in thing) {...} statement could act as syntax sugar for + thing.forEach{ elem -> ... } + + if thing is not an Iterable/array/Iterator but has a suitable forEach method + */ + sample().forEachLine { + list.add(it) + } + assertEquals(arrayListOf("Hello", "World"), list) + + var reader = StringReader("") + var c = 0 + reader.forEachLine { c++ } + assertEquals(0, c) + + reader = StringReader(" ") + reader.forEachLine { c++ } + assertEquals(1, c) + + reader = StringReader(" \n") + c = 0 + reader.forEachLine { c++ } + assertEquals(1, c) + + reader = StringReader(" \n ") + c = 0 + reader.forEachLine { c++ } + assertEquals(2, c) + } + + test fun file() { + val file = File.createTempFile("temp", System.nanoTime().toString()) + + file.writeText("Hello\nWorld") + val list = ArrayList() + file.forEachLine{ + list.add(it) + } + assertEquals(arrayListOf("Hello", "World"), list) + + file.writeText("") + var c = 0 + file.forEachLine { c++ } + assertEquals(0, c) + + file.writeText(" ") + file.forEachLine { c++ } + assertEquals(1, c) + + file.writeText(" \n") + c = 0 + file.forEachLine { c++ } + assertEquals(1, c) + + file.writeText(" \n ") + c = 0 + file.forEachLine { c++ } + assertEquals(2, c) + + file.deleteOnExit() + } + + class LineIteratorTest { + test fun useLines() { + // TODO we should maybe zap the useLines approach as it encourages + // use of iterators which don't close the underlying stream + val list1 = sample().useLines { it.toArrayList() } + val list2 = sample().useLines>{ it.toArrayList() } + + assertEquals(arrayListOf("Hello", "World"), list1) + assertEquals(arrayListOf("Hello", "World"), list2) + } + + test fun manualClose() { + val reader = sample().buffered() + try { + val list = reader.lines().toArrayList() + assertEquals(arrayListOf("Hello", "World"), list) + } finally { + reader.close() + } + } + + test fun boundaryConditions() { + var reader = StringReader("").buffered() + assertEquals(ArrayList(), reader.lines().toArrayList()) + reader.close() + + reader = StringReader(" ").buffered() + assertEquals(arrayListOf(" "), reader.lines().toArrayList()) + reader.close() + + reader = StringReader(" \n").buffered() + assertEquals(arrayListOf(" "), reader.lines().toArrayList()) + reader.close() + + reader = StringReader(" \n ").buffered() + assertEquals(arrayListOf(" ", " "), reader.lines().toArrayList()) + reader.close() + } + } + + test fun testUse() { + val list = ArrayList() + val reader = sample().buffered() + + reader.use { + while (true) { + val line = it.readLine() + if (line != null) + list.add(line) + else + break + } + } + + assertEquals(arrayListOf("Hello", "World"), list) + } +}