9 files changed, 466 insertions, 95 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
index a8107b5..28196be 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
@@ -113,7 +113,7 @@ object RSAComb extends App {
           ontology.individuals.foreach(println)
 
           println("\nThings:")
-          val things = RDFoxHelpers.submitSelectQuery(
+          val things = RDFoxHelpers.submitQuery(
             data,
             """
              PREFIX  owl:  <http://www.w3.org/2002/07/owl#>
@@ -126,7 +126,7 @@ object RSAComb extends App {
           println(things)
 
           println("\nNAMEDs:")
-          val named = RDFoxHelpers.submitSelectQuery(
+          val named = RDFoxHelpers.submitQuery(
             data,
             """
              SELECT ?X {
@@ -138,7 +138,7 @@ object RSAComb extends App {
           println(named)
 
           println("\nNIs:")
-          val nis = RDFoxHelpers.submitSelectQuery(
+          val nis = RDFoxHelpers.submitQuery(
             data,
             """
              SELECT ?X {
@@ -159,7 +159,7 @@ object RSAComb extends App {
           println(ids)
 
           println("\nCongruent:")
-          val equivs = RDFoxHelpers.submitSelectQuery(
+          val equivs = RDFoxHelpers.submitQuery(
             data,
             """
               SELECT ?X ?Y {
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
index 93fd5cd..c4d4184 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
@@ -254,7 +254,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
       data: DataStoreConnection
   ): Graph[Resource, UnDiEdge] = {
     val query = "SELECT ?X ?Y WHERE { ?X rsa:E ?Y }"
-    val answers = RDFoxHelpers.submitSelectQuery(data, query, RSA.Prefixes)
+    val answers = RDFoxHelpers.submitQuery(data, query, RSA.Prefixes).get
     var edges: List[UnDiEdge[Resource]] = answers.map {
       case n1 :: n2 :: _ => UnDiEdge(n1, n2)
     }
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/implicits/JavaCollections.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/implicits/JavaCollections.scala
index 3b621f4..9d205b5 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/implicits/JavaCollections.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/implicits/JavaCollections.scala
@@ -9,5 +9,4 @@ object JavaCollections {
 
   implicit def scalaToJavaList[A](list: List[A]): java.util.List[A] =
     list.asJava
-
 }
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala
new file mode 100644
index 0000000..b523938
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala
@@ -0,0 +1,124 @@
+package uk.ac.ox.cs.rsacomb.sparql
+
+import java.util.{Map => JMap, HashMap => JHashMap}
+import tech.oxfordsemantic.jrdfox.Prefixes
+import tech.oxfordsemantic.jrdfox.client.DataStoreConnection
+import tech.oxfordsemantic.jrdfox.logic.expression.Variable
+import tech.oxfordsemantic.jrdfox.logic.sparql.pattern.{
+  ConjunctionPattern,
+  QueryPattern,
+  TriplePattern
+}
+import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
+import uk.ac.ox.cs.rsacomb.util.RDFoxHelpers
+
+/** Factory for [[uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery]]. */
+object ConjunctiveQuery {
+
+  /** Creates a new ConjunctiveQuery instance.
+    *
+    * @param query `SelectQuery` instance representing the actual query
+    */
+  def apply(query: SelectQuery): ConjunctiveQuery =
+    new ConjunctiveQuery(query)
+
+  /** Creates a new ConjunctiveQuery from a query string
+    *
+    * @param query a string representing the query in SPARQL format
+    * @param prefixes additional prefixes used in the query. Defaults to
+    *                 an empty set of prefixes.
+    * @return an [[scala.Option]] containing a ConjunctiveQuery if the
+    *         input query represents one, None is returned otherwise.
+    */
+  def apply(
+      query: String,
+      prefixes: Prefixes = new Prefixes()
+  ): Option[ConjunctiveQuery] =
+    RDFoxHelpers.parseSelectQuery(query, prefixes).map(ConjunctiveQuery(_))
+
+}
+
+/** A conjunctive query
+  *
+  * A thin layer around
+  * [[tech.oxfordsemantics.jrdfox.logic.sparql.statement.SelectQuery]].
+  *
+  * Instances should be created using the companion object.
+  *
+  * @todo additional checks need to be performed in order for a
+  * `SelectQuery` to be considered a conjunctive query.
+  */
+class ConjunctiveQuery(
+    query: SelectQuery,
+    val prefixes: Prefixes = new Prefixes()
+) {
+
+  import uk.ac.ox.cs.rsacomb.implicits.JavaCollections._
+
+  /** SELECT section of the SPARQL query.
+    *
+    * Simply exposes the underlying `getSelection` method in
+    * [[tech.oxfordsemantics.jrdfox.logic.sparql.statement.SelectQuery]].
+    */
+  val select = query.getSelection
+
+  /** WHERE section of the SPARQL query.
+    *
+    * Simply exposes the underlying `getWherePattern` method in
+    * [[tech.oxfordsemantics.jrdfox.logic.sparql.statement.QueryBody]].
+    */
+  val where = query.getQueryBody.getWherePattern
+
+  /** Returns true if it is a boolean CQ.
+    *
+    * @note checking for `select` being empty is not enough. When a
+    * query selects '''all''' variables with `*`, `select` is empty as
+    * well.
+    */
+  val boolean: Boolean = select.isEmpty && !query.getAllPossibleVariables
+
+  /** Returns the full set of variables involved in the query. */
+  val variables: Set[Variable] =
+    where match {
+      case b: ConjunctionPattern => {
+        b.getConjuncts.toSet.flatMap { conj: QueryPattern =>
+          conj match {
+            case c: TriplePattern =>
+              Set(c.getSubject, c.getPredicate, c.getObject).collect {
+                case v: Variable => v
+              }
+            case _ => Set()
+          }
+        }
+      }
+      case _ => Set()
+    }
+
+  /** Returns the collection of answer variables in the query. */
+  val answer: Set[Variable] =
+    if (query.getAllPossibleVariables)
+      variables
+    else
+      select.map(_.getVariable).toSet
+
+  /** Returns the collection of bounded (existential) variables in the query. */
+  val bounded: Set[Variable] = variables &~ answer
+
+  /** Returns the answers to a query
+    *
+    * @param data data store against which the query is executed
+    * @param opts additional options passed to RDFox
+    * @return a new [[ConjunctiveQueryAnswers]] instance containing the
+    *         collection of answers.
+    */
+  def answers(
+      data: DataStoreConnection,
+      opts: JMap[String, String] = new JHashMap[String, String]()
+  ): ConjunctiveQueryAnswers =
+    new ConjunctiveQueryAnswers(
+      boolean,
+      RDFoxHelpers.submitSelectQuery(data, query, opts)
+    )
+
+  override def toString(): String = query.toString
+}
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswers.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswers.scala
new file mode 100644
index 0000000..223e121
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswers.scala
@@ -0,0 +1,29 @@
+package uk.ac.ox.cs.rsacomb.sparql
+
+import tech.oxfordsemantic.jrdfox.logic.expression.Resource
+
+/** A collections of answers to a query
+  *
+  * Will take the query type (CQ or BCQ) into consideration when
+  * serialised.
+  *
+  * @param boolean whether the answers are to a BCQ
+  * @param answers collection of answers to a query. When dealing with
+  *                BCQs, and empty collection represents a ''false'',
+  *                ''true'' otherwise.
+  */
+class ConjunctiveQueryAnswers(
+    boolean: Boolean,
+    val answers: Seq[Seq[Resource]]
+) {
+
+  override def toString(): String =
+    if (boolean) {
+      if (answers.isEmpty) "FALSE" else "TRUE"
+    } else {
+      if (answers.isEmpty)
+        "NO ANSWER"
+      else
+        answers.map(_.mkString("(", ", ", ")")).mkString("\n")
+    }
+}
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
index fd9e1c5..5b85436 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
@@ -54,11 +54,10 @@ object RDFoxHelpers {
 
   def submitSelectQuery(
       data: DataStoreConnection,
-      query: String,
-      prefixes: Prefixes = new Prefixes(),
+      query: SelectQuery,
       opts: JMap[String, String] = new JHashMap[String, String]()
   ): List[List[Resource]] = {
-    val cursor = data.createCursor(prefixes, query, opts)
+    val cursor = data.createCursor(query, opts)
     var answers: List[List[Resource]] = List()
     var mul = cursor.open()
     while (mul > 0) {
@@ -71,6 +70,14 @@ object RDFoxHelpers {
     answers
   }
 
+  def submitQuery(
+      data: DataStoreConnection,
+      query: String,
+      prefixes: Prefixes = new Prefixes(),
+      opts: JMap[String, String] = new JHashMap[String, String]()
+  ): Option[List[List[Resource]]] =
+    parseSelectQuery(query, prefixes).map(submitSelectQuery(data, _, opts))
+
   def queryInternalPredicate(
       data: DataStoreConnection,
       pred: String,
@@ -86,7 +93,7 @@ object RDFoxHelpers {
       query ++= s" ?S rsa:${pred :: Nth(i)} ?X$i ."
     }
     query ++= " }"
-    submitSelectQuery(data, query, RSA.Prefixes, opts)
+    submitQuery(data, query, RSA.Prefixes, opts).get
   }
 
   def closeConnection(
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala
index 49abd48..e9a20db 100644
--- a/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala
@@ -310,89 +310,4 @@ class FilteringProgramSpec
 
   import FilteringProgramSpec._
 
-  "Queries" should "have distinct answer and bounded variables" in {
-    for (query <- queries) {
-      val program = new FilteringProgram(query, List())
-      forAll(program.answer) { v => program.bounded should not contain v }
-      forAll(program.bounded) { v => program.answer should not contain v }
-    }
-  }
-
-  "Query 0" should "have {?obj, ?pred} as bounded variables" in {
-    val pred = Variable.create("obj")
-    val obj = Variable.create("pred")
-    val program = new FilteringProgram(query0, List())
-    program.bounded should contain theSameElementsAs List(pred, obj)
-  }
-
-  "Query 1" should "have no bounded variable" in {
-    val program = new FilteringProgram(query1, List())
-    program.bounded shouldBe empty
-  }
-
-  "Query 2" should "have no bounded variable" in {
-    val program = new FilteringProgram(query2, List())
-    program.bounded shouldBe empty
-  }
-
-  "Query 3" should "have {?w, ?fp} as bounded variables" in {
-    val w = Variable.create("w")
-    val fp = Variable.create("fp")
-    val program = new FilteringProgram(query3, List())
-    program.bounded should contain theSameElementsAs List(w, fp)
-  }
-
-  "Query 4" should "have no bounded variable" in {
-    val program = new FilteringProgram(query4, List())
-    program.bounded shouldBe empty
-  }
-
-  "Query 5" should "have a non-empty bounded set" in {
-    val w = Variable.create("w")
-    val c_int = Variable.create("c_int")
-    val f_int = Variable.create("f_int")
-    val c_unit = Variable.create("c_unit")
-    val program = new FilteringProgram(query5, List())
-    program.bounded should contain theSameElementsAs List(
-      w,
-      c_int,
-      f_int,
-      c_unit
-    )
-  }
-
-  "Query 6" should "have a non-empty bounded set" in {
-    val w = Variable.create("w")
-    val int = Variable.create("int")
-    val program = new FilteringProgram(query6, List())
-    program.bounded should contain theSameElementsAs List(w, int)
-  }
-
-  "Query 7" should "have a non-empty bounded set" in {
-    val w = Variable.create("w")
-    val z = Variable.create("z")
-    val u = Variable.create("u")
-    val strat_unit_name = Variable.create("strat_unit_name")
-    val wellbore = Variable.create("wellbore")
-    val cored_int = Variable.create("cored_int")
-    val c = Variable.create("c")
-    val sample_depth = Variable.create("sample_depth")
-    val p = Variable.create("p")
-    val top = Variable.create("top")
-    val bot = Variable.create("bot")
-    val program = new FilteringProgram(query7, List())
-    program.bounded should contain theSameElementsAs List(
-      w,
-      z,
-      u,
-      strat_unit_name,
-      wellbore,
-      cored_int,
-      c,
-      sample_depth,
-      p,
-      top,
-      bot
-    )
-  }
 }
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswerSpecs.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswerSpecs.scala
new file mode 100644
index 0000000..65c3e29
--- /dev/null
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQueryAnswerSpecs.scala
@@ -0,0 +1,62 @@
+package uk.ac.ox.cs.rsacomb.sparql
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import tech.oxfordsemantic.jrdfox.logic.expression.IRI
+
+object ConjunctiveQueryAnswerSpec {
+
+  val iri1 = IRI.create("_:iri1")
+  val iri2 = IRI.create("_:iri2")
+  val iri3 = IRI.create("_:iri3")
+
+  val oneAnswer = new ConjunctiveQueryAnswers(false, Seq(Seq(iri1, iri2, iri3)))
+  val multipleAnswers =
+    new ConjunctiveQueryAnswers(
+      false,
+      Seq(Seq(iri1, iri1), Seq(iri1, iri2), Seq(iri1, iri3))
+    )
+  val noAnswer = new ConjunctiveQueryAnswers(false, Seq())
+  val emptyAnswer = new ConjunctiveQueryAnswers(false, Seq(Seq()))
+
+  val falseAnswer = new ConjunctiveQueryAnswers(true, Seq())
+  val trueAnswer1 = new ConjunctiveQueryAnswers(true, Seq(Seq()))
+  val trueAnswer2 =
+    new ConjunctiveQueryAnswers(
+      true,
+      Seq(Seq(iri1, iri1), Seq(iri1, iri2), Seq(iri1, iri3))
+    )
+}
+
+class ConjunctiveQueryAnswerSpec extends AnyFlatSpec with Matchers {
+
+  import ConjunctiveQueryAnswerSpec._
+
+  "A conjunctive query" should "print a single line if it has a single answer" in {
+    oneAnswer.toString shouldBe s"($iri1, $iri2, $iri3)"
+  }
+
+  it should "print multiple answers on multiple lines" in {
+    multipleAnswers.toString shouldBe s"($iri1, $iri1)\n($iri1, $iri2)\n($iri1, $iri3)"
+  }
+
+  it should "print a special \"NO ANSWER\" string when it has no answer" in {
+    noAnswer.toString shouldBe "NO ANSWER"
+  }
+
+  it should "print an empty list when it has an empty answer" in {
+    emptyAnswer.toString shouldBe "()"
+  }
+
+  "A boolean conjunctive query" should "print \"FALSE\" when it has no answer" in {
+    falseAnswer.toString shouldBe "FALSE"
+  }
+
+  it should "print \"TRUE\" when it has a single empty answer" in {
+    trueAnswer1.toString shouldBe "TRUE"
+  }
+
+  it should "print \"TRUE\" when it has a non-empty collection of answers" in {
+    trueAnswer2.toString shouldBe "TRUE"
+  }
+}
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuerySpec.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuerySpec.scala
new file mode 100644
index 0000000..e683d36
--- /dev/null
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuerySpec.scala
@@ -0,0 +1,235 @@
+package uk.ac.ox.cs.rsacomb.sparql
+
+import org.scalatest.{Inspectors, OptionValues}
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import tech.oxfordsemantic.jrdfox.logic.expression.Variable
+
+object ConjunctiveQuerySpec {
+
+  val cq0 = """
+    PREFIX  :  <http://example.com/rsa_example.owl#>
+
+    SELECT ?X
+    WHERE {
+      ?X a  :D ;
+         :R ?Y .
+      ?Y :S ?Z .
+      ?Z a  :D .
+    }
+  """
+
+  val cq1 = """
+    PREFIX  :  <http://example.com/rsa_example.owl#>
+
+    SELECT *
+    WHERE {
+      ?X a  :D ;
+         :R ?Y .
+      ?Y :S ?Z .
+      ?Z a  :D .
+    }
+  """
+
+  val cq2 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT  *
+    WHERE {
+      ?w    a                     :Wellbore ;
+            :wellboreDocument     ?doc .
+      ?doc  :hasURL               ?document_hyperlink
+    }
+  """
+
+  val cq3 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT  ?wellbore ?formation_pressure
+    WHERE {
+      ?w   a                      :Wellbore ;
+           :name                  ?wellbore ;
+           :hasFormationPressure  ?fp .
+      ?fp  :valueInStandardUnit   ?formation_pressure
+    }
+  """
+
+  val cq4 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT  *
+    WHERE {
+      ?w            a                           :Wellbore ;
+                    :hasGeochemicalMeasurement  ?measurement .
+      ?measurement  :cgType                     ?cgtype ;
+                    :peakName                   ?peakType ;
+                    :peakHeight                 ?peak_height ;
+                    :peakAmount                 ?peak_amount
+    }
+  """
+
+  val cq5 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT  ?wellbore ?unit_name ?discovery
+    WHERE {
+      ?w       a                     :Wellbore ;
+               :name                 ?wellbore ;
+               :hasWellboreInterval  ?c_int ;
+               :hasWellboreInterval  ?f_int .
+      ?c_int   :hasUnit              ?c_unit .
+      ?c_unit  :name                 ?unit_name .
+      ?f_int   a                     :FluidZone ;
+               :name                 ?discovery ;
+               :overlapsWellboreInterval  ?c_int
+    }
+  """
+
+  val cq6 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT DISTINCT ?wellbore ?content
+    WHERE {
+      ?w    a                     :Wellbore ;
+            :name                 ?wellbore ;
+            :hasWellboreInterval  ?int .
+      ?int  a                     :FluidZone ;
+            :fluidZoneContent     ?content
+    }
+  """
+
+  val cq7 = """
+    PREFIX  :  <http://slegger.gitlab.io/slegge-obda/ontology/subsurface-exploration#>
+    SELECT  ?wName ?sample ?porosity ?top_depth_md ?bot_depth_md
+    WHERE {
+      ?w        a                     :Wellbore ;
+                :name                 ?wName ;
+                :hasWellboreInterval  ?z .
+      ?z        :hasUnit              ?u .
+      ?u        :name                 ?strat_unit_name .
+      ?wellbore  :hasWellboreInterval  ?cored_int .
+      ?c        :extractedFrom        ?cored_int ;
+                :hasCoreSample        ?sample .
+      ?sample   :hasDepth  ?sample_depth .
+      ?sample_depth
+                :inWellboreInterval   ?z .
+      ?sample   :hasPorosity  ?p .
+      ?p        :valueInStandardUnit  ?porosity .
+      ?z        :hasTopDepth  ?top .
+      ?top      a                     :MeasuredDepth ;
+                :valueInStandardUnit  ?top_depth_md .
+      ?z        :hasBottomDepth  ?bot .
+      ?bot      a                     :MeasuredDepth ;
+                :valueInStandardUnit  ?bot_depth_md
+   }
+  """
+
+  val bcq0 = """
+    PREFIX  :  <http://example.com/scrubs/casting/>
+    ASK {
+      :turk a        :Doctor ;
+            :married ?X .
+      ?X    a        :Nurse .
+    } 
+  """
+
+  val queries =
+    List(cq0, cq1, cq2, cq3, cq4, cq5, cq6, cq7, bcq0)
+
+}
+
+class ConjunctiveQuerySpec
+    extends AnyFlatSpec
+    with Matchers
+    with Inspectors
+    with OptionValues {
+
+  import ConjunctiveQuerySpec._
+
+  "A conjunctive query" should "result in a `ConjunctiveQuery` instance" in {
+    ConjunctiveQuery(cq0) shouldBe defined
+  }
+
+  "A boolean conjunctive query" should "result in a `ConjunctiveQuery` instance" in {
+    ConjunctiveQuery(bcq0) shouldBe defined
+  }
+
+  "A query with proper SELECT defined" should "not be a BCQ" in {
+    ConjunctiveQuery(cq0).value should not be 'boolean
+  }
+
+  "A query with a \"*\" SELECT" should "not be a BCQ" in {
+    ConjunctiveQuery(cq1).value should not be 'boolean
+  }
+
+  "An ASK query" should "not be a BCQ" in {
+    ConjunctiveQuery(bcq0).value shouldBe 'boolean
+  }
+
+  "Queries" should "have distinct answer and bounded variables" in {
+    for (q <- queries) {
+      val cq = ConjunctiveQuery(q)
+      forAll(cq.value.answer) { v => cq.value.bounded should not contain v }
+      forAll(cq.value.bounded) { v => cq.value.answer should not contain v }
+    }
+  }
+
+  "CQ0" should "have {?obj, ?pred} as bounded variables" in {
+    ConjunctiveQuery(cq0).value.bounded should contain theSameElementsAs
+      List(
+        Variable.create("Y"),
+        Variable.create("Z")
+      )
+  }
+
+  "CQ1" should "have no bounded variable" in {
+    ConjunctiveQuery(cq1).value.bounded shouldBe empty
+  }
+
+  "CQ2" should "have no bounded variable" in {
+    ConjunctiveQuery(cq2).value.bounded shouldBe empty
+  }
+
+  "CQ3" should "have {?w, ?fp} as bounded variables" in {
+    ConjunctiveQuery(cq3).value.bounded should contain theSameElementsAs
+      List(
+        Variable.create("w"),
+        Variable.create("fp")
+      )
+  }
+
+  "CQ4" should "have no bounded variable" in {
+    ConjunctiveQuery(cq4).value.bounded shouldBe empty
+  }
+
+  "CQ5" should "have a non-empty bounded set" in {
+    ConjunctiveQuery(cq5).value.bounded should contain theSameElementsAs
+      List(
+        Variable.create("w"),
+        Variable.create("c_int"),
+        Variable.create("f_int"),
+        Variable.create("c_unit")
+      )
+  }
+
+  "CQ6" should "have a non-empty bounded set" in {
+    ConjunctiveQuery(cq6).value.bounded should contain theSameElementsAs
+      List(
+        Variable.create("w"),
+        Variable.create("int")
+      )
+  }
+
+  "CQ7" should "have a non-empty bounded set" in {
+    ConjunctiveQuery(cq7).value.bounded should contain theSameElementsAs
+      List(
+        Variable.create("w"),
+        Variable.create("z"),
+        Variable.create("u"),
+        Variable.create("strat_unit_name"),
+        Variable.create("wellbore"),
+        Variable.create("cored_int"),
+        Variable.create("c"),
+        Variable.create("sample_depth"),
+        Variable.create("p"),
+        Variable.create("top"),
+        Variable.create("bot")
+      )
+  }
+
+}