refactor: jvm platform input stream wrapper and testcases

Author: iseki0

src/commonMain/kotlin/space/iseki/bencoding/BencodingSerializationException.kt

@@ -2,7 +2,13 @@ package space.iseki.bencoding
 
 import kotlinx.serialization.SerializationException
 
-class BencodingSerializationException(
+open class BencodingSerializationException(
     override val message: String = "",
     override val cause: Throwable? = null,
 ) : SerializationException()
+
+class BencodingDecodeException(
+    val reason: String,
+    val position: Long,
+    cause: Throwable? = null,
+) : BencodingSerializationException("decode failed at $position, $reason", cause)

src/commonMain/kotlin/space/iseki/bencoding/IO.kt

@@ -10,7 +10,7 @@ internal enum class Symbol {
 }
 
 internal interface I {
-    val pos: Int
+    val pos: Long
     fun lookahead(): Symbol
     fun readText(): ByteArray
     fun readNumber(): Long

src/commonTest/kotlin/space/iseki/bencoding/BencodingDecodeExceptionTest.kt

@@ -0,0 +1,13 @@
+package space.iseki.bencoding
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class BencodingDecodeExceptionTest{
+
+    @Test
+    fun test(){
+        val th =  checkNotNull(runCatching { throw BencodingDecodeException("test", 10) }.exceptionOrNull())
+        assertTrue { th is BencodingDecodeException && th.position == 10L && th.reason == "test" }
+    }
+}

src/jvmMain/kotlin/space/iseki/bencoding/InputStreamInput.kt

@@ -2,14 +2,17 @@ package space.iseki.bencoding
 
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.serializer
+import java.io.EOFException
 import java.io.InputStream
 
 private const val UNINITIALIZED = -2
 private const val EOF = -1
 
-internal class InputStreamI(private val inputStream: InputStream) : I {
-    override var pos: Int = 0
-        private set
+
+internal class InputStreamI(inputStream: InputStream) : I {
+    private val inputStream = CounteredInputStream(inputStream)
+    override val pos: Long
+        get() = inputStream.pos
 
     override fun lookahead(): Symbol = when (la()) {
         'l'.code -> Symbol.List
@@ -21,16 +24,28 @@ internal class InputStreamI(private val inputStream: InputStream) : I {
         else -> unrecognizedInput()
     }
 
-    override fun readText(): ByteArray = readLength().let { n -> inputStream.readNBytes(n).also { pos += n } }
+    override fun readText(): ByteArray {
+        val len = readLength()
+        if (len == 0) return ByteArray(0)
+        val buffer = ByteArray(len)
+        var p = 0
+        while (p < buffer.size) {
+            p = inputStream.read(buffer, p, buffer.size - p)
+            if (p == -1) {
+                unexpectedEOF("read $len bytes as text")
+            }
+        }
+        return buffer
+    }
 
     override fun readNumber(): Long {
         var n = 0L
         var factor = 1
-        if (read() != 'i'.code) unrecognizedInput("readNumber")
+        if (read() != 'i'.code) unrecognizedInput("read number")
         while (true) {
             when (val i = read()) {
                 '-'.code -> {
-                    if (n != 0L || factor != 1) unrecognizedInput("readNumber")
+                    if (n != 0L || factor != 1) unrecognizedInput("read number")
                     factor = -1
                 }
 
@@ -39,7 +54,8 @@ internal class InputStreamI(private val inputStream: InputStream) : I {
                 }
 
                 'e'.code -> break
-                else -> unrecognizedInput("readNumber")
+                EOF -> unexpectedEOF("read number")
+                else -> unrecognizedInput("read number")
             }
         }
         return n
@@ -49,20 +65,28 @@ internal class InputStreamI(private val inputStream: InputStream) : I {
         when (lookahead()) {
             Symbol.EOF -> return
             Symbol.Dict, Symbol.List, Symbol.End -> read()
-            Symbol.Text -> readLength().let { n -> inputStream.skipNBytes(n.toLong()); pos += n }
+            Symbol.Text -> {
+                val len = readLength()
+                try {
+                    inputStream.skipNBytes(len.toLong())
+                } catch (ex: EOFException) {
+                    unexpectedEOF("skip $len bytes")
+                }
+            }
+
             Symbol.Integer -> readNumber()
         }
     }
 
     private var _la = UNINITIALIZED
 
     private fun la() = when (_la) {
-        UNINITIALIZED -> inputStream.read().also { _la = it;pos++ }
+        UNINITIALIZED -> inputStream.read().also { _la = it }
         else -> _la
     }
 
     private fun read() = when (_la) {
-        UNINITIALIZED -> inputStream.read().also { pos++ }
+        UNINITIALIZED -> inputStream.read()
         else -> _la.also { _la = UNINITIALIZED }
     }
 
@@ -72,21 +96,37 @@ internal class InputStreamI(private val inputStream: InputStream) : I {
             when (val i = read()) {
                 in '0'.code..'9'.code -> l = l * 10 + (i - '0'.code)
                 ':'.code -> break
-                else -> unrecognizedInput("readLength")
+                EOF -> unexpectedEOF("read length")
+                else -> unrecognizedInput("read length")
             }
             if (l < 0) error("length overflow")
         }
+
         return l
     }
 
+    private fun unexpectedEOF(during: String = ""): Nothing = when {
+        during.isEmpty() -> "unexpected EOF"
+        else -> "unexpected EOF during $during"
+    }.let { error(it) }
+
     private fun unrecognizedInput(during: String = ""): Nothing = when {
         during.isEmpty() -> "unrecognized input"
         else -> "unrecognized input, during $during"
-    }.let { throw BencodingSerializationException(it) }
+    }.let { throw BencodingDecodeException(it, pos) }
 
-    @Suppress("SameParameterValue")
-    private fun error(msg: String): Nothing = throw BencodingSerializationException(msg)
+    private fun error(reason: String, cause: Throwable? = null): Nothing =
+        throw BencodingDecodeException(reason, pos, cause)
 
+    private class CounteredInputStream(private val inputStream: InputStream) : InputStream() {
+        var pos = 0L
+            private set
+
+        override fun read(): Int = inputStream.read().also { if (it > 0) pos += it }
+        override fun skip(n: Long): Long = inputStream.skip(n).also { if (it > 0) pos += it }
+        override fun read(b: ByteArray, off: Int, len: Int): Int =
+            inputStream.read(b, off, len).also { if (it > 0) pos += it }
+    }
 }
 
 inline fun <reified T> InputStream.decodeInBencoding() = decodeInBencoding(serializer<T>())