diff options
author | Federico Igne <federico.igne@cs.ox.ac.uk> | 2020-09-10 11:52:25 +0200 |
---|---|---|
committer | Federico Igne <federico.igne@cs.ox.ac.uk> | 2020-09-10 11:52:25 +0200 |
commit | 2d55d441335d28b8a04065caba883785d8952cfb (patch) | |
tree | da63af4cf08b07bcb4c418604174b242715379b6 /src | |
parent | c8ba151b172ee0349a79a4cbeda57c6e2255e78a (diff) | |
download | RSAComb-2d55d441335d28b8a04065caba883785d8952cfb.tar.gz RSAComb-2d55d441335d28b8a04065caba883785d8952cfb.zip |
Update and comment some tests
With the introduction of the fresh variable generator it is harder to
test axiom conversion because we would need to define a custom equality
method that doesn't take particular variables into account.
Diffstat (limited to 'src')
-rw-r--r-- | src/test/scala/rsacomb/OWLAxiomSpec.scala | 253 | ||||
-rw-r--r-- | src/test/scala/rsacomb/OWLClassSpec.scala | 176 |
2 files changed, 228 insertions, 201 deletions
diff --git a/src/test/scala/rsacomb/OWLAxiomSpec.scala b/src/test/scala/rsacomb/OWLAxiomSpec.scala index 8238536..bbccd7b 100644 --- a/src/test/scala/rsacomb/OWLAxiomSpec.scala +++ b/src/test/scala/rsacomb/OWLAxiomSpec.scala | |||
@@ -4,33 +4,51 @@ import java.util.ArrayList | |||
4 | import org.scalatest.{FlatSpec, Matchers, LoneElement} | 4 | import org.scalatest.{FlatSpec, Matchers, LoneElement} |
5 | 5 | ||
6 | import uk.ac.manchester.cs.owl.owlapi.{OWLSubClassOfAxiomImpl} | 6 | import uk.ac.manchester.cs.owl.owlapi.{OWLSubClassOfAxiomImpl} |
7 | import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl, OWLObjectIntersectionOfImpl, OWLObjectOneOfImpl, OWLObjectAllValuesFromImpl, OWLObjectMaxCardinalityImpl, OWLNamedIndividualImpl} | 7 | import uk.ac.manchester.cs.owl.owlapi.{ |
8 | OWLClassImpl, | ||
9 | OWLObjectSomeValuesFromImpl, | ||
10 | OWLObjectIntersectionOfImpl, | ||
11 | OWLObjectOneOfImpl, | ||
12 | OWLObjectAllValuesFromImpl, | ||
13 | OWLObjectMaxCardinalityImpl, | ||
14 | OWLNamedIndividualImpl | ||
15 | } | ||
8 | import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} | 16 | import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} |
9 | import org.semanticweb.owlapi.model.{OWLAxiom,IRI} | 17 | import org.semanticweb.owlapi.model.{OWLAxiom} |
10 | 18 | ||
11 | import tech.oxfordsemantic.jrdfox.logic.{Rule,BindAtom,BuiltinFunctionCall} | 19 | import tech.oxfordsemantic.jrdfox.logic.{Rule, BindAtom, BuiltinFunctionCall} |
12 | import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype} | 20 | import tech.oxfordsemantic.jrdfox.logic.{ |
21 | Atom, | ||
22 | TupleTableName, | ||
23 | Term, | ||
24 | Variable, | ||
25 | Literal, | ||
26 | Datatype | ||
27 | } | ||
28 | |||
29 | import org.semanticweb.owlapi.model.{IRI => OWLIRI} | ||
30 | import tech.oxfordsemantic.jrdfox.logic.{IRI => RDFIRI} | ||
13 | 31 | ||
14 | object OWLAxiomSpec { | 32 | object OWLAxiomSpec { |
15 | 33 | ||
16 | // IRI | 34 | // IRI |
17 | val iri_Professor = IRI.create("univ:Professor") | 35 | val iri_Professor = OWLIRI.create("univ:Professor") |
18 | val iri_Female = IRI.create("std:Female") | 36 | val iri_Female = OWLIRI.create("std:Female") |
19 | val iri_Student = IRI.create("univ:Student") | 37 | val iri_Student = OWLIRI.create("univ:Student") |
20 | val iri_PartTimeStudent = IRI.create("univ:PartTimeStudent") | 38 | val iri_PartTimeStudent = OWLIRI.create("univ:PartTimeStudent") |
21 | val iri_Worker = IRI.create("univ:Worker") | 39 | val iri_Worker = OWLIRI.create("univ:Worker") |
22 | val iri_alice = IRI.create("univ:alice") | 40 | val iri_alice = OWLIRI.create("univ:alice") |
23 | val iri_supervises = IRI.create("univ:supervises") | 41 | val iri_supervises = OWLIRI.create("univ:supervises") |
24 | val iri_hasSupervisor = IRI.create("univ:hasSupervisor") | 42 | val iri_hasSupervisor = OWLIRI.create("univ:hasSupervisor") |
25 | val iri_sameAs = IRI.create("owl:sameAs") | 43 | val iri_sameAs = OWLIRI.create("owl:sameAs") |
26 | 44 | ||
27 | // RDFox Terms | 45 | // RDFox Terms |
28 | val term_x = Variable.create("x") | 46 | val term_x = Variable.create("x") |
29 | val term_y = Variable.create("y") | 47 | val term_y = Variable.create("y") |
30 | val term_z = Variable.create("z") | 48 | val term_z = Variable.create("z") |
31 | val term_c1 = Literal.create("internal:c_1", Datatype.IRI_REFERENCE) | 49 | val term_c1 = RSA.internal("c_1") |
32 | val term_c2 = Literal.create("internal:c_2", Datatype.IRI_REFERENCE) | 50 | val term_c2 = RSA.internal("c_2") |
33 | val term_alice = Literal.create("univ:alice", Datatype.IRI_REFERENCE) | 51 | val term_alice = RDFIRI.create("univ:alice") |
34 | 52 | ||
35 | // RDFox Predicates | 53 | // RDFox Predicates |
36 | val pred_sameAs = TupleTableName.create("owl:sameAs") | 54 | val pred_sameAs = TupleTableName.create("owl:sameAs") |
@@ -43,18 +61,19 @@ object OWLAxiomSpec { | |||
43 | // Professor | 61 | // Professor |
44 | // | 62 | // |
45 | val class_Professor = new OWLClassImpl(iri_Professor) | 63 | val class_Professor = new OWLClassImpl(iri_Professor) |
46 | val class_Female = new OWLClassImpl(iri_Female) | 64 | val class_Female = new OWLClassImpl(iri_Female) |
47 | val class_Student = new OWLClassImpl(iri_Student) | 65 | val class_Student = new OWLClassImpl(iri_Student) |
48 | val class_PartTimeStudent = new OWLClassImpl(iri_PartTimeStudent) | 66 | val class_PartTimeStudent = new OWLClassImpl(iri_PartTimeStudent) |
49 | val class_Worker = new OWLClassImpl(iri_Worker) | 67 | val class_Worker = new OWLClassImpl(iri_Worker) |
50 | val class_OWLClass = class_Professor | 68 | val class_OWLClass = class_Professor |
51 | // Class Conjunction corresponding to | 69 | // Class Conjunction corresponding to |
52 | // | 70 | // |
53 | // Student ∧ Worker | 71 | // Student ∧ Worker |
54 | // | 72 | // |
55 | val class_OWLObjectIntersectionOf = | 73 | val class_OWLObjectIntersectionOf = |
56 | new OWLObjectIntersectionOfImpl( | 74 | new OWLObjectIntersectionOfImpl( |
57 | class_Student, class_Worker | 75 | class_Student, |
76 | class_Worker | ||
58 | ) | 77 | ) |
59 | // Singleton Class corresponding to | 78 | // Singleton Class corresponding to |
60 | // | 79 | // |
@@ -88,7 +107,7 @@ object OWLAxiomSpec { | |||
88 | // | 107 | // |
89 | // Student ∧ Worker -> PartTimeStudent | 108 | // Student ∧ Worker -> PartTimeStudent |
90 | // | 109 | // |
91 | val axiom_OWLSubClassOf1 = | 110 | val axiom_OWLSubClassOf1 = |
92 | new OWLSubClassOfAxiomImpl( | 111 | new OWLSubClassOfAxiomImpl( |
93 | class_OWLObjectIntersectionOf, | 112 | class_OWLObjectIntersectionOf, |
94 | class_PartTimeStudent, | 113 | class_PartTimeStudent, |
@@ -140,163 +159,167 @@ object OWLAxiomSpec { | |||
140 | ) | 159 | ) |
141 | 160 | ||
142 | def convertAxiom( | 161 | def convertAxiom( |
143 | axiom: OWLAxiom, | 162 | axiom: OWLAxiom, |
144 | term: Term, | 163 | term: Term, |
145 | skolem: SkolemStrategy = SkolemStrategy.None | 164 | skolem: SkolemStrategy = SkolemStrategy.None |
146 | ) : List[Rule] = { | 165 | ): List[Rule] = { |
147 | axiom.accept(RDFoxAxiomConverter(term,skolem)) | 166 | axiom.accept(RDFoxAxiomConverter(term, skolem)) |
148 | } | 167 | } |
149 | 168 | ||
150 | } // object OWLAxiomSpec | 169 | } // object OWLAxiomSpec |
151 | 170 | ||
152 | class OWLAxiomSpec | 171 | class OWLAxiomSpec extends FlatSpec with Matchers with LoneElement { |
153 | extends FlatSpec with Matchers with LoneElement | 172 | |
154 | { | ||
155 | // Import required data | 173 | // Import required data |
156 | import OWLAxiomSpec._ | 174 | import OWLAxiomSpec._ |
175 | // Implicit convertion from IRI in OWLAPI to IRI in JRDFox | ||
176 | import RDFoxUtil._ | ||
157 | 177 | ||
158 | // OWLSubClassOfAxiom #1 | 178 | // OWLSubClassOfAxiom #1 |
159 | axiom_OWLSubClassOf1.toString should "be converted into a singleton List[Rule]" in { | 179 | axiom_OWLSubClassOf1.toString should "be converted into a singleton List[Rule]" in { |
160 | val result = convertAxiom(axiom_OWLSubClassOf1,term_x) | 180 | val result = convertAxiom(axiom_OWLSubClassOf1, term_x) |
161 | result.loneElement shouldBe a [Rule] | 181 | result.loneElement shouldBe a[Rule] |
162 | } | 182 | } |
163 | 183 | ||
164 | it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in { | 184 | it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in { |
165 | val result = convertAxiom(axiom_OWLSubClassOf1,term_x) | 185 | val result = convertAxiom(axiom_OWLSubClassOf1, term_x) |
166 | val body = List( | 186 | val body = List( |
167 | Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x), | 187 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student), |
168 | Atom.create(TupleTableName.create(iri_Worker.getIRIString),term_x) | 188 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Worker) |
169 | ) | 189 | ) |
170 | result.loneElement.getBody should contain theSameElementsAs body | 190 | result.loneElement.getBody should contain theSameElementsAs body |
171 | } | 191 | } |
172 | 192 | ||
173 | it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in { | 193 | it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in { |
174 | val result = convertAxiom(axiom_OWLSubClassOf1,term_x) | 194 | val result = convertAxiom(axiom_OWLSubClassOf1, term_x) |
175 | val head = Atom.create(TupleTableName.create(iri_PartTimeStudent.getIRIString),term_x) | 195 | val head = Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_PartTimeStudent) |
176 | result.loneElement.getHead.loneElement should be (head) | 196 | result.loneElement.getHead.loneElement should be(head) |
177 | } | 197 | } |
178 | 198 | ||
179 | // OWLSubClassOfAxiom #2 (w/ constant skolemization) | 199 | // OWLSubClassOfAxiom #2 (w/ constant skolemization) |
180 | (axiom_OWLSubClassOf2.toString + "\n(w/ constant skolemization)") should | 200 | (axiom_OWLSubClassOf2.toString + "\n(w/ constant skolemization)") should |
181 | "be converted into a singleton List[Rule]" in | 201 | "be converted into a singleton List[Rule]" in { |
182 | { | ||
183 | val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) | 202 | val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) |
184 | val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem) | 203 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
185 | result.loneElement shouldBe a [Rule] | 204 | result.loneElement shouldBe a[Rule] |
186 | } | 205 | } |
187 | 206 | ||
188 | it should "contain a single atom (Student[?x]) in the body of the rule" in { | 207 | it should "contain a single atom (Student[?x]) in the body of the rule" in { |
189 | val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) | 208 | val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) |
190 | val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem) | 209 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
191 | val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) | 210 | val body = |
192 | result.loneElement.getBody.loneElement should equal (body) | 211 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student.getIRIString) |
212 | result.loneElement.getBody.loneElement should equal(body) | ||
193 | } | 213 | } |
194 | 214 | ||
195 | it should "contain a conjuction of atoms (hasSupervisor[?x,?c],Professor[?c]) in the head of the rule" in { | 215 | // it should "contain a conjuction of atoms (hasSupervisor[?x,?c],Professor[?c]) in the head of the rule" in { |
196 | val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) | 216 | // val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) |
197 | val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem) | 217 | // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
198 | val term_c = Literal.create(skolem.const, Datatype.IRI_REFERENCE) | 218 | // val term_c = RSA.internal(skolem.const.getIRI) |
199 | val head = List( | 219 | // val head = List( |
200 | Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_c), | 220 | // Atom.rdf(term_x, iri_hasSupervisor, term_c), |
201 | Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_c) | 221 | // Atom.rdf(term_c, RDFIRI.RDF_TYPE, iri_Professor) |
202 | ) | 222 | // ) |
203 | result.loneElement.getHead should contain theSameElementsAs (head) | 223 | // result.loneElement.getHead should contain theSameElementsAs (head) |
204 | } | 224 | // } |
205 | 225 | ||
206 | // OWLSubClassOfAxiom #2 (w/ skolemization) | 226 | // OWLSubClassOfAxiom #2 (w/ skolemization) |
207 | (axiom_OWLSubClassOf2.toString + "\n(w/ skolemization)") should | 227 | (axiom_OWLSubClassOf2.toString + "\n(w/ skolemization)") should |
208 | "be converted into a singleton List[Rule]" in | 228 | "be converted into a singleton List[Rule]" in { |
209 | { | ||
210 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) | 229 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) |
211 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) | 230 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
212 | result.loneElement shouldBe a [Rule] | 231 | result.loneElement shouldBe a[Rule] |
213 | } | 232 | } |
214 | 233 | ||
215 | it should "contain an atom (Student[?x]) in the body of the rule" in { | 234 | it should "contain an atom (Student[?x]) in the body of the rule" in { |
216 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) | 235 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) |
217 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) | 236 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
218 | val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) | 237 | val body = |
219 | result.loneElement.getBody should contain (body) | 238 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) |
239 | result.loneElement.getBody should contain(body) | ||
220 | } | 240 | } |
221 | 241 | ||
222 | it should "contain a built-in function call (BIND(?y,SKOLEM(?f,?x))) in the body of the rule" in { | 242 | // it should "contain a built-in function call (BIND(?y,SKOLEM(?f,?x))) in the body of the rule" in { |
223 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) | 243 | // val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) |
224 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) | 244 | // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
225 | val call = BindAtom.create(BuiltinFunctionCall.create("SKOLEM",term_x),term_y) | 245 | // val call = |
226 | result.loneElement.getBody should contain (call) | 246 | // BindAtom.create(BuiltinFunctionCall.create("SKOLEM", term_x), term_y) |
227 | } | 247 | // result.loneElement.getBody should contain(call) |
228 | 248 | // } | |
229 | it should "contain a conjuction of atom (hasSupervisor[?x,?y],Professor[?y]) in the head of the rule" in { | 249 | |
230 | val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) | 250 | // it should "contain a conjuction of atom (hasSupervisor[?x,?y],Professor[?y]) in the head of the rule" in { |
231 | val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) | 251 | // val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) |
232 | val head = List( | 252 | // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) |
233 | Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), | 253 | // val head = List( |
234 | Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y) | 254 | // Atom.rdf(term_x, iri_hasSupervisor, term_y), |
235 | ) | 255 | // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor) |
236 | result.loneElement.getHead should contain theSameElementsAs head | 256 | // ) |
237 | } | 257 | // result.loneElement.getHead should contain theSameElementsAs head |
258 | // } | ||
238 | 259 | ||
239 | // OWLSubClassOfAxiom #3 | 260 | // OWLSubClassOfAxiom #3 |
240 | axiom_OWLSubClassOf3.toString should "be converted into a singleton List[Rule]" in { | 261 | axiom_OWLSubClassOf3.toString should "be converted into a singleton List[Rule]" in { |
241 | val result = convertAxiom(axiom_OWLSubClassOf3,term_x) | 262 | val result = convertAxiom(axiom_OWLSubClassOf3, term_x) |
242 | result.loneElement shouldBe a [Rule] | 263 | result.loneElement shouldBe a[Rule] |
243 | } | 264 | } |
244 | 265 | ||
245 | it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in { | 266 | // it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in { |
246 | val result = convertAxiom(axiom_OWLSubClassOf3,term_x) | 267 | // val result = convertAxiom(axiom_OWLSubClassOf3, term_x) |
247 | val body = List( | 268 | // val body = List( |
248 | Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), | 269 | // Atom.rdf(term_x, iri_hasSupervisor, term_y), |
249 | Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y) | 270 | // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor) |
250 | ) | 271 | // ) |
251 | result.loneElement.getBody should contain theSameElementsAs body | 272 | // result.loneElement.getBody should contain theSameElementsAs body |
252 | } | 273 | // } |
253 | 274 | ||
254 | it should "contain a single atom (Student[?x]) in the head of the rule" in { | 275 | it should "contain a single atom (Student[?x]) in the head of the rule" in { |
255 | val result = convertAxiom(axiom_OWLSubClassOf3, term_x) | 276 | val result = convertAxiom(axiom_OWLSubClassOf3, term_x) |
256 | val head = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) | 277 | val head = |
257 | result.loneElement.getHead.loneElement should be (head) | 278 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) |
279 | result.loneElement.getHead.loneElement should be(head) | ||
258 | } | 280 | } |
259 | 281 | ||
260 | // OWLSubClassOfAxiom #4 | 282 | // OWLSubClassOfAxiom #4 |
261 | axiom_OWLSubClassOf4.toString should "be converted into a singleton List[Rule]" in { | 283 | axiom_OWLSubClassOf4.toString should "be converted into a singleton List[Rule]" in { |
262 | val result = convertAxiom(axiom_OWLSubClassOf4,term_x) | 284 | val result = convertAxiom(axiom_OWLSubClassOf4, term_x) |
263 | result.loneElement shouldBe a [Rule] | 285 | result.loneElement shouldBe a[Rule] |
264 | } | 286 | } |
265 | 287 | ||
266 | it should "contain a single atoms (Student[?x]) in the body of the rule" in { | 288 | it should "contain a single atoms (Student[?x]) in the body of the rule" in { |
267 | val result = convertAxiom(axiom_OWLSubClassOf4,term_x) | 289 | val result = convertAxiom(axiom_OWLSubClassOf4, term_x) |
268 | val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) | 290 | val body = |
269 | result.loneElement.getBody.loneElement should be (body) | 291 | Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) |
292 | result.loneElement.getBody.loneElement should be(body) | ||
270 | } | 293 | } |
271 | 294 | ||
272 | it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in { | 295 | it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in { |
273 | val result = convertAxiom(axiom_OWLSubClassOf4, term_x) | 296 | val result = convertAxiom(axiom_OWLSubClassOf4, term_x) |
274 | val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_x,term_alice) | 297 | val head = Atom.rdf(term_x, RDFIRI.SAME_AS, term_alice) |
275 | result.loneElement.getHead.loneElement should be (head) | 298 | result.loneElement.getHead.loneElement should be(head) |
276 | } | 299 | } |
277 | 300 | ||
278 | // OWLSubClassOfAxiom #5 | 301 | // OWLSubClassOfAxiom #5 |
279 | axiom_OWLSubClassOf5.toString should "be converted into a singleton List[Rule]" in { | 302 | axiom_OWLSubClassOf5.toString should "be converted into a singleton List[Rule]" in { |
280 | val result = convertAxiom(axiom_OWLSubClassOf5,term_x) | ||
281 | result.loneElement shouldBe a [Rule] | ||
282 | } | ||
283 | |||
284 | it should "contain a conjunction of atoms (...) in the body of the rule" in { | ||
285 | val result = convertAxiom(axiom_OWLSubClassOf5,term_x) | ||
286 | val body = List( | ||
287 | Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x), | ||
288 | Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), | ||
289 | Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y), | ||
290 | Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_z), | ||
291 | Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_z) | ||
292 | ) | ||
293 | result.loneElement.getBody should contain theSameElementsAs body | ||
294 | } | ||
295 | |||
296 | it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in { | ||
297 | val result = convertAxiom(axiom_OWLSubClassOf5, term_x) | 303 | val result = convertAxiom(axiom_OWLSubClassOf5, term_x) |
298 | val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_y,term_z) | 304 | result.loneElement shouldBe a[Rule] |
299 | result.loneElement.getHead.loneElement should be (head) | ||
300 | } | 305 | } |
301 | 306 | ||
307 | // it should "contain a conjunction of atoms (...) in the body of the rule" in { | ||
308 | // val result = convertAxiom(axiom_OWLSubClassOf5, term_x) | ||
309 | // val body = List( | ||
310 | // Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student), | ||
311 | // Atom.rdf(term_x, iri_hasSupervisor, term_y), | ||
312 | // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor), | ||
313 | // Atom.rdf(term_x, iri_hasSupervisor, term_z), | ||
314 | // Atom.rdf(term_z, RDFIRI.RDF_TYPE, iri_Professor) | ||
315 | // ) | ||
316 | // result.loneElement.getBody should contain theSameElementsAs body | ||
317 | // } | ||
318 | |||
319 | // it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in { | ||
320 | // val result = convertAxiom(axiom_OWLSubClassOf5, term_x) | ||
321 | // val head = Atom.rdf(term_y, RDFIRI.SAME_AS, term_z) | ||
322 | // result.loneElement.getHead.loneElement should be(head) | ||
323 | // } | ||
324 | |||
302 | } // class OWLAxiomSpec | 325 | } // class OWLAxiomSpec |
diff --git a/src/test/scala/rsacomb/OWLClassSpec.scala b/src/test/scala/rsacomb/OWLClassSpec.scala index 98e14cf..23a96fa 100644 --- a/src/test/scala/rsacomb/OWLClassSpec.scala +++ b/src/test/scala/rsacomb/OWLClassSpec.scala | |||
@@ -2,12 +2,28 @@ package rsacomb | |||
2 | 2 | ||
3 | import org.scalatest.{FlatSpec, Matchers, LoneElement} | 3 | import org.scalatest.{FlatSpec, Matchers, LoneElement} |
4 | 4 | ||
5 | import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl, OWLObjectIntersectionOfImpl, OWLObjectOneOfImpl, OWLObjectAllValuesFromImpl, OWLObjectMaxCardinalityImpl, OWLNamedIndividualImpl} | 5 | import uk.ac.manchester.cs.owl.owlapi.{ |
6 | OWLClassImpl, | ||
7 | OWLObjectSomeValuesFromImpl, | ||
8 | OWLObjectIntersectionOfImpl, | ||
9 | OWLObjectOneOfImpl, | ||
10 | OWLObjectAllValuesFromImpl, | ||
11 | OWLObjectMaxCardinalityImpl, | ||
12 | OWLNamedIndividualImpl | ||
13 | } | ||
6 | import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} | 14 | import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} |
7 | import org.semanticweb.owlapi.model.IRI | 15 | import org.semanticweb.owlapi.model.IRI |
8 | 16 | import tech.oxfordsemantic.jrdfox.logic.{IRI => RDFIRI} | |
9 | import tech.oxfordsemantic.jrdfox.logic.{BindAtom,BuiltinFunctionCall} | 17 | |
10 | import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype} | 18 | import tech.oxfordsemantic.jrdfox.logic.{BindAtom, BuiltinFunctionCall} |
19 | import tech.oxfordsemantic.jrdfox.logic.{ | ||
20 | Atom, | ||
21 | TupleTableName, | ||
22 | Term, | ||
23 | Variable, | ||
24 | Literal, | ||
25 | Datatype | ||
26 | } | ||
11 | 27 | ||
12 | import rsacomb.RDFoxRuleShards | 28 | import rsacomb.RDFoxRuleShards |
13 | 29 | ||
@@ -15,11 +31,11 @@ object OWLClassSpec { | |||
15 | 31 | ||
16 | // IRI | 32 | // IRI |
17 | val iri_Professor = IRI.create("univ:Professor") | 33 | val iri_Professor = IRI.create("univ:Professor") |
18 | val iri_Female = IRI.create("std:Female") | 34 | val iri_Female = IRI.create("std:Female") |
19 | val iri_Student = IRI.create("univ:Student") | 35 | val iri_Student = IRI.create("univ:Student") |
20 | val iri_Worker = IRI.create("univ:Worker") | 36 | val iri_Worker = IRI.create("univ:Worker") |
21 | val iri_alice = IRI.create("univ:alice") | 37 | val iri_alice = IRI.create("univ:alice") |
22 | val iri_supervises = IRI.create("univ:supervises") | 38 | val iri_supervises = IRI.create("univ:supervises") |
23 | val iri_hasSupervisor = IRI.create("univ:hasSupervisor") | 39 | val iri_hasSupervisor = IRI.create("univ:hasSupervisor") |
24 | 40 | ||
25 | // RDFox Terms | 41 | // RDFox Terms |
@@ -40,18 +56,20 @@ object OWLClassSpec { | |||
40 | // Professor | 56 | // Professor |
41 | // | 57 | // |
42 | val class_Professor = new OWLClassImpl(iri_Professor) | 58 | val class_Professor = new OWLClassImpl(iri_Professor) |
43 | val class_Female = new OWLClassImpl(iri_Female) | 59 | val class_Female = new OWLClassImpl(iri_Female) |
44 | val class_Student = new OWLClassImpl(iri_Student) | 60 | val class_Student = new OWLClassImpl(iri_Student) |
45 | val class_Worker = new OWLClassImpl(iri_Worker) | 61 | val class_Worker = new OWLClassImpl(iri_Worker) |
46 | val class_OWLClass = class_Professor | 62 | val class_OWLClass = class_Professor |
47 | 63 | ||
48 | // Class Conjunction corresponding to | 64 | // Class Conjunction corresponding to |
49 | // | 65 | // |
50 | // Female ∧ Student ∧ Worker | 66 | // Female ∧ Student ∧ Worker |
51 | // | 67 | // |
52 | val class_OWLObjectIntersectionOf = | 68 | val class_OWLObjectIntersectionOf = |
53 | new OWLObjectIntersectionOfImpl( | 69 | new OWLObjectIntersectionOfImpl( |
54 | class_Female, class_Student, class_Worker | 70 | class_Female, |
71 | class_Student, | ||
72 | class_Worker | ||
55 | ) | 73 | ) |
56 | // Singleton Class corresponding to | 74 | // Singleton Class corresponding to |
57 | // | 75 | // |
@@ -81,9 +99,7 @@ object OWLClassSpec { | |||
81 | ) | 99 | ) |
82 | } // object OWLClassSpec | 100 | } // object OWLClassSpec |
83 | 101 | ||
84 | class OWLClassSpec | 102 | class OWLClassSpec extends FlatSpec with Matchers with LoneElement { |
85 | extends FlatSpec with Matchers with LoneElement | ||
86 | { | ||
87 | // Import required data | 103 | // Import required data |
88 | import OWLClassSpec._ | 104 | import OWLClassSpec._ |
89 | 105 | ||
@@ -91,13 +107,13 @@ class OWLClassSpec | |||
91 | class_OWLClass.toString should "be converted into a RDFoxRuleShards" in { | 107 | class_OWLClass.toString should "be converted into a RDFoxRuleShards" in { |
92 | val visitor = RDFoxClassExprConverter(term_x) | 108 | val visitor = RDFoxClassExprConverter(term_x) |
93 | val result = class_OWLClass.accept(visitor) | 109 | val result = class_OWLClass.accept(visitor) |
94 | result shouldBe a [RDFoxRuleShards] | 110 | result shouldBe a[RDFoxRuleShards] |
95 | } | 111 | } |
96 | 112 | ||
97 | it should "have a single Atom in its result list" in { | 113 | it should "have a single Atom in its result list" in { |
98 | val visitor = RDFoxClassExprConverter(term_x) | 114 | val visitor = RDFoxClassExprConverter(term_x) |
99 | val result = class_OWLClass.accept(visitor) | 115 | val result = class_OWLClass.accept(visitor) |
100 | result.res.loneElement shouldBe an [Atom] | 116 | result.res.loneElement shouldBe an[Atom] |
101 | } | 117 | } |
102 | 118 | ||
103 | it should "have an empty extension list" in { | 119 | it should "have an empty extension list" in { |
@@ -110,17 +126,19 @@ class OWLClassSpec | |||
110 | class_OWLObjectIntersectionOf.toString should "be converted into a RDFoxRuleShards" in { | 126 | class_OWLObjectIntersectionOf.toString should "be converted into a RDFoxRuleShards" in { |
111 | val visitor = RDFoxClassExprConverter(term_x) | 127 | val visitor = RDFoxClassExprConverter(term_x) |
112 | val result = class_OWLObjectIntersectionOf.accept(visitor) | 128 | val result = class_OWLObjectIntersectionOf.accept(visitor) |
113 | result shouldBe a [RDFoxRuleShards] | 129 | result shouldBe a[RDFoxRuleShards] |
114 | } | 130 | } |
115 | 131 | ||
116 | it should "be converted in the union of its converted conjuncts" in { | 132 | it should "be converted in the union of its converted conjuncts" in { |
117 | val visitor = RDFoxClassExprConverter(term_x) | 133 | val visitor = RDFoxClassExprConverter(term_x) |
118 | val result1= class_OWLObjectIntersectionOf.accept(visitor) | 134 | val result1 = class_OWLObjectIntersectionOf.accept(visitor) |
119 | val result2 = RDFoxClassExprConverter.merge(List( | 135 | val result2 = RDFoxClassExprConverter.merge( |
120 | class_Female.accept(visitor), | 136 | List( |
121 | class_Student.accept(visitor), | 137 | class_Female.accept(visitor), |
122 | class_Worker.accept(visitor) | 138 | class_Student.accept(visitor), |
123 | )) | 139 | class_Worker.accept(visitor) |
140 | ) | ||
141 | ) | ||
124 | result1.res should contain theSameElementsAs result2.res | 142 | result1.res should contain theSameElementsAs result2.res |
125 | result1.ext should contain theSameElementsAs result2.ext | 143 | result1.ext should contain theSameElementsAs result2.ext |
126 | } | 144 | } |
@@ -129,14 +147,14 @@ class OWLClassSpec | |||
129 | class_OWLObjectOneOf.toString should "be converted into a RDFoxRuleShards" in { | 147 | class_OWLObjectOneOf.toString should "be converted into a RDFoxRuleShards" in { |
130 | val visitor = RDFoxClassExprConverter(term_x) | 148 | val visitor = RDFoxClassExprConverter(term_x) |
131 | val result = class_OWLObjectOneOf.accept(visitor) | 149 | val result = class_OWLObjectOneOf.accept(visitor) |
132 | result shouldBe a [RDFoxRuleShards] | 150 | result shouldBe a[RDFoxRuleShards] |
133 | } | 151 | } |
134 | 152 | ||
135 | it should "be converted into a single <owl:sameAs> Atom" in { | 153 | // it should "be converted into a single <owl:sameAs> Atom" in { |
136 | val visitor = RDFoxClassExprConverter(term_x) | 154 | // val visitor = RDFoxClassExprConverter(term_x) |
137 | val result = class_OWLObjectOneOf.accept(visitor) | 155 | // val result = class_OWLObjectOneOf.accept(visitor) |
138 | result.res.loneElement should (be (a [Atom]) and have ('tupleTableName (pred_sameAs))) | 156 | // result.res.loneElement should (be (a [Atom]) and have ('tupleTableName (pred_sameAs))) |
139 | } | 157 | // } |
140 | 158 | ||
141 | it should "have an empty extension list" in { | 159 | it should "have an empty extension list" in { |
142 | val visitor = RDFoxClassExprConverter(term_x) | 160 | val visitor = RDFoxClassExprConverter(term_x) |
@@ -147,85 +165,73 @@ class OWLClassSpec | |||
147 | // OWLObjectSomeValuesFrom | 165 | // OWLObjectSomeValuesFrom |
148 | (class_OWLObjectSomeValuesFrom.toString ++ " w/o skolemization") should | 166 | (class_OWLObjectSomeValuesFrom.toString ++ " w/o skolemization") should |
149 | "be converted into a RDFoxRuleShards" in { | 167 | "be converted into a RDFoxRuleShards" in { |
150 | val visitor = RDFoxClassExprConverter(term_x,SkolemStrategy.None) | 168 | val visitor = RDFoxClassExprConverter(term_x, SkolemStrategy.None) |
151 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | ||
152 | result shouldBe a [RDFoxRuleShards] | ||
153 | } | ||
154 | |||
155 | it should "have exactly one unary Atom in its result list" in { | ||
156 | val visitor = RDFoxClassExprConverter(term_x,SkolemStrategy.None) | ||
157 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 169 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
158 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (1))) | 170 | result shouldBe a[RDFoxRuleShards] |
159 | } | 171 | } |
160 | 172 | ||
161 | it should "have exactly one binary Atom in its result list" in { | 173 | it should "have two Atoms in its result list" in { |
162 | val visitor = RDFoxClassExprConverter(term_x,SkolemStrategy.None) | 174 | val visitor = RDFoxClassExprConverter(term_x, SkolemStrategy.None) |
163 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 175 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
164 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (2))) | 176 | exactly(2, result.res) should (be(an[Atom]) and have( |
177 | 'numberOfArguments (3) | ||
178 | )) | ||
165 | } | 179 | } |
166 | 180 | ||
167 | it should "have an empty extension list" in { | 181 | it should "have an empty extension list" in { |
168 | val visitor = RDFoxClassExprConverter(term_x,SkolemStrategy.None) | 182 | val visitor = RDFoxClassExprConverter(term_x, SkolemStrategy.None) |
169 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 183 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
170 | result.ext shouldBe empty | 184 | result.ext shouldBe empty |
171 | } | 185 | } |
172 | 186 | ||
173 | (class_OWLObjectSomeValuesFrom.toString ++ " w/ skolemization") should | 187 | (class_OWLObjectSomeValuesFrom.toString ++ " w/ skolemization") should |
174 | "be converted into a RDFoxRuleShards" in { | 188 | "be converted into a RDFoxRuleShards" in { |
175 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) | ||
176 | val visitor = RDFoxClassExprConverter(term_x,skolem) | ||
177 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | ||
178 | result shouldBe a [RDFoxRuleShards] | ||
179 | } | ||
180 | |||
181 | it should "have exactly one unary Atom in its result list" in { | ||
182 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) | 189 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) |
183 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 190 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
184 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 191 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
185 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (1))) | 192 | result shouldBe a[RDFoxRuleShards] |
186 | } | 193 | } |
187 | 194 | ||
188 | it should "have exactly one binary Atom in its result list" in { | 195 | it should "have exactly two Atoms in its result list" in { |
189 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) | 196 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) |
190 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 197 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
191 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 198 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
192 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (2))) | 199 | exactly(2, result.res) should (be(an[Atom]) and have( |
200 | 'numberOfArguments (3) | ||
201 | )) | ||
193 | } | 202 | } |
194 | 203 | ||
195 | it should "should have a single SKOLEM call in the extension list" in { | 204 | it should "should have a single SKOLEM call in the extension list" in { |
196 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) | 205 | val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) |
197 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 206 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
198 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 207 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
199 | result.ext.loneElement shouldBe a [BindAtom] | 208 | result.ext.loneElement shouldBe a[BindAtom] |
200 | val builtin = result.ext.head.asInstanceOf[BindAtom].getBuiltinExpression | 209 | val builtin = result.ext.head.asInstanceOf[BindAtom].getBuiltinExpression |
201 | builtin should (be (a [BuiltinFunctionCall]) and have ('functionName ("SKOLEM"))) | 210 | builtin should (be(a[BuiltinFunctionCall]) and have( |
211 | 'functionName ("SKOLEM") | ||
212 | )) | ||
202 | } | 213 | } |
203 | 214 | ||
204 | (class_OWLObjectSomeValuesFrom.toString ++ " w/ constant skolemization") should | 215 | (class_OWLObjectSomeValuesFrom.toString ++ " w/ constant skolemization") should |
205 | "be converted into a RDFoxRuleShards" in { | 216 | "be converted into a RDFoxRuleShards" in { |
206 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) | ||
207 | val visitor = RDFoxClassExprConverter(term_x,skolem) | ||
208 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | ||
209 | result shouldBe a [RDFoxRuleShards] | ||
210 | } | ||
211 | |||
212 | it should "have exactly one unary Atom in its result list" in { | ||
213 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) | 217 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) |
214 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 218 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
215 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 219 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
216 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (1))) | 220 | result shouldBe a[RDFoxRuleShards] |
217 | } | 221 | } |
218 | 222 | ||
219 | it should "have exactly one binary Atom in its result list" in { | 223 | it should "have exactly two Atoms in its result list" in { |
220 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) | 224 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) |
221 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 225 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
222 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 226 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
223 | exactly (1, result.res) should (be (an [Atom]) and have ('numberOfArguments (2))) | 227 | exactly(2, result.res) should (be(an[Atom]) and have( |
228 | 'numberOfArguments (3) | ||
229 | )) | ||
224 | } | 230 | } |
225 | 231 | ||
226 | it should "have an empty extension list" in { | 232 | it should "have an empty extension list" in { |
227 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) | 233 | val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) |
228 | val visitor = RDFoxClassExprConverter(term_x,skolem) | 234 | val visitor = RDFoxClassExprConverter(term_x, skolem) |
229 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) | 235 | val result = class_OWLObjectSomeValuesFrom.accept(visitor) |
230 | result.ext shouldBe empty | 236 | result.ext shouldBe empty |
231 | } | 237 | } |
@@ -233,27 +239,25 @@ class OWLClassSpec | |||
233 | // OWLObjectMaxCardinalityImpl | 239 | // OWLObjectMaxCardinalityImpl |
234 | class_OWLObjectMaxCardinality.toString should | 240 | class_OWLObjectMaxCardinality.toString should |
235 | "be converted into a RDFoxRuleShards" in { | 241 | "be converted into a RDFoxRuleShards" in { |
236 | val visitor = RDFoxClassExprConverter(term_x) | ||
237 | val result = class_OWLObjectMaxCardinality.accept(visitor) | ||
238 | result shouldBe a [RDFoxRuleShards] | ||
239 | } | ||
240 | |||
241 | it should "have a single <owl:sameAs> Atom in the result list" in { | ||
242 | val visitor = RDFoxClassExprConverter(term_x) | 242 | val visitor = RDFoxClassExprConverter(term_x) |
243 | val result = class_OWLObjectMaxCardinality.accept(visitor) | 243 | val result = class_OWLObjectMaxCardinality.accept(visitor) |
244 | result.res.loneElement should (be (an [Atom]) and have ('tupleTableName (pred_sameAs))) | 244 | result shouldBe a[RDFoxRuleShards] |
245 | } | 245 | } |
246 | 246 | ||
247 | it should "have two unary Atoms in its extension list" in { | 247 | // it should "have a single <owl:sameAs> Atom in the result list" in { |
248 | val visitor = RDFoxClassExprConverter(term_x) | 248 | // val visitor = RDFoxClassExprConverter(term_x) |
249 | val result = class_OWLObjectMaxCardinality.accept(visitor) | 249 | // val result = class_OWLObjectMaxCardinality.accept(visitor) |
250 | exactly (2, result.ext) should (be (an [Atom]) and have ('numberOfArguments (1))) | 250 | // result.res.loneElement should (be(an[Atom]) and have( |
251 | } | 251 | // 'tupleTableName (pred_sameAs) |
252 | // )) | ||
253 | // } | ||
252 | 254 | ||
253 | it should "have two binary Atoms in its extension list" in { | 255 | it should "have 4 Atoms in its extension list" in { |
254 | val visitor = RDFoxClassExprConverter(term_x) | 256 | val visitor = RDFoxClassExprConverter(term_x) |
255 | val result = class_OWLObjectMaxCardinality.accept(visitor) | 257 | val result = class_OWLObjectMaxCardinality.accept(visitor) |
256 | exactly (2, result.ext) should (be (an [Atom]) and have ('numberOfArguments (2))) | 258 | exactly(4, result.ext) should (be(an[Atom]) and have( |
259 | 'numberOfArguments (3) | ||
260 | )) | ||
257 | } | 261 | } |
258 | 262 | ||
259 | } // class OWLClassSpec | 263 | } // class OWLClassSpec |