Merge branch 'feature/libraries' into feature/testing

solve-classic/src/commonTest/kotlin/it/unibo/tuprolog/solve/systemtest/TestClassicSolver.kt

@@ -1,13 +1,7 @@
 package it.unibo.tuprolog.solve.systemtest
 
 import it.unibo.tuprolog.solve.*
-import it.unibo.tuprolog.solve.channel.InputChannel
-import it.unibo.tuprolog.solve.channel.OutputChannel
-import it.unibo.tuprolog.solve.exception.PrologWarning
-import it.unibo.tuprolog.solve.library.AliasedLibrary
-import it.unibo.tuprolog.solve.library.Libraries
-import it.unibo.tuprolog.solve.stdlib.DefaultBuiltins
-import it.unibo.tuprolog.theory.Theory
+import kotlin.test.Ignore
 import kotlin.test.Test
 
 class TestClassicSolver : TestSolver, SolverFactory by ClassicSolverFactory {
@@ -294,4 +288,63 @@ class TestClassicSolver : TestSolver, SolverFactory by ClassicSolverFactory {
     override fun testAppend() {
         prototype.testAppend()
     }
+
+    @Test
+    override fun testTermGreaterThan() {
+        prototype.testTermGreaterThan()
+    }
+
+    @Test
+    override fun testTermSame() {
+        prototype.testTermSame()
+    }
+
+    @Test
+    override fun testTermLowerThan() {
+        prototype.testTermLowerThan()
+    }
+
+    @Test
+    override fun testTermGreaterThanOrEqual() {
+        prototype.testTermGreaterThanOrEqual()
+    }
+
+    @Test
+    override fun testTermLowerThanOrEqual() {
+        prototype.testTermLowerThanOrEqual()
+    }
+
+    @Test
+    override fun testTermNotSame() {
+        prototype.testTermNotSame()
+    }
+
+    @Test
+    override fun testAtomChars() {
+        prototype.testAtomChars()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomLength() {
+        prototype.testAtomLength()
+    }
+
+    @Test
+    @Ignore
+    override fun testCharCode() {
+        prototype.testCharCode()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomCodes() {
+        prototype.testAtomCodes()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomConcat() {
+        prototype.testAtomConcat()
+    }
 }

solve-streams/src/commonTest/kotlin/it/unibo/tuprolog/solve/systemtest/TestStreamsSolver.kt

@@ -333,4 +333,64 @@ class TestStreamsSolver : SolverFactory, TestSolver {
     override fun testAppend() {
         prototype.testAppend()
     }
+
+    @Test
+    override fun testTermGreaterThan() {
+        prototype.testTermGreaterThan()
+    }
+
+    @Test
+    override fun testTermSame() {
+        prototype.testTermSame()
+    }
+
+    @Test
+    override fun testTermLowerThan() {
+        prototype.testTermLowerThan()
+    }
+
+    @Test
+    override fun testTermGreaterThanOrEqual() {
+        prototype.testTermGreaterThanOrEqual()
+    }
+
+    @Test
+    override fun testTermLowerThanOrEqual() {
+        prototype.testTermLowerThanOrEqual()
+    }
+
+    @Test
+    override fun testTermNotSame() {
+        prototype.testTermNotSame()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomChars() {
+        prototype.testAtomChars()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomLength() {
+        prototype.testAtomLength()
+    }
+
+    @Test
+    @Ignore
+    override fun testCharCode() {
+        prototype.testCharCode()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomCodes() {
+        prototype.testAtomCodes()
+    }
+
+    @Test
+    @Ignore
+    override fun testAtomConcat() {
+        prototype.testAtomConcat()
+    }
 }

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/exception/error/TypeError.kt

@@ -51,6 +51,21 @@ class TypeError(
 
         // TODO: 16/01/2020 test factories
 
+        fun forArgumentList(
+            context: ExecutionContext,
+            procedure: Signature,
+            expectedType: Expected,
+            actualValue: Term,
+            index: Int? = null
+        ) = TypeError(
+            message = "Argument ${index
+                ?: ""} of `${procedure.toIndicator()}` should be a list of `$expectedType`, but `$actualValue` has been provided instead",
+            context = context,
+            expectedType = expectedType,
+            actualValue = actualValue,
+            extraData = actualValue
+        )
+
         fun forArgument(
             context: ExecutionContext,
             procedure: Signature,

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/primitive/PrimitiveWrapper.kt

@@ -9,6 +9,7 @@ import it.unibo.tuprolog.solve.exception.error.DomainError
 import it.unibo.tuprolog.solve.exception.error.InstantiationError
 import it.unibo.tuprolog.solve.exception.error.TypeError
 import org.gciatto.kt.math.BigInteger
+import it.unibo.tuprolog.core.List as LogicList
 
 /**
  * Wrapper class for [Primitive] implementation
@@ -142,6 +143,12 @@ abstract class PrimitiveWrapper<C : ExecutionContext> : AbstractWrapper<Primitiv
                 else -> this
             }
 
+        fun <C : ExecutionContext> Solve.Request<C>.ensuringArgumentIsList(index: Int): Solve.Request<C> =
+            when (val arg = arguments[index]) {
+                !is LogicList -> throw TypeError.forArgument(context, signature, TypeError.Expected.LIST, arg, index)
+                else -> this
+            }
+
         fun <C : ExecutionContext> Solve.Request<C>.ensuringArgumentIsNonNegativeInteger(index: Int): Solve.Request<C> =
             arguments[index].let { arg ->
                 when {

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/stdlib/CommonBuiltins.kt

@@ -24,6 +24,7 @@ object CommonBuiltins : AliasedLibrary by Library.aliased(
         AssertA,
         AssertZ,
         Atom,
+        AtomChars,
         Atomic,
         Between,
         Callable,
@@ -52,6 +53,8 @@ object CommonBuiltins : AliasedLibrary by Library.aliased(
         TermLowerThan,
         TermLowerThanOrEqualTo,
         TermNotIdentical,
+        TermNotSame,
+        TermSame,
         UnifiesWith,
         Univ,
         Var,

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/stdlib/primitive/AtomChars.kt

@@ -0,0 +1,50 @@
+package it.unibo.tuprolog.solve.stdlib.primitive
+
+import it.unibo.tuprolog.core.Atom
+import it.unibo.tuprolog.core.Substitution
+import it.unibo.tuprolog.core.Term
+import it.unibo.tuprolog.core.Var
+import it.unibo.tuprolog.solve.ExecutionContext
+import it.unibo.tuprolog.solve.exception.error.TypeError
+import it.unibo.tuprolog.solve.primitive.BinaryRelation
+import it.unibo.tuprolog.solve.primitive.Solve
+import it.unibo.tuprolog.unify.Unificator.Companion.mguWith
+import it.unibo.tuprolog.core.List as LogicList
+
+object AtomChars : BinaryRelation.Functional<ExecutionContext>("atom_chars") {
+    override fun Solve.Request<ExecutionContext>.computeOneSubstitution(first: Term, second: Term): Substitution =
+        when {
+            first is Var && second is Var -> {
+                ensuringAllArgumentsAreInstantiated()
+                Substitution.failed()
+            }
+            first is Var -> {
+                ensuringArgumentIsList(1)
+                val chars = second as LogicList
+                val atom: Atom = Atom.of(
+                    chars.toSequence().map {
+                        if (it is Atom) {
+                            it.value[0]
+                        } else {
+                            throw TypeError.forArgumentList(context, signature, TypeError.Expected.CHARACTER, it, 1)
+                        }
+                    }.joinToString("")
+                )
+                Substitution.of(first, atom)
+            }
+            second is Var -> {
+                ensuringArgumentIsAtom(0)
+                val charArray = (first as Atom).value.toCharArray()
+                val chars = LogicList.of(charArray.map { Atom.of("" + it) })
+                Substitution.of(second, chars)
+            }
+            else -> {
+                ensuringArgumentIsAtom(0)
+                ensuringArgumentIsList(1)
+                val chars = LogicList.of(
+                    (first as Atom).value.toCharArray().map { Atom.of("" + it) }
+                )
+                chars mguWith second
+            }
+        }
+}

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/stdlib/primitive/TermNotSame.kt

@@ -0,0 +1,13 @@
+package it.unibo.tuprolog.solve.stdlib.primitive
+
+import it.unibo.tuprolog.core.Term
+import it.unibo.tuprolog.solve.ExecutionContext
+import it.unibo.tuprolog.solve.primitive.Solve
+import it.unibo.tuprolog.solve.primitive.BinaryRelation
+
+/** Implementation of '=='/2 predicate */
+object TermNotSame : BinaryRelation.Predicative<ExecutionContext>("\\=@=") {
+    override fun Solve.Request<ExecutionContext>.compute(first: Term, second: Term): Boolean {
+        return first.compareTo(second) != 0
+    }
+}

solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/stdlib/primitive/TermSame.kt

@@ -0,0 +1,13 @@
+package it.unibo.tuprolog.solve.stdlib.primitive
+
+import it.unibo.tuprolog.core.Term
+import it.unibo.tuprolog.solve.ExecutionContext
+import it.unibo.tuprolog.solve.primitive.Solve
+import it.unibo.tuprolog.solve.primitive.BinaryRelation
+
+/** Implementation of '=='/2 predicate */
+object TermSame : BinaryRelation.Predicative<ExecutionContext>("=@=") {
+    override fun Solve.Request<ExecutionContext>.compute(first: Term, second: Term): Boolean {
+        return first.compareTo(second) == 0
+    }
+}

test-solve/src/commonMain/kotlin/it/unibo/tuprolog/solve/TestSolver.kt

@@ -158,5 +158,27 @@ interface TestSolver : SolverTest {
     fun testUniv()
     fun testAppend()
     fun testRetractAll()
+
+    fun testTermGreaterThan()
+    fun testTermGreaterThanOrEqual()
+    fun testTermSame()
+    fun testTermNotSame()
+    fun testTermLowerThan()
+    fun testTermLowerThanOrEqual()
+
+    /** atom_chars/2 test */
+    fun testAtomChars()
+
+    /** atom_length test */
+    fun testAtomLength()
+
+    /** char_code/2 test */
+    fun testCharCode()
+
+    /** atom_codes/2 test */
+    fun testAtomCodes()
+
+    /** atom_concat/3 test */
+    fun testAtomConcat()
 }