tdpeuter/2025LogProg-project-GhentProlog
tdpeuter/2025LogProg-project-GhentProlog
Archived
1
Fork 0
Code Issues Releases Activity Actions

Cleanup 2

Browse source
This commit is contained in:
Tibo De Peuter 2025-05-09 18:30:18 +02:00
parent a9bb6e0338
commit 3c938749d0
Signed by: tdpeuter
GPG key ID: 38297DE43F75FFE2
22 changed files with 299 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

7
tests/interpreter/ParserPreprocessorIntegrationTests.kt
View file

@ -41,10 +41,7 @@ class ParserPreprocessorIntegrationTests {
val parsed = parser.parseToEnd("X is $input") as Term
assertEquals(
Structure(Atom("is"), listOf(
Variable("X"),
Structure(Atom("-"), listOf(number)),
)),
Structure("is", Variable("X"), Structure("-",number)),
parsed
)
@ -74,7 +71,7 @@ class ParserPreprocessorIntegrationTests {
val result = parser.parseToEnd(input) as Term
assertEquals(
Structure(Atom("is"), listOf(Variable("X"), Structure(Atom("-"), listOf(Integer(1), Integer(2))))),
Structure("is", Variable("X"), Structure("-", Integer(1), Integer(2))),
result
)

32
tests/interpreter/PreprocessorTests.kt
View file

@ -37,7 +37,7 @@ class PreprocessorTests {
@Test
fun `multiple anonymous variables should be unique`() {
val input = CompoundTerm(Atom("foo"), listOf(Variable("_"), Variable("_")))
val input = CompoundTerm("foo", Variable("_"), Variable("_"))
val result = preprocessor.preprocess(input)
@ -68,7 +68,7 @@ class PreprocessorTests {
for (argument in inner.arguments) {
if ((argument as Variable).name != "Name") {
assertTrue(
(argument as Variable).name.matches("_\\d+".toRegex()),
argument.name.matches("_\\d+".toRegex()),
"Expected anonymous variable name, but got ${argument.name}"
)
}
@ -83,27 +83,13 @@ class PreprocessorTests {
test(
mapOf(
Atom("=\\=") to Atom("=\\="),
CompoundTerm(Atom("=\\="), emptyList()) to CompoundTerm(Atom("=\\="), emptyList()),
CompoundTerm("=\\=") to CompoundTerm("=\\="),
Atom("EvaluatesToDifferent") to Atom("EvaluatesToDifferent"),
CompoundTerm(Atom("EvaluatesToDifferent"), emptyList()) to CompoundTerm(
Atom("EvaluatesToDifferent"),
emptyList()
),
CompoundTerm(Atom("=\\="), listOf(Atom("a"))) to CompoundTerm(
Atom("=\\="),
listOf(Atom("a"))
),
CompoundTerm(Atom("=\\="), listOf(Integer(1))) to CompoundTerm(
Atom("=\\="),
listOf(Integer(1))
),
CompoundTerm(Atom("=\\="), listOf(Atom("=\\="))) to CompoundTerm(
Atom("=\\="),
listOf(Atom("=\\="))
),
CompoundTerm(Atom("=\\="), listOf(Integer(1), Integer(2))) to EvaluatesToDifferent(
Integer(1), Integer(2)
)
CompoundTerm("EvaluatesToDifferent") to CompoundTerm("EvaluatesToDifferent"),
CompoundTerm("=\\=", Atom("a")) to CompoundTerm("=\\=", Atom("a")),
CompoundTerm("=\\=", Integer(1)) to CompoundTerm("=\\=", Integer(1)),
CompoundTerm("=\\=", Atom("=\\=")) to CompoundTerm("=\\=", Atom("=\\=")),
CompoundTerm("=\\=", Integer(1), Integer(2)) to EvaluatesToDifferent(Integer(1), Integer(2))
)
)
}
@ -113,7 +99,7 @@ class PreprocessorTests {
test(
mapOf(
Atom("=:=") to Atom("=:="),
CompoundTerm(Atom("=:="), emptyList()) to CompoundTerm(Atom("=:="), emptyList()),
CompoundTerm("=:=") to CompoundTerm("=:="),
Atom("EvaluatesTo") to Atom("EvaluatesTo"),
CompoundTerm(Atom("EvaluatesTo"), emptyList()) to CompoundTerm(
Atom("EvaluatesTo"),

2
tests/prolog/builtins/DelimitedContinuationsOperatorsTests.kt
View file

@ -12,8 +12,6 @@ import prolog.ast.logic.Rule
import prolog.ast.terms.Atom
import prolog.ast.terms.Structure
import prolog.ast.terms.Variable
import java.io.ByteArrayOutputStream
import java.io.PrintStream
class DelimitedContinuationsOperatorsTests {
@BeforeEach

159
tests/prolog/builtins/ListOperatorsTests.kt
View file

@ -1,5 +1,6 @@
package prolog.builtins
import com.sun.source.tree.EmptyStatementTree
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Disabled
@ -7,6 +8,7 @@ import org.junit.jupiter.api.Test
import prolog.ast.lists.List.Cons
import prolog.ast.lists.List.Empty
import prolog.ast.terms.Atom
import prolog.ast.terms.Term
import prolog.ast.terms.Variable
class ListOperatorsTests {
@ -70,4 +72,161 @@ class ListOperatorsTests {
assertTrue(result[0].isSuccess, "Expected success")
assertEquals(atom, result[0].getOrNull()!![variable], "Expected variable to be unified with atom")
}
@Disabled("Not implemented yet")
@Test
fun `appended empty lists is an empty list`() {
val append = Append(Empty, Empty, Empty)
val result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
assertTrue(result[0].getOrNull()!!.isEmpty(), "Expected empty substitution map")
}
@Disabled("Not implemented yet")
@Test
fun `appending two empty lists gives an empty list`() {
val list1 = Empty
val list2 = Empty
val list12 = Variable("Result")
val append = Append(list1, list2, list12)
val result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
val subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(Empty, subs[list12], "Expected result to be empty list")
}
@Disabled("Not implemented yet")
@Test
fun `appending an empty list to another list gives that list`() {
val nonempty = Cons(Atom("a"), Empty)
var append = Append(nonempty, Empty, Empty)
var result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
assertTrue(result[0].getOrNull()!!.isEmpty(), "Expected empty substitution map")
append = Append(Empty, nonempty, Empty)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
assertTrue(result[0].getOrNull()!!.isEmpty(), "Expected empty substitution map")
val variable = Variable("List1AndList2")
append = Append(Empty, nonempty, variable)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
var subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(nonempty, subs[variable], "Expected result to be nonempty list")
append = Append(nonempty, Empty, variable)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
}
@Disabled("Not implemented yet")
@Test
fun `appending two lists gives combined list`() {
val list1 = Cons(Atom("a"), Cons(Atom("b"), Empty))
val list2 = Cons(Atom("c"), Cons(Atom("d"), Empty))
val list3 = Cons(Atom("a"), Cons(Atom("b"), Cons(Atom("c"), Cons(Atom("d"), Empty))))
val list4 = Cons(Atom("c"), Cons(Atom("d"), Cons(Atom("a"), Cons(Atom("b"), Empty))))
var append = Append(list1, list2, list3)
var result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
assertTrue(result[0].getOrNull()!!.isEmpty(), "Expected empty substitution map")
val variable = Variable("List1AndList2")
append = Append(list1, list2, variable)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
var subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(list3, subs[variable], "Expected result to be combined list")
append = Append(list2, list1, variable)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(list4, subs[variable], "Expected result to be combined list")
}
@Disabled("Not implemented yet")
@Test
fun `you can find the appended list`() {
val list1 = Cons(Atom("a"), Cons(Atom("b"), Empty))
val list2: Term = Variable("List2")
val list3 = Cons(Atom("a"), Cons(Atom("b"), Cons(Atom("c"), Cons(Atom("d"), Empty))))
var append = Append(list1, list2, list1)
var result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
var subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(Empty, subs[list2], "Expected result to be empty list")
append = Append(list1, list2, list3)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(Cons(Atom("c"), Cons(Atom("d"), Empty)), subs[list2], "Expected result to be list with c and d")
}
@Disabled("Not implemented yet")
@Test
fun `you can find the prepended list`() {
val list1 = Variable("List1")
val list2 = Cons(Atom("c"), Cons(Atom("d"), Empty))
val list3 = Cons(Atom("a"), Cons(Atom("b"), Cons(Atom("c"), Cons(Atom("d"), Empty))))
var append = Append(list1, list2, list2)
var result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
var subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(Empty, subs[list1], "Expected result to be empty list")
append = Append(list1, list2, list3)
result = append.satisfy(emptyMap()).toList()
assertEquals(1, result.size, "Expected one solution")
assertTrue(result[0].isSuccess, "Expected success")
subs = result[0].getOrNull()!!
assertEquals(1, subs.size, "Expected one substitution")
assertEquals(Cons(Atom("a"), Cons(Atom("b"), Empty)), subs[list1], "Expected result to be list with a and b")
}
}

9
tests/prolog/logic/TermAnalysisConstructionTest.kt
View file

@ -1,13 +1,10 @@
package prolog.logic
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test
import prolog.ast.terms.Atom
import prolog.ast.terms.Functor
import prolog.ast.terms.Structure
import prolog.ast.arithmetic.Integer
/**
* Based on [Predicates for analyzing/constructing terms](https://github.com/dtonhofer/prolog_notes/blob/master/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.png)
@ -27,7 +24,7 @@ class TermAnalysisConstructionTest {
@Test
fun compound_arity_0_properties() {
val structure = Structure(Atom("foo"), emptyList())
val structure = Structure("foo")
assertFalse(atomic(structure))
assertTrue(compound(structure))
@ -35,7 +32,7 @@ class TermAnalysisConstructionTest {
@Test
fun compound_arity_1_properties() {
val structure = Structure(Atom("foo"), listOf(Atom("bar")))
val structure = Structure("foo", Atom("bar"))
assertFalse(atomic(structure))
assertTrue(compound(structure))