From e2ca1583b0cd69d9135105a6dcf716b04cd9d8d2 Mon Sep 17 00:00:00 2001
From: Alex Semin <alllexsm@gmail.com>
Date: Fri, 28 Jul 2023 11:11:53 +0200
Subject: [PATCH] Add an aspirational test for ignored tokens parsing

---
 .../kotlin/me/alllex/parsus/Tests.kt          | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/commonTest/kotlin/me/alllex/parsus/Tests.kt b/src/commonTest/kotlin/me/alllex/parsus/Tests.kt
index 38fea51..697565e 100644
--- a/src/commonTest/kotlin/me/alllex/parsus/Tests.kt
+++ b/src/commonTest/kotlin/me/alllex/parsus/Tests.kt
@@ -570,12 +570,45 @@ class Tests {
         }
     }
 
+    @Test
+    fun forceIgnoredTokenParsing() {
+        object : Grammar<SyntaxTree>() {
+            val ws by regexToken("\\s+", ignored = true)
+            val a by literalToken("a")
+            override val root by parser {
+                val a1 = lexeme(a)
+                ws()
+                val a2 = lexeme(a)
+                node(a1, a2)
+            }
+        }.run {
+            assertParsed("a a").isEqualTo(node(a.lex("a", 0), a.lex("a", 2)))
+            assertParsed(" a a ").isEqualTo(node(a.lex("a", 1), a.lex("a", 3)))
+            assertNotParsed("aa").failedWithTokenMismatch(ws, a, 1)
+            assertNotParsed(" aa").failedWithTokenMismatch(ws, a, 2)
+        }
+
+        object : Grammar<SyntaxTree>() {
+            val ws by regexToken("\\s+", ignored = true)
+            val a by literalToken("a")
+            override val root by parlex(a) and (-ws * parlex(a)) map { node(it.first, it.second) }
+        }.run {
+            assertParsed("a a").isEqualTo(node(a.lex("a", 0), a.lex("a", 2)))
+            assertParsed(" a a ").isEqualTo(node(a.lex("a", 1), a.lex("a", 3)))
+            assertNotParsed("aa").failedWithTokenMismatch(ws, a, 1)
+            assertNotParsed(" aa").failedWithTokenMismatch(ws, a, 2)
+        }
+    }
+
     companion object {
 
         private fun parlex(token: Token) = parser { lexeme(token) }
 
         private fun <T> Grammar<T>.assertParsed(text: String): Assert<T> = assertThat(parseOrThrow(text))
 
+        private fun <T> Grammar<T>.assertNotParsed(text: String): Assert<ParseError> =
+            assertThat(parse(text)).isInstanceOf(ParseError::class)
+
         private fun <T> Grammar<T>.assertThatParsing(text: String): Assert<ParseResult<T>> = assertThat(parse(text))
 
         private fun node(vararg literals: LiteralToken, startOffset: Int = 0): Node {