From 9b454a9669c49842b4e4d64423ebe781c86b9cdd Mon Sep 17 00:00:00 2001
From: Tibo De Peuter <Tibo.DePeuter@UGent.be>
Date: Thu, 8 May 2025 19:14:48 +0200
Subject: [PATCH] test: Meta examples

---
 examples/meta/mib_voorbeelden.pl           | 48 ++++++++++++++++++++++
 src/prolog/ast/terms/Structure.kt          |  2 +-
 tests/e2e/Examples.kt                      | 11 +++++
 tests/parser/grammars/LogicGrammarTests.kt |  2 +-
 tests/prolog/builtins/IoOperatorsTests.kt  |  2 +-
 5 files changed, 62 insertions(+), 3 deletions(-)
 create mode 100644 examples/meta/mib_voorbeelden.pl

diff --git a/examples/meta/mib_voorbeelden.pl b/examples/meta/mib_voorbeelden.pl
new file mode 100644
index 0000000..47003d5
--- /dev/null
+++ b/examples/meta/mib_voorbeelden.pl
@@ -0,0 +1,48 @@
+% Old mag steeds door New vervangen worden
+mib(Old, New, Old, New).
+
+% Een term blijft enkel behouden als het een attoom is
+% (dat is, niet compound), en als het niet Old is
+mib(Old, _, Term, Term) :-
+    atomic(Term),
+    Term \= Old.
+
+% Voor een samengestelde Term
+mib(Old, New, Pre, Post) :-
+    compound(Pre),
+    functor(Pre,  F, N), % Pre heeft naam F en arriteit N
+    functor(Post, F, N), % Post is term met zelfde naam (F) en arriteit (N)
+    mib(N, Old, New, Pre, Post).
+
+% Extra predicaat om de argumenten te vervangen van een samengestelde term
+%
+% N = het nr van het argument (strikt positief)
+mib(0, _, _, _, _) :- !. % Argument 0 bestaat niet, als we hier komen zijn we klaar.
+
+mib(N, Old, New, Pre, Post) :-
+    arg(N, Pre, ArgPre),            % neem het N-de argument
+    mib(Old, New, ArgPre, ArgPost), % vertaal het
+    arg(N, Post, ArgPost),          % unificeer het met het N-de argument van output
+    N1 is N-1,
+    mib(N1, Old, New, Pre, Post).   % Herhaal voor argument N-1
+
+example1 :-
+    mib(a, b, a, Result),
+    write(Result), nl.
+example2 :-
+    mib(a, b, f(a), Result),
+    write(Result), nl.
+example3 :-
+    mib(b, a, f(g(a, b), h(c, d), i(e, f)), Result),
+    write(Result), nl,
+    mib(d, c, Result, Result2),
+    write(Result2), nl,
+    mib(f, e, Result2, Result3),
+    write(Result3), nl.
+
+main :-
+    example1,
+    example2,
+    example3.
+
+:- initialization(main).
diff --git a/src/prolog/ast/terms/Structure.kt b/src/prolog/ast/terms/Structure.kt
index e17b987..b6d41fe 100644
--- a/src/prolog/ast/terms/Structure.kt
+++ b/src/prolog/ast/terms/Structure.kt
@@ -21,7 +21,7 @@ open class Structure(val name: Atom, var arguments: List<Argument>) : Goal(), He
     override fun toString(): String {
         return when {
             arguments.isEmpty() -> name.name
-            else -> "${name.name}(${arguments.joinToString(", ")})"
+            else -> "${name.name}(${arguments.joinToString(",")})"
         }
     }
 
diff --git a/tests/e2e/Examples.kt b/tests/e2e/Examples.kt
index bafef47..4c86e0d 100644
--- a/tests/e2e/Examples.kt
+++ b/tests/e2e/Examples.kt
@@ -37,6 +37,13 @@ class Examples {
         assertEquals(expected, outStream.toString())
     }
 
+    @ParameterizedTest
+    @MethodSource("meta")
+    fun `Identical output for meta`(inputFile: String, expected: String) {
+        loader.load("examples/meta/$inputFile")
+        assertEquals(expected, outStream.toString())
+    }
+
     @ParameterizedTest
     @MethodSource("other")
     fun `Identical output for other`(inputFile: String, expected: String) {
@@ -57,6 +64,10 @@ class Examples {
         Arguments.of("write.pl", "gpl zegt: dag(wereld)\n"),
     )
 
+    fun meta() = listOf(
+        Arguments.of("mib_voorbeelden.pl", "b\nf(b)\nf(g(a,a),h(c,d),i(e,f))\nf(g(a,a),h(c,c),i(e,f))\nf(g(a,a),h(c,c),i(e,e))\n")
+    )
+
     fun other() = listOf(
         Arguments.of("program.pl", "10\nhello(world)")
     )
diff --git a/tests/parser/grammars/LogicGrammarTests.kt b/tests/parser/grammars/LogicGrammarTests.kt
index cbcb949..f5cde74 100644
--- a/tests/parser/grammars/LogicGrammarTests.kt
+++ b/tests/parser/grammars/LogicGrammarTests.kt
@@ -32,7 +32,7 @@ class LogicGrammarTests {
         "male(jimmy).",
         "female(mary).",
         "not(not(true)).",
-        "not(a, not(b, c), d, not(not(a)))."
+        "not(a,not(b,c),d,not(not(a)))."
     ])
     fun `parse simple fact`(input: String) {
         val result = parser.parseToEnd(input)
diff --git a/tests/prolog/builtins/IoOperatorsTests.kt b/tests/prolog/builtins/IoOperatorsTests.kt
index 05607ec..6bf8ee0 100644
--- a/tests/prolog/builtins/IoOperatorsTests.kt
+++ b/tests/prolog/builtins/IoOperatorsTests.kt
@@ -55,7 +55,7 @@ class IoOperatorsTests {
 
         assertEquals(1, result.size, "Should return one result")
         assertTrue(result[0].isSuccess, "Result should be successful")
-        assertEquals("person(john, doe)", outStream.toString().trim(), "Output should match the structure")
+        assertEquals("person(john,doe)", outStream.toString().trim(), "Output should match the structure")
     }
 
     @Test