All Downloads are FREE. Search and download functionalities are using the official Maven repository.

commonTest.it.unibo.tuprolog.solve.library.LibrariesTest.kt Maven / Gradle / Ivy

package it.unibo.tuprolog.solve.library

import it.unibo.tuprolog.solve.library.exception.AlreadyLoadedLibraryException
import it.unibo.tuprolog.solve.library.testutils.LibraryUtils
import it.unibo.tuprolog.solve.library.testutils.LibraryUtils.aliasLibraryMap
import it.unibo.tuprolog.solve.library.testutils.LibraryUtils.aliasPrimitiveOrFunction
import it.unibo.tuprolog.solve.library.testutils.LibraryUtils.libraryWithAliasConstructor
import it.unibo.tuprolog.solve.library.testutils.LibraryUtils.makeLib
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertNotEquals

/**
 * Test class for [Runtime] and [Runtime]
 *
 * @author Enrico
 */
internal class LibrariesTest {

    private val emptyLibrary = makeLib(LibraryUtils.emptyLibrary, ::libraryWithAliasConstructor)
    private val library = makeLib(LibraryUtils.library, ::libraryWithAliasConstructor)
    private val overridingLibrary = makeLib(LibraryUtils.overridingLibrary, ::libraryWithAliasConstructor)
    private val overriddenLibrary = makeLib(LibraryUtils.overriddenLibrary, ::libraryWithAliasConstructor)
    private val duplicatedAliasLibrary = makeLib(LibraryUtils.duplicatedAliasLibrary, ::libraryWithAliasConstructor)

    private val differentAliasInstances = listOf(emptyLibrary, library, overridingLibrary, overriddenLibrary)
    private val allLibInstances =
        listOf(emptyLibrary, library, overridingLibrary, overriddenLibrary, duplicatedAliasLibrary)

    /** A test instance with [differentAliasInstances] */
    private val librariesInstance = Runtime.of(differentAliasInstances)

    @Test
    fun iterableConstructor() {
        assertEquals(differentAliasInstances.toSet(), Runtime.of(differentAliasInstances).libraries.toSet())
    }

    @Test
    fun sequenceConstructor() {
        assertEquals(differentAliasInstances.toSet(), Runtime.of(differentAliasInstances.asSequence()).libraries.toSet())
    }

    @Test
    fun varargConstructor() {
        assertEquals(
            differentAliasInstances.toSet(),
            Runtime.of(*differentAliasInstances.toTypedArray()).libraries.toSet()
        )
    }

    @Test
    fun constructorsOverrideDuplicatedAliasesLibrariesWithLastInOrder() {
        assertEquals((allLibInstances - library).toSet(), Runtime.of(allLibInstances).libraries.toSet())
        assertEquals((allLibInstances - library).toSet(), Runtime.of(*allLibInstances.toTypedArray()).libraries.toSet())
        assertEquals((allLibInstances - library).toSet(), Runtime.of(allLibInstances.asSequence()).libraries.toSet())
    }

    @Test
    fun librariesReturnsAllCurrentlyPresentLibraries() {
        assertEquals(differentAliasInstances.toSet(), librariesInstance.libraries.toSet())
    }

    @Test
    fun libraryAliasesCorrect() {
        assertEquals(differentAliasInstances.map { it.alias }.toSet(), librariesInstance.aliases)
    }

    @Test
    fun operatorsCorrectWithSingleLibrary() {
        val correct = allLibInstances.map { it.operators }
        val toBeTested = allLibInstances.map { Runtime.of(it).operators }

        correct.zip(toBeTested).forEach { (expected, actual) -> assertEquals(expected, actual) }
    }

    @Test
    fun operatorsShouldReturnOverriddenOnesByLastlyAddedLibrary() {
        assertEquals(library.operators, Runtime.of(library, emptyLibrary).operators)
        assertEquals(overriddenLibrary.operators, Runtime.of(library, overridingLibrary).operators)
    }

    @Test
    fun theoryCorrectWithSingleLibrary() {
        val correct = allLibInstances.map { it.theory }
        val toBeTested = allLibInstances.map { Runtime.of(it).theory }

        correct.zip(toBeTested).forEach { (expected, actual) -> assertEquals(expected, actual) }
    }

    @Test
    fun theoryShouldReturnAllClausesComposingAllProvidedTheories() {
        assertEquals(library.theory, Runtime.of(library, emptyLibrary).theory)
        assertEquals(overriddenLibrary.theory, Runtime.of(library, overridingLibrary).theory)
    }

    @Test
    fun primitivesCorrectWithSingleLibrary() {
        val correct = allLibInstances.map { aliasLibraryMap(it.alias, it.primitives) }
        val toBeTested = allLibInstances.map { Runtime.of(it).primitives }

        correct.zip(toBeTested).forEach { (expected, actual) -> assertEquals(expected, actual) }
    }

    @Test
    fun primitivesShouldReturnNonAliasedOverriddenPrimitiveFromLastlyAddedLibrary() {
        val toBeTested = Runtime.of(library, overridingLibrary)

        assertEquals(
            overriddenLibrary.primitives,
            toBeTested.primitives.filterKeys { !it.name.contains(Library.ALIAS_SEPARATOR) }
        )
    }

    @Test
    fun primitivesShouldReturnAllAliasedPrimitivesEvenAfterOverriding() {
        val correct = aliasLibraryMap(overridingLibrary.alias, overriddenLibrary.primitives) +
            library.primitives.map { aliasPrimitiveOrFunction(library.alias, it) }
        val toBeTested = Runtime.of(library, overridingLibrary)

        assertEquals(correct, toBeTested.primitives)

        assertEquals(aliasLibraryMap(library.alias, library.primitives), Runtime.of(library, emptyLibrary).primitives)
    }

    @Test
    fun functionsCorrectWithSingleLibrary() {
        val correct = allLibInstances.map { aliasLibraryMap(it.alias, it.functions) }
        val toBeTested = allLibInstances.map { Runtime.of(it).functions }

        correct.zip(toBeTested).forEach { (expected, actual) -> assertEquals(expected, actual) }
    }

    @Test
    fun functionsShouldReturnNonAliasedOverriddenPrimitiveFromLastlyAddedLibrary() {
        val toBeTested = Runtime.of(library, overridingLibrary)

        assertEquals(
            overriddenLibrary.functions,
            toBeTested.functions.filterKeys { !it.name.contains(Library.ALIAS_SEPARATOR) }
        )
    }

    @Test
    fun functionsShouldReturnAllAliasedPrimitivesEvenAfterOverriding() {
        val correct = aliasLibraryMap(overridingLibrary.alias, overriddenLibrary.functions) +
            library.functions.map { aliasPrimitiveOrFunction(library.alias, it) }
        val toBeTested = Runtime.of(library, overridingLibrary)

        assertEquals(correct, toBeTested.functions)

        assertEquals(aliasLibraryMap(library.alias, library.functions), Runtime.of(library, emptyLibrary).functions)
    }

    @Test
    fun plusLibraryShouldAddANonPresentLibrary() {
        val toBeTested = Runtime.of(library) + overridingLibrary

        assertEquals(Runtime.of(library, overridingLibrary), toBeTested)
    }

    @Test
    fun plusLibraryWithAlreadyPresentAliasLibraryComplains() {
        assertFailsWith { Runtime.of(library) + duplicatedAliasLibrary }
    }

    @Test
    fun plusLibraryGroupShouldAddNonPresentLibrary() {
        val instances = differentAliasInstances
        val instancesCount = instances.count()

        assertEquals(
            Runtime.of(instances),
            Runtime.of(instances.take(instancesCount / 2)) + Runtime.of(instances.drop(instancesCount / 2))
        )
    }

    @Test
    fun plusLibraryGroupWithAlreadyPresentAliasLibraryComplains() {
        assertFailsWith { Runtime.of(library) + Runtime.of(duplicatedAliasLibrary) }
    }

    @Test
    fun updateShouldSubstituteAlreadyPresentAliasedLibrary() {
        val toBeTested = Runtime.of(library).update(duplicatedAliasLibrary)

        assertNotEquals(Runtime.of(library), toBeTested)
        assertEquals(Runtime.of(duplicatedAliasLibrary), toBeTested)
    }

    @Test
    fun updateShouldComplainIfNoLibraryLoadedWithSomeAlias() {
        assertFailsWith { Runtime.of(library).update(emptyLibrary) }
    }

    @Test
    fun equalsWorksAsExpected() {
        assertEquals(Runtime.of(differentAliasInstances), Runtime.of(differentAliasInstances))
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy