testejä

src/main/kotlin/guru/kake/xmlp/XMLParser.kt

 package guru.kake.xmlp
 
 import java.io.FileInputStream
+import java.io.InputStream
 import javax.xml.namespace.QName
 import javax.xml.stream.XMLEventReader
 import javax.xml.stream.XMLInputFactory
@@ -14,18 +15,25 @@ annotation class DSL
  * Implements a DSL-language for event-based parsing of XML files.
  */
 @DSL
-class XMLParser private constructor(path: String) {
+class XMLParser private constructor(stream: InputStream) {
     companion object {
         /**
          * Parse an XML-file using an event-based interface
          * @param path path to file
          * @param init lambda to execute on each XML event
          */
-        fun parse(path: String, init: XMLParser.() -> Unit): Unit = XMLParser(path).init(init)
+        fun parse(path: String, init: XMLParser.() -> Unit): Unit = XMLParser(FileInputStream(path)).init(init)
+
+        /**
+         * Parse an XML-file using an event-based interface
+         * @param stream [InputStream] containing XML data
+         * @param init lambda to execute on each XML event
+         */
+        fun parse(stream: InputStream, init: XMLParser.() -> Unit): Unit = XMLParser(stream).init(init)
     }
 
     private val factory: XMLInputFactory = XMLInputFactory.newInstance()
-    private val reader: XMLEventReader = factory.createXMLEventReader(FileInputStream(path))
+    private val reader: XMLEventReader = factory.createXMLEventReader(stream)
     private val elements: MutableMap<String, Element> = mutableMapOf()
 
     private fun init(init: XMLParser.() -> Unit) {

src/test/kotlin/guru/kake/xmlp/XMLParserTest.kt

+package guru.kake.xmlp
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import kotlin.test.assertFailsWith
+
+class XMLParserTest {
+
+    private val xml: String ="""
+        <tag>
+            <tag><cont foo="not" bar="not">one</cont></tag>
+            <tag><attr foo="two" bar="not">not</attr></tag>
+            <tag><tag><both foo="not" bar="three">four</both></tag></tag>
+            <attr foo="five" />
+        </tag>
+        """.trimIndent()
+
+    private val eof: String ="""
+        <tag><tag><tag></tag></tag>
+        """.trimIndent()
+
+    private val close: String ="""
+        <tag></tag></tag>
+        """.trimIndent()
+
+
+    @Test fun parseXML() {
+        val sb = StringBuilder()
+        XMLParser.parse(xml.byteInputStream()) {
+            element("cont") {
+                start { sb.append(content()) }
+            }
+            element("attr") {
+                start { sb.append(attribute("foo"))}
+            }
+            element("both") {
+                start {
+                    sb.append(content())
+                    sb.append(attribute("bar"))
+                }
+            }
+            element("tag") {
+                start {
+                    sb.append("{")
+                }
+                end{
+                    sb.append("}")
+                }
+            }
+        }
+        assertEquals(sb.toString(),"{{one}{two}{{fourthree}}five}")
+    }
+
+    @Test fun malformed() {
+        assertFailsWith<com.ctc.wstx.exc.WstxEOFException> { XMLParser.parse(eof.byteInputStream()) {}}
+        assertFailsWith<com.ctc.wstx.exc.WstxParsingException> { XMLParser.parse(close.byteInputStream()) {}}
+    }
+}
\ No newline at end of file