stdlib: improve tests

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))
+    }
+}

libraries/stdlib/test/io/IoTest.kt

@@ -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<ArrayList<String>>{ it.toArrayList() }
-
-        assertEquals(arrayListOf("Hello", "World"), list1)
-        assertEquals(arrayListOf("Hello", "World"), list2)
-    }
-
-    test fun testForEach() {
-        val list = ArrayList<String>()
-        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<String>()
-
-        /* 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<String>()
-        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()
-    }
-
-}

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<String>()
+
+        /* 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<String>()
+        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<ArrayList<String>>{ 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<String>(), 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<String>()
+        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)
+    }
+}