From e320bb53e58314fb2f04d514fc68202efcb52f3e Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sun, 14 Oct 2018 22:18:17 +0200 Subject: Add validation test suite --- schemas/owl.ttl | 614 +++++++++++++++++++++ schemas/rdf.ttl | 127 +++++ schemas/rdfs.ttl | 123 +++++ schemas/xsd.ttl | 353 ++++++++++++ tests/validate/bad-all-values-from.ttl | 18 + tests/validate/bad-cardinality-high.ttl | 18 + tests/validate/bad-cardinality-low.ttl | 16 + tests/validate/bad-cardinality.ttl | 18 + tests/validate/bad-datatype-property.ttl | 18 + tests/validate/bad-domain.ttl | 19 + tests/validate/bad-functional-property.ttl | 13 + tests/validate/bad-inverse-functional-property.ttl | 15 + tests/validate/bad-literal-pattern.ttl | 7 + .../validate/bad-literal-value-high-exclusive.ttl | 18 + .../validate/bad-literal-value-high-inclusive.ttl | 18 + tests/validate/bad-literal-value-low-exclusive.ttl | 18 + tests/validate/bad-literal-value-low-inclusive.ttl | 19 + tests/validate/bad-object-property.ttl | 12 + tests/validate/bad-pattern.ttl | 21 + tests/validate/bad-plain-literal.ttl | 12 + tests/validate/bad-range-instance-not-literal.ttl | 18 + tests/validate/bad-range-instance.ttl | 21 + tests/validate/bad-range-literal-not-instance.ttl | 15 + tests/validate/bad-range-literal.ttl | 25 + tests/validate/bad-some-values-from.ttl | 18 + tests/validate/bad-string-literal-value-high.ttl | 19 + tests/validate/bad-string-literal-value-low.ttl | 19 + tests/validate/bad-unknown-datatype.ttl | 6 + tests/validate/bad-unknown-property.ttl | 6 + tests/validate/manifest.ttl | 165 ++++++ wscript | 76 ++- 31 files changed, 1853 insertions(+), 12 deletions(-) create mode 100644 schemas/owl.ttl create mode 100644 schemas/rdf.ttl create mode 100644 schemas/rdfs.ttl create mode 100644 schemas/xsd.ttl create mode 100644 tests/validate/bad-all-values-from.ttl create mode 100644 tests/validate/bad-cardinality-high.ttl create mode 100644 tests/validate/bad-cardinality-low.ttl create mode 100644 tests/validate/bad-cardinality.ttl create mode 100644 tests/validate/bad-datatype-property.ttl create mode 100644 tests/validate/bad-domain.ttl create mode 100644 tests/validate/bad-functional-property.ttl create mode 100644 tests/validate/bad-inverse-functional-property.ttl create mode 100644 tests/validate/bad-literal-pattern.ttl create mode 100644 tests/validate/bad-literal-value-high-exclusive.ttl create mode 100644 tests/validate/bad-literal-value-high-inclusive.ttl create mode 100644 tests/validate/bad-literal-value-low-exclusive.ttl create mode 100644 tests/validate/bad-literal-value-low-inclusive.ttl create mode 100644 tests/validate/bad-object-property.ttl create mode 100644 tests/validate/bad-pattern.ttl create mode 100644 tests/validate/bad-plain-literal.ttl create mode 100644 tests/validate/bad-range-instance-not-literal.ttl create mode 100644 tests/validate/bad-range-instance.ttl create mode 100644 tests/validate/bad-range-literal-not-instance.ttl create mode 100644 tests/validate/bad-range-literal.ttl create mode 100644 tests/validate/bad-some-values-from.ttl create mode 100644 tests/validate/bad-string-literal-value-high.ttl create mode 100644 tests/validate/bad-string-literal-value-low.ttl create mode 100644 tests/validate/bad-unknown-datatype.ttl create mode 100644 tests/validate/bad-unknown-property.ttl create mode 100644 tests/validate/manifest.ttl diff --git a/schemas/owl.ttl b/schemas/owl.ttl new file mode 100644 index 00000000..3057fdd3 --- /dev/null +++ b/schemas/owl.ttl @@ -0,0 +1,614 @@ +@prefix rdf: . +@prefix rdfs: . +@prefix xsd: . +@prefix owl: . + + + rdfs:comment "The OWL 2 Schema vocabulary (OWL 2)" ; + a owl:Ontology ; + rdfs:comment """ + This ontology partially describes the built-in classes and + properties that together form the basis of the RDF/XML syntax of OWL 2. + The content of this ontology is based on Tables 6.1 and 6.2 + in Section 6.4 of the OWL 2 RDF-Based Semantics specification, + available at http://www.w3.org/TR/owl2-rdf-based-semantics/. + Please note that those tables do not include the different annotations + (labels, comments and rdfs:isDefinedBy links) used in this file. + Also note that the descriptions provided in this ontology do not + provide a complete and correct formal description of either the syntax + or the semantics of the introduced terms (please see the OWL 2 + recommendations for the complete and normative specifications). + Furthermore, the information provided by this ontology may be + misleading if not used with care. This ontology SHOULD NOT be imported + into OWL ontologies. Importing this file into an OWL 2 DL ontology + will cause it to become an OWL 2 Full ontology and may have other, + unexpected, consequences. + """ ; + rdfs:isDefinedBy , , ; + rdfs:seeAlso , ; + owl:imports rdfs: ; + owl:versionIRI ; + owl:versionInfo "$Date: 2009/11/15 10:54:12 $" . + +owl:AllDifferent + a rdfs:Class ; + rdfs:comment "The class of collections of pairwise different individuals." ; + rdfs:isDefinedBy ; + rdfs:label "AllDifferent" ; + rdfs:subClassOf rdfs:Resource . + +owl:AllDisjointClasses + a rdfs:Class ; + rdfs:comment "The class of collections of pairwise disjoint classes." ; + rdfs:isDefinedBy ; + rdfs:label "AllDisjointClasses" ; + rdfs:subClassOf rdfs:Resource . + +owl:AllDisjointProperties + a rdfs:Class ; + rdfs:comment "The class of collections of pairwise disjoint properties." ; + rdfs:isDefinedBy ; + rdfs:label "AllDisjointProperties" ; + rdfs:subClassOf rdfs:Resource . + +owl:Annotation + a rdfs:Class ; + rdfs:comment "The class of annotated annotations for which the RDF serialization consists of an annotated subject, predicate and object." ; + rdfs:isDefinedBy ; + rdfs:label "Annotation" ; + rdfs:subClassOf rdfs:Resource . + +owl:AnnotationProperty + a rdfs:Class ; + rdfs:comment "The class of annotation properties." ; + rdfs:isDefinedBy ; + rdfs:label "AnnotationProperty" ; + rdfs:subClassOf rdf:Property . + +owl:AsymmetricProperty + a rdfs:Class ; + rdfs:comment "The class of asymmetric properties." ; + rdfs:isDefinedBy ; + rdfs:label "AsymmetricProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:Axiom + a rdfs:Class ; + rdfs:comment "The class of annotated axioms for which the RDF serialization consists of an annotated subject, predicate and object." ; + rdfs:isDefinedBy ; + rdfs:label "Axiom" ; + rdfs:subClassOf rdfs:Resource . + +owl:Class + a rdfs:Class ; + rdfs:comment "The class of OWL classes." ; + rdfs:isDefinedBy ; + rdfs:label "Class" ; + rdfs:subClassOf rdfs:Class . + +owl:DatatypeProperty + a rdfs:Class ; + rdfs:comment "The class of data properties." ; + rdfs:isDefinedBy ; + rdfs:label "DatatypeProperty" ; + rdfs:subClassOf rdf:Property . + +owl:DeprecatedClass + a rdfs:Class ; + rdfs:comment "The class of deprecated classes." ; + rdfs:isDefinedBy ; + rdfs:label "DeprecatedClass" ; + rdfs:subClassOf rdfs:Class . + +owl:DeprecatedProperty + a rdfs:Class ; + rdfs:comment "The class of deprecated properties." ; + rdfs:isDefinedBy ; + rdfs:label "DeprecatedProperty" ; + rdfs:subClassOf rdf:Property . + +owl:FunctionalProperty + a rdfs:Class ; + rdfs:comment "The class of functional properties." ; + rdfs:isDefinedBy ; + rdfs:label "FunctionalProperty" ; + rdfs:subClassOf rdf:Property . + +owl:InverseFunctionalProperty + a rdfs:Class ; + rdfs:comment "The class of inverse-functional properties." ; + rdfs:isDefinedBy ; + rdfs:label "InverseFunctionalProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:IrreflexiveProperty + a rdfs:Class ; + rdfs:comment "The class of irreflexive properties." ; + rdfs:isDefinedBy ; + rdfs:label "IrreflexiveProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:NamedIndividual + a rdfs:Class ; + rdfs:comment "The class of named individuals." ; + rdfs:isDefinedBy ; + rdfs:label "NamedIndividual" ; + rdfs:subClassOf owl:Thing . + +owl:NegativePropertyAssertion + a rdfs:Class ; + rdfs:comment "The class of negative property assertions." ; + rdfs:isDefinedBy ; + rdfs:label "NegativePropertyAssertion" ; + rdfs:subClassOf rdfs:Resource . + +owl:Nothing + a owl:Class ; + rdfs:comment "This is the empty class." ; + rdfs:isDefinedBy ; + rdfs:label "Nothing" ; + rdfs:subClassOf owl:Thing . + +owl:ObjectProperty + a rdfs:Class ; + rdfs:comment "The class of object properties." ; + rdfs:isDefinedBy ; + rdfs:label "ObjectProperty" ; + rdfs:subClassOf rdf:Property . + +owl:Ontology + a rdfs:Class ; + rdfs:comment "The class of ontologies." ; + rdfs:isDefinedBy ; + rdfs:label "Ontology" ; + rdfs:subClassOf rdfs:Resource . + +owl:OntologyProperty + a rdfs:Class ; + rdfs:comment "The class of ontology properties." ; + rdfs:isDefinedBy ; + rdfs:label "OntologyProperty" ; + rdfs:subClassOf rdf:Property . + +owl:ReflexiveProperty + a rdfs:Class ; + rdfs:comment "The class of reflexive properties." ; + rdfs:isDefinedBy ; + rdfs:label "ReflexiveProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:Restriction + a rdfs:Class ; + rdfs:comment "The class of property restrictions." ; + rdfs:isDefinedBy ; + rdfs:label "Restriction" ; + rdfs:subClassOf owl:Class . + +owl:SymmetricProperty + a rdfs:Class ; + rdfs:comment "The class of symmetric properties." ; + rdfs:isDefinedBy ; + rdfs:label "SymmetricProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:Thing + a owl:Class ; + rdfs:comment "The class of OWL individuals." ; + rdfs:isDefinedBy ; + rdfs:label "Thing" . + +owl:TransitiveProperty + a rdfs:Class ; + rdfs:comment "The class of transitive properties." ; + rdfs:isDefinedBy ; + rdfs:label "TransitiveProperty" ; + rdfs:subClassOf owl:ObjectProperty . + +owl:allValuesFrom + a rdf:Property ; + rdfs:comment "The property that determines the class that a universal property restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "all values from" ; + rdfs:range rdfs:Class . + +owl:annotatedProperty + a rdf:Property ; + rdfs:comment "The property that determines the predicate of an annotated axiom or annotated annotation." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "annotated property" ; + rdfs:range rdfs:Resource . + +owl:annotatedSource + a rdf:Property ; + rdfs:comment "The property that determines the subject of an annotated axiom or annotated annotation." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "annotated source" ; + rdfs:range rdfs:Resource . + +owl:annotatedTarget + a rdf:Property ; + rdfs:comment "The property that determines the object of an annotated axiom or annotated annotation." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "annotated target" ; + rdfs:range rdfs:Resource . + +owl:assertionProperty + a rdf:Property ; + rdfs:comment "The property that determines the predicate of a negative property assertion." ; + rdfs:domain owl:NegativePropertyAssertion ; + rdfs:isDefinedBy ; + rdfs:label "assertion property" ; + rdfs:range rdf:Property . + +owl:backwardCompatibleWith + a owl:AnnotationProperty, owl:OntologyProperty ; + rdfs:comment "The annotation property that indicates that a given ontology is backward compatible with another ontology." ; + rdfs:domain owl:Ontology ; + rdfs:isDefinedBy ; + rdfs:label "backward compatible with" ; + rdfs:range owl:Ontology . + +owl:bottomDataProperty + a owl:DatatypeProperty ; + rdfs:comment "The data property that does not relate any individual to any data value." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "bottom data property" ; + rdfs:range rdfs:Literal . + +owl:bottomObjectProperty + a owl:ObjectProperty ; + rdfs:comment "The object property that does not relate any two individuals." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "bottom object property" ; + rdfs:range owl:Thing . + +owl:cardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of an exact cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:complementOf + a rdf:Property ; + rdfs:comment "The property that determines that a given class is the complement of another class." ; + rdfs:domain owl:Class ; + rdfs:isDefinedBy ; + rdfs:label "complement of" ; + rdfs:range owl:Class . + +owl:datatypeComplementOf + a rdf:Property ; + rdfs:comment "The property that determines that a given data range is the complement of another data range with respect to the data domain." ; + rdfs:domain rdfs:Datatype ; + rdfs:isDefinedBy ; + rdfs:label "datatype complement of" ; + rdfs:range rdfs:Datatype . + +owl:deprecated + a owl:AnnotationProperty ; + rdfs:comment "The annotation property that indicates that a given entity has been deprecated." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "deprecated" ; + rdfs:range rdfs:Resource . + +owl:differentFrom + a rdf:Property ; + rdfs:comment "The property that determines that two given individuals are different." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "different from" ; + rdfs:range owl:Thing . + +owl:disjointUnionOf + a rdf:Property ; + rdfs:comment "The property that determines that a given class is equivalent to the disjoint union of a collection of other classes." ; + rdfs:domain owl:Class ; + rdfs:isDefinedBy ; + rdfs:label "disjoint union of" ; + rdfs:range rdf:List . + +owl:disjointWith + a rdf:Property ; + rdfs:comment "The property that determines that two given classes are disjoint." ; + rdfs:domain owl:Class ; + rdfs:isDefinedBy ; + rdfs:label "disjoint with" ; + rdfs:range owl:Class . + +owl:distinctMembers + a rdf:Property ; + rdfs:comment "The property that determines the collection of pairwise different individuals in a owl:AllDifferent axiom." ; + rdfs:domain owl:AllDifferent ; + rdfs:isDefinedBy ; + rdfs:label "distinct members" ; + rdfs:range rdf:List . + +owl:equivalentClass + a rdf:Property ; + rdfs:comment "The property that determines that two given classes are equivalent, and that is used to specify datatype definitions." ; + rdfs:domain rdfs:Class ; + rdfs:isDefinedBy ; + rdfs:label "equivalent class" ; + rdfs:range rdfs:Class . + +owl:equivalentProperty + a rdf:Property ; + rdfs:comment "The property that determines that two given properties are equivalent." ; + rdfs:domain rdf:Property ; + rdfs:isDefinedBy ; + rdfs:label "equivalent property" ; + rdfs:range rdf:Property . + +owl:hasKey + a rdf:Property ; + rdfs:comment "The property that determines the collection of properties that jointly build a key." ; + rdfs:domain owl:Class ; + rdfs:isDefinedBy ; + rdfs:label "has key" ; + rdfs:range rdf:List . + +owl:hasSelf + a rdf:Property ; + rdfs:comment "The property that determines the property that a self restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "has self" ; + rdfs:range rdfs:Resource . + +owl:hasValue + a rdf:Property ; + rdfs:comment "The property that determines the individual that a has-value restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "has value" ; + rdfs:range rdfs:Resource . + +owl:imports + a owl:OntologyProperty ; + rdfs:comment "The property that is used for importing other ontologies into a given ontology." ; + rdfs:domain owl:Ontology ; + rdfs:isDefinedBy ; + rdfs:label "imports" ; + rdfs:range owl:Ontology . + +owl:incompatibleWith + a owl:AnnotationProperty, owl:OntologyProperty ; + rdfs:comment "The annotation property that indicates that a given ontology is incompatible with another ontology." ; + rdfs:domain owl:Ontology ; + rdfs:isDefinedBy ; + rdfs:label "incompatible with" ; + rdfs:range owl:Ontology . + +owl:intersectionOf + a rdf:Property ; + rdfs:comment "The property that determines the collection of classes or data ranges that build an intersection." ; + rdfs:domain rdfs:Class ; + rdfs:isDefinedBy ; + rdfs:label "intersection of" ; + rdfs:range rdf:List . + +owl:inverseOf + a rdf:Property ; + rdfs:comment "The property that determines that two given properties are inverse." ; + rdfs:domain owl:ObjectProperty ; + rdfs:isDefinedBy ; + rdfs:label "inverse of" ; + rdfs:range owl:ObjectProperty . + +owl:maxCardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of a maximum cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "max cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:maxQualifiedCardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of a maximum qualified cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "max qualified cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:members + a rdf:Property ; + rdfs:comment "The property that determines the collection of members in either a owl:AllDifferent, owl:AllDisjointClasses or owl:AllDisjointProperties axiom." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "members" ; + rdfs:range rdf:List . + +owl:minCardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of a minimum cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "min cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:minQualifiedCardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of a minimum qualified cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "min qualified cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:onClass + a rdf:Property ; + rdfs:comment "The property that determines the class that a qualified object cardinality restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "on class" ; + rdfs:range owl:Class . + +owl:onDataRange + a rdf:Property ; + rdfs:comment "The property that determines the data range that a qualified data cardinality restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "on data range" ; + rdfs:range rdfs:Datatype . + +owl:onDatatype + a rdf:Property ; + rdfs:comment "The property that determines the datatype that a datatype restriction refers to." ; + rdfs:domain rdfs:Datatype ; + rdfs:isDefinedBy ; + rdfs:label "on datatype" ; + rdfs:range rdfs:Datatype . + +owl:onProperties + a rdf:Property ; + rdfs:comment "The property that determines the n-tuple of properties that a property restriction on an n-ary data range refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "on properties" ; + rdfs:range rdf:List . + +owl:onProperty + a rdf:Property ; + rdfs:comment "The property that determines the property that a property restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "on property" ; + rdfs:range rdf:Property . + +owl:oneOf + a rdf:Property ; + rdfs:comment "The property that determines the collection of individuals or data values that build an enumeration." ; + rdfs:domain rdfs:Class ; + rdfs:isDefinedBy ; + rdfs:label "one of" ; + rdfs:range rdf:List . + +owl:priorVersion + a owl:AnnotationProperty, owl:OntologyProperty ; + rdfs:comment "The annotation property that indicates the predecessor ontology of a given ontology." ; + rdfs:domain owl:Ontology ; + rdfs:isDefinedBy ; + rdfs:label "prior version" ; + rdfs:range owl:Ontology . + +owl:propertyChainAxiom + a rdf:Property ; + rdfs:comment "The property that determines the n-tuple of properties that build a sub property chain of a given property." ; + rdfs:domain owl:ObjectProperty ; + rdfs:isDefinedBy ; + rdfs:label "property chain axiom" ; + rdfs:range rdf:List . + +owl:propertyDisjointWith + a rdf:Property ; + rdfs:comment "The property that determines that two given properties are disjoint." ; + rdfs:domain rdf:Property ; + rdfs:isDefinedBy ; + rdfs:label "property disjoint with" ; + rdfs:range rdf:Property . + +owl:qualifiedCardinality + a rdf:Property ; + rdfs:comment "The property that determines the cardinality of an exact qualified cardinality restriction." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "qualified cardinality" ; + rdfs:range xsd:nonNegativeInteger . + +owl:sameAs + a rdf:Property ; + rdfs:comment "The property that determines that two given individuals are equal." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "same as" ; + rdfs:range owl:Thing . + +owl:someValuesFrom + a rdf:Property ; + rdfs:comment "The property that determines the class that an existential property restriction refers to." ; + rdfs:domain owl:Restriction ; + rdfs:isDefinedBy ; + rdfs:label "some values from" ; + rdfs:range rdfs:Class . + +owl:sourceIndividual + a rdf:Property ; + rdfs:comment "The property that determines the subject of a negative property assertion." ; + rdfs:domain owl:NegativePropertyAssertion ; + rdfs:isDefinedBy ; + rdfs:label "source individual" ; + rdfs:range owl:Thing . + +owl:targetIndividual + a rdf:Property ; + rdfs:comment "The property that determines the object of a negative object property assertion." ; + rdfs:domain owl:NegativePropertyAssertion ; + rdfs:isDefinedBy ; + rdfs:label "target individual" ; + rdfs:range owl:Thing . + +owl:targetValue + a rdf:Property ; + rdfs:comment "The property that determines the value of a negative data property assertion." ; + rdfs:domain owl:NegativePropertyAssertion ; + rdfs:isDefinedBy ; + rdfs:label "target value" ; + rdfs:range rdfs:Literal . + +owl:topDataProperty + a owl:DatatypeProperty ; + rdfs:comment "The data property that relates every individual to every data value." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "top data property" ; + rdfs:range rdfs:Literal . + +owl:topObjectProperty + a owl:ObjectProperty ; + rdfs:comment "The object property that relates every two individuals." ; + rdfs:domain owl:Thing ; + rdfs:isDefinedBy ; + rdfs:label "top object property" ; + rdfs:range owl:Thing . + +owl:unionOf + a rdf:Property ; + rdfs:comment "The property that determines the collection of classes or data ranges that build a union." ; + rdfs:domain rdfs:Class ; + rdfs:isDefinedBy ; + rdfs:label "union of" ; + rdfs:range rdf:List . + +owl:versionIRI + a owl:OntologyProperty ; + rdfs:comment "The property that identifies the version IRI of an ontology." ; + rdfs:domain owl:Ontology ; + rdfs:isDefinedBy ; + rdfs:label "version IRI" ; + rdfs:range owl:Ontology . + +owl:versionInfo + a owl:AnnotationProperty ; + rdfs:comment "The annotation property that provides version information for an ontology or another OWL construct." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "version info" ; + rdfs:range rdfs:Resource . + +owl:withRestrictions + a rdf:Property ; + rdfs:comment "The property that determines the collection of facet-value pairs that define a datatype restriction." ; + rdfs:domain rdfs:Datatype ; + rdfs:isDefinedBy ; + rdfs:label "with restrictions" ; + rdfs:range rdf:List . + diff --git a/schemas/rdf.ttl b/schemas/rdf.ttl new file mode 100644 index 00000000..5ef93450 --- /dev/null +++ b/schemas/rdf.ttl @@ -0,0 +1,127 @@ +@prefix rdf: . +@prefix rdfs: . +@prefix owl: . + + + rdfs:comment "The RDF Vocabulary (RDF)" ; + a owl:Ontology ; + rdfs:seeAlso . + +rdf:Alt + a rdfs:Class ; + rdfs:comment "The class of containers of alternatives." ; + rdfs:isDefinedBy ; + rdfs:label "Alt" ; + rdfs:subClassOf rdfs:Container . + +rdf:Bag + a rdfs:Class ; + rdfs:comment "The class of unordered containers." ; + rdfs:isDefinedBy ; + rdfs:label "Bag" ; + rdfs:subClassOf rdfs:Container . + +rdf:List + a rdfs:Class ; + rdfs:comment "The class of RDF Lists." ; + rdfs:isDefinedBy ; + rdfs:label "List" ; + rdfs:subClassOf rdfs:Resource . + +rdf:PlainLiteral + a rdfs:Datatype ; + rdfs:comment "The class of plain (i.e. untyped) literal values." ; + rdfs:isDefinedBy ; + rdfs:label "Plain Literal" ; + rdfs:subClassOf rdfs:Literal . + +rdf:Property + a rdfs:Class ; + rdfs:comment "The class of RDF properties." ; + rdfs:isDefinedBy ; + rdfs:label "Property" ; + rdfs:subClassOf rdfs:Resource . + +rdf:Seq + a rdfs:Class ; + rdfs:comment "The class of ordered containers." ; + rdfs:isDefinedBy ; + rdfs:label "Seq" ; + rdfs:subClassOf rdfs:Container . + +rdf:Statement + a rdfs:Class ; + rdfs:comment "The class of RDF statements." ; + rdfs:isDefinedBy ; + rdfs:label "Statement" ; + rdfs:subClassOf rdfs:Resource . + +rdf:XMLLiteral + a rdfs:Datatype ; + rdfs:comment "The class of XML literal values." ; + rdfs:isDefinedBy ; + rdfs:label "XML Literal" ; + rdfs:subClassOf rdfs:Literal . + +rdf:first + a rdf:Property ; + rdfs:comment "The first item in the subject RDF list." ; + rdfs:domain rdf:List ; + rdfs:isDefinedBy ; + rdfs:label "first" ; + rdfs:range rdfs:Resource . + +rdf:nil + a rdf:List ; + rdfs:comment "The empty list, with no items in it. If the rest of a list is nil then the list has no more items in it." ; + rdfs:isDefinedBy ; + rdfs:label "nil" . + +rdf:object + a rdf:Property ; + rdfs:comment "The object of the subject RDF statement." ; + rdfs:domain rdf:Statement ; + rdfs:isDefinedBy ; + rdfs:label "object" ; + rdfs:range rdfs:Resource . + +rdf:predicate + a rdf:Property ; + rdfs:comment "The predicate of the subject RDF statement." ; + rdfs:domain rdf:Statement ; + rdfs:isDefinedBy ; + rdfs:label "predicate" ; + rdfs:range rdfs:Resource . + +rdf:rest + a rdf:Property ; + rdfs:comment "The rest of the subject RDF list after the first item." ; + rdfs:domain rdf:List ; + rdfs:isDefinedBy ; + rdfs:label "rest" ; + rdfs:range rdf:List . + +rdf:subject + a rdf:Property ; + rdfs:comment "The subject of the subject RDF statement." ; + rdfs:domain rdf:Statement ; + rdfs:isDefinedBy ; + rdfs:label "subject" ; + rdfs:range rdfs:Resource . + +rdf:type + a rdf:Property ; + rdfs:comment "The subject is an instance of a class." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "type" ; + rdfs:range rdfs:Class . + +rdf:value + a rdf:Property ; + rdfs:comment "Idiomatic property used for structured values." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "value" ; + rdfs:range rdfs:Resource . + diff --git a/schemas/rdfs.ttl b/schemas/rdfs.ttl new file mode 100644 index 00000000..43c51e58 --- /dev/null +++ b/schemas/rdfs.ttl @@ -0,0 +1,123 @@ +@prefix rdf: . +@prefix rdfs: . +@prefix owl: . + + + rdfs:comment "The RDF Schema vocabulary (RDFS)" ; + a owl:Ontology ; + rdfs:seeAlso . + +rdfs:Class + a rdfs:Class ; + rdfs:comment "The class of classes." ; + rdfs:isDefinedBy ; + rdfs:label "Class" ; + rdfs:subClassOf rdfs:Resource . + +rdfs:Container + a rdfs:Class ; + rdfs:comment "The class of RDF containers." ; + rdfs:isDefinedBy ; + rdfs:label "Container" ; + rdfs:subClassOf rdfs:Resource . + +rdfs:ContainerMembershipProperty + a rdfs:Class ; + rdfs:comment "The class of container membership properties, rdf:_1, rdf:_2, ..., all of which are sub-properties of 'member'." ; + rdfs:isDefinedBy ; + rdfs:label "Container Membership Property" ; + rdfs:subClassOf rdf:Property . + +rdfs:Datatype + a rdfs:Class ; + rdfs:comment "The class of RDF datatypes." ; + rdfs:isDefinedBy ; + rdfs:label "Datatype" ; + rdfs:subClassOf rdfs:Class . + +rdfs:Literal + a rdfs:Class ; + rdfs:comment "The class of literal values, eg. textual strings and integers." ; + rdfs:isDefinedBy ; + rdfs:label "Literal" ; + rdfs:subClassOf rdfs:Resource . + +rdfs:Resource + a rdfs:Class ; + rdfs:comment "The class resource, everything." ; + rdfs:isDefinedBy ; + rdfs:label "Resource" . + +rdfs:comment + a rdf:Property ; + rdfs:comment "A description of the subject resource." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "comment" ; + rdfs:range rdfs:Literal . + +rdfs:domain + a rdf:Property ; + rdfs:comment "A domain of the subject property." ; + rdfs:domain rdf:Property ; + rdfs:isDefinedBy ; + rdfs:label "domain" ; + rdfs:range rdfs:Class . + +rdfs:isDefinedBy + a rdf:Property ; + rdfs:comment "The defininition of the subject resource." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "is defined by" ; + rdfs:range rdfs:Resource ; + rdfs:subPropertyOf rdfs:seeAlso . + +rdfs:label + a rdf:Property ; + rdfs:comment "A human-readable name for the subject." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "label" ; + rdfs:range rdfs:Literal . + +rdfs:member + a rdf:Property ; + rdfs:comment "A member of the subject resource." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "member" ; + rdfs:range rdfs:Resource . + +rdfs:range + a rdf:Property ; + rdfs:comment "A range of the subject property." ; + rdfs:domain rdf:Property ; + rdfs:isDefinedBy ; + rdfs:label "range" ; + rdfs:range rdfs:Class . + +rdfs:seeAlso + a rdf:Property ; + rdfs:comment "Further information about the subject resource." ; + rdfs:domain rdfs:Resource ; + rdfs:isDefinedBy ; + rdfs:label "see also" ; + rdfs:range rdfs:Resource . + +rdfs:subClassOf + a rdf:Property ; + rdfs:comment "The subject is a subclass of a class." ; + rdfs:domain rdfs:Class ; + rdfs:isDefinedBy ; + rdfs:label "sub-class of" ; + rdfs:range rdfs:Class . + +rdfs:subPropertyOf + a rdf:Property ; + rdfs:comment "The subject is a subproperty of a property." ; + rdfs:domain rdf:Property ; + rdfs:isDefinedBy ; + rdfs:label "sub-property of" ; + rdfs:range rdf:Property . + diff --git a/schemas/xsd.ttl b/schemas/xsd.ttl new file mode 100644 index 00000000..46f6793a --- /dev/null +++ b/schemas/xsd.ttl @@ -0,0 +1,353 @@ +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . +@prefix xsd: . + + + a owl:Ontology ; + rdfs:comment "XML Schema Datatypes" . + +xsd:ID + a rdfs:Datatype ; + owl:onDatatype xsd:NCName . + +xsd:IDREF + a rdfs:Datatype ; + owl:onDatatype xsd:NCName . + +xsd:ENTITY + a rdfs:Datatype ; + owl:onDatatype xsd:NCName . + +xsd:NCName + a rdfs:Datatype ; + owl:onDatatype xsd:Name . + +xsd:NMTOKEN + a rdfs:Datatype ; + owl:onDatatype xsd:token . + +xsd:Name + a rdfs:Datatype ; + owl:onDatatype xsd:token . + +xsd:totalDigits + a rdf:Property , + owl:DatatypeProperty ; + rdfs:range xsd:positiveInteger ; + rdfs:label "total digits" ; + rdfs:comment "The maximum number of decimal digits required to represent a value." . + +xsd:fractionDigits + a rdf:Property , + owl:DatatypeProperty ; + rdfs:range xsd:nonNegativeInteger ; + rdfs:label "fraction digits" ; + rdfs:comment "The total number of digits to the right of the decimal point required to represent a value." . + +xsd:pattern + a rdf:Property , + owl:DatatypeProperty ; + rdfs:label "pattern" ; + rdfs:comment "A regular expression that matches complete valid literals." . + +xsd:maxInclusive + a rdf:Property , + owl:DatatypeProperty ; + rdfs:label "max inclusive" ; + rdfs:comment "The inclusive upper bound of an ordered datatype." . + +xsd:maxExclusive + a rdf:Property , + owl:DatatypeProperty ; + rdfs:label "max exclusive" ; + rdfs:comment "The exclusive upper bound of an ordered datatype." . + +xsd:minInclusive + a rdf:Property , + owl:DatatypeProperty ; + rdfs:label "min inclusive" ; + rdfs:comment "The inclusive lower bound of an ordered datatype." . + +xsd:minExclusive + a rdf:Property , + owl:DatatypeProperty ; + rdfs:label "min exclusive" ; + rdfs:comment "The exclusive lower bound of an ordered datatype." . + +xsd:QName + a rdfs:Datatype ; + rdfs:label "XML qualified name" . + +xsd:anyURI + a rdfs:Datatype ; + rdfs:label "URI reference" . + +xsd:base64Binary + a rdfs:Datatype ; + rdfs:label "base64 binary" ; + rdfs:comment "Base64-encoded arbitrary binary data." ; + owl:withRestrictions ( + [ + xsd:pattern "(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?" + ] + ) . + +xsd:boolean + a rdfs:Datatype ; + rdfs:label "boolean" ; + owl:withRestrictions ( + [ + xsd:pattern "(true|false)" + ] + ) . + +xsd:byte + a rdfs:Datatype ; + rdfs:label "byte" ; + owl:onDatatype xsd:short ; + owl:withRestrictions ( + [ + xsd:maxInclusive 127 + ] [ + xsd:minInclusive -128 + ] + ) . + +xsd:date + a rdfs:Datatype ; + rdfs:label "date" ; + owl:withRestrictions ( + [ + xsd:pattern "-?[0-9][0-9][0-9][0-9]([0-9]*)?-(0[1-9]|1[0-2])-([0-3][0-9])([+-]([0-1][0-9]|2[0-3]):[0-5][0-9])?" + ] + ) . + +xsd:dateTime + a rdfs:Datatype ; + rdfs:label "date time" . + +xsd:decimal + a rdfs:Datatype ; + rdfs:label "decimal" ; + rdfs:comment "A subset of the real numbers, which can be represented by decimal numerals." ; + owl:withRestrictions ( + [ + xsd:pattern "[+-]?[0-9]*\\.?[0-9]*" + ] + ) . + +xsd:double + a rdfs:Datatype ; + rdfs:label "double" ; + rdfs:comment "IEEE double-precision 64-bit floating point." ; + owl:withRestrictions ( + [ + xsd:pattern "[+-]?[0-9]*\\.?[0-9]*([eE][-+]?[0-9]+)?" + ] + ) . + +xsd:duration + a rdfs:Datatype ; + rdfs:label "duration" . + +xsd:float + a rdfs:Datatype ; + rdfs:label "float" ; + rdfs:comment "IEEE single-precision 32-bit floating point." ; + owl:onDatatype xsd:double . + +xsd:gDay + a rdfs:Datatype . + +xsd:gMonth + a rdfs:Datatype . + +xsd:gMonthDay + a rdfs:Datatype . + +xsd:gYear + a rdfs:Datatype . + +xsd:gYearMonth + a rdfs:Datatype . + +xsd:hexBinary + a rdfs:Datatype ; + rdfs:label "hex binary" ; + rdfs:comment "Hex-encoded arbitrary binary data." ; + owl:withRestrictions ( + [ + xsd:pattern "[0-9A-F]*" + ] + ) . + +xsd:int + a rdfs:Datatype ; + rdfs:label "int" ; + owl:onDatatype xsd:long ; + owl:withRestrictions ( + [ + xsd:maxInclusive 2147483647 + ] [ + xsd:minInclusive -2147483648 + ] + ) . + +xsd:integer + a rdfs:Datatype ; + rdfs:label "integer" ; + owl:onDatatype xsd:decimal ; + owl:withRestrictions ( + [ + xsd:pattern "[-+]?[0-9]+" + ] [ + xsd:fractionDigits 0 + ] + ) . + +xsd:language + a rdfs:Datatype ; + rdfs:label "language" ; + owl:onDatatype xsd:token ; + owl:withRestrictions ( + [ + xsd:pattern "[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*" + ] + ) . + +xsd:long + a rdfs:Datatype ; + rdfs:label "long" ; + owl:onDatatype xsd:integer ; + owl:withRestrictions ( + [ + xsd:maxInclusive 9223372036854775807 + ] [ + xsd:minInclusive -9223372036854775808 + ] + ) . + +xsd:negativeInteger + a rdfs:Datatype ; + rdfs:label "negative integer" ; + owl:onDatatype xsd:nonPositiveInteger ; + owl:withRestrictions ( + [ + xsd:maxInclusive -1 + ] + ) . + +xsd:nonNegativeInteger + a rdfs:Datatype ; + rdfs:label "non-negative integer" ; + owl:onDatatype xsd:integer ; + owl:withRestrictions ( + [ + xsd:pattern "[0-9]*" + ] [ + xsd:minInclusive 0 + ] + ) . + +xsd:nonPositiveInteger + a rdfs:Datatype ; + rdfs:label "non-positive integer" ; + owl:onDatatype xsd:integer ; + owl:withRestrictions ( + [ + xsd:pattern "(0|-[0-9]+)" + ] [ + xsd:maxInclusive 0 + ] + ) . + +xsd:normalizedString + a rdfs:Datatype ; + rdfs:label "normalized string" ; + owl:onDatatype xsd:string ; + rdfs:comment "The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters." . + +xsd:positiveInteger + a rdfs:Datatype ; + rdfs:label "positive integer" ; + owl:onDatatype xsd:nonNegativeInteger ; + owl:withRestrictions ( + [ + xsd:pattern "[+]?[0-9]+" + ] [ + xsd:minInclusive 1 + ] + ) . + +xsd:short + a rdfs:Datatype ; + rdfs:label "short" ; + owl:onDatatype xsd:int ; + owl:withRestrictions ( + [ + xsd:maxInclusive 32767 + ] [ + xsd:minInclusive -32768 + ] + ) . + +xsd:string + a rdfs:Datatype ; + rdfs:label "string" ; + rdfs:comment "A character string." . + +xsd:time + a rdfs:Datatype ; + rdfs:label "time" ; + owl:withRestrictions ( + [ + xsd:pattern "[1-2][0-9]:[0-5][0-9]:[0-5][0-9].[0-9][0-9][0-9]" + ] + ) . + +xsd:token + a rdfs:Datatype ; + rdfs:label "token" ; + owl:onDatatype xsd:normalizedString ; + rdfs:comment "The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters, that have no leading or trailing spaces (#x20) and that have no internal sequences of two or more spaces." . + +xsd:unsignedByte + a rdfs:Datatype ; + rdfs:label "unsigned byte" ; + owl:onDatatype xsd:unsignedShort ; + owl:withRestrictions ( + [ + xsd:maxInclusive 255 + ] + ) . + +xsd:unsignedInt + a rdfs:Datatype ; + rdfs:label "unsigned int" ; + owl:onDatatype xsd:unsignedLong ; + owl:withRestrictions ( + [ + xsd:maxInclusive 4294967295 + ] + ) . + +xsd:unsignedLong + a rdfs:Datatype ; + rdfs:label "unsigned long" ; + owl:onDatatype xsd:nonNegativeInteger ; + owl:withRestrictions ( + [ + xsd:maxInclusive 18446744073709551615 + ] + ) . + +xsd:unsignedShort + a rdfs:Datatype ; + rdfs:label "unsigned short" ; + owl:onDatatype xsd:unsignedInt ; + owl:withRestrictions ( + [ + xsd:maxInclusive 65535 + ] + ) . diff --git a/tests/validate/bad-all-values-from.ttl b/tests/validate/bad-all-values-from.ttl new file mode 100644 index 00000000..e8243423 --- /dev/null +++ b/tests/validate/bad-all-values-from.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty rdfs:label ; + owl:allValuesFrom rdf:PlainLiteral + ] . + +eg:s + a eg:Thing ; + rdfs:label "plain" , + "not plain"^^rdf:XMLLiteral . + diff --git a/tests/validate/bad-cardinality-high.ttl b/tests/validate/bad-cardinality-high.ttl new file mode 100644 index 00000000..7e1605c3 --- /dev/null +++ b/tests/validate/bad-cardinality-high.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty rdf:value ; + owl:maxCardinality 1 + ] . + +eg:s + a eg:Thing ; + rdf:value 1 , + 2 . + diff --git a/tests/validate/bad-cardinality-low.ttl b/tests/validate/bad-cardinality-low.ttl new file mode 100644 index 00000000..93dd0051 --- /dev/null +++ b/tests/validate/bad-cardinality-low.ttl @@ -0,0 +1,16 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty rdf:value ; + owl:minCardinality 1 + ] . + +eg:s + a eg:Thing . + diff --git a/tests/validate/bad-cardinality.ttl b/tests/validate/bad-cardinality.ttl new file mode 100644 index 00000000..481fe456 --- /dev/null +++ b/tests/validate/bad-cardinality.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty rdf:value ; + owl:cardinality 3 + ] . + +eg:s + a eg:Thing ; + rdf:value 1 , + 2 . + diff --git a/tests/validate/bad-datatype-property.ttl b/tests/validate/bad-datatype-property.ttl new file mode 100644 index 00000000..a3e993f3 --- /dev/null +++ b/tests/validate/bad-datatype-property.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:value + rdfs:label "value" ; + a owl:DatatypeProperty . + +eg:Thing + a rdfs:Class . + +eg:s1 + a eg:Thing . + +eg:s2 + eg:value eg:s1 . + diff --git a/tests/validate/bad-domain.ttl b/tests/validate/bad-domain.ttl new file mode 100644 index 00000000..d36b5652 --- /dev/null +++ b/tests/validate/bad-domain.ttl @@ -0,0 +1,19 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class . + +eg:NonThing + a rdfs:Class . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:domain eg:Thing . + +eg:nonthing + a eg:NonThing ; + eg:value 42 . + diff --git a/tests/validate/bad-functional-property.ttl b/tests/validate/bad-functional-property.ttl new file mode 100644 index 00000000..53a73ccd --- /dev/null +++ b/tests/validate/bad-functional-property.ttl @@ -0,0 +1,13 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:identity + rdfs:label "identity" ; + a owl:FunctionalProperty . + +eg:s + eg:identity "me" , + "you" . + diff --git a/tests/validate/bad-inverse-functional-property.ttl b/tests/validate/bad-inverse-functional-property.ttl new file mode 100644 index 00000000..95c0aaea --- /dev/null +++ b/tests/validate/bad-inverse-functional-property.ttl @@ -0,0 +1,15 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:identity + rdfs:label "identity" ; + a owl:InverseFunctionalProperty . + +eg:s1 + eg:identity "me" . + +eg:s2 + eg:identity "me" . + diff --git a/tests/validate/bad-literal-pattern.ttl b/tests/validate/bad-literal-pattern.ttl new file mode 100644 index 00000000..40f9eec0 --- /dev/null +++ b/tests/validate/bad-literal-pattern.ttl @@ -0,0 +1,7 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:s + rdf:value "no"^^xsd:boolean . + diff --git a/tests/validate/bad-literal-value-high-exclusive.ttl b/tests/validate/bad-literal-value-high-exclusive.ttl new file mode 100644 index 00000000..9e2bfe47 --- /dev/null +++ b/tests/validate/bad-literal-value-high-exclusive.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:Normal + a rdfs:Datatype ; + rdfs:label "normal" ; + owl:onDatatype xsd:double ; + owl:withRestrictions ( + [ + xsd:maxExclusive 1.0 + ] [ + xsd:minExclusive 0.0 + ] + ) . + +eg:s + rdf:value "1.0"^^eg:Normal . diff --git a/tests/validate/bad-literal-value-high-inclusive.ttl b/tests/validate/bad-literal-value-high-inclusive.ttl new file mode 100644 index 00000000..b58793ec --- /dev/null +++ b/tests/validate/bad-literal-value-high-inclusive.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:Normal + a rdfs:Datatype ; + rdfs:label "normal" ; + owl:onDatatype xsd:double ; + owl:withRestrictions ( + [ + xsd:maxInclusive 1.0 + ] [ + xsd:minInclusive 0.0 + ] + ) . + +eg:s + rdf:value "1.1"^^eg:Normal . diff --git a/tests/validate/bad-literal-value-low-exclusive.ttl b/tests/validate/bad-literal-value-low-exclusive.ttl new file mode 100644 index 00000000..fdcaf94a --- /dev/null +++ b/tests/validate/bad-literal-value-low-exclusive.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:Normal + a rdfs:Datatype ; + rdfs:label "normal" ; + owl:onDatatype xsd:double ; + owl:withRestrictions ( + [ + xsd:maxExclusive 1.0 + ] [ + xsd:minExclusive 0.0 + ] + ) . + +eg:s + rdf:value "0.0"^^eg:Normal . diff --git a/tests/validate/bad-literal-value-low-inclusive.ttl b/tests/validate/bad-literal-value-low-inclusive.ttl new file mode 100644 index 00000000..c88123dd --- /dev/null +++ b/tests/validate/bad-literal-value-low-inclusive.ttl @@ -0,0 +1,19 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:Normal + a rdfs:Datatype ; + rdfs:label "normal" ; + owl:onDatatype xsd:double ; + owl:withRestrictions ( + [ + xsd:maxInclusive 1.0 + ] [ + xsd:minInclusive 0.0 + ] + ) . + +eg:s + rdf:value "-0.1"^^eg:Normal . + diff --git a/tests/validate/bad-object-property.ttl b/tests/validate/bad-object-property.ttl new file mode 100644 index 00000000..b4a31f9d --- /dev/null +++ b/tests/validate/bad-object-property.ttl @@ -0,0 +1,12 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:value + rdfs:label "value" ; + a owl:ObjectProperty . + +eg:s + eg:value "literal" . + diff --git a/tests/validate/bad-pattern.ttl b/tests/validate/bad-pattern.ttl new file mode 100644 index 00000000..1c367bd2 --- /dev/null +++ b/tests/validate/bad-pattern.ttl @@ -0,0 +1,21 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:BrokenLiteral + a rdfs:Datatype ; + rdfs:label "broken literal" ; + owl:withRestrictions ( + [ + xsd:pattern "[" + ] + ) . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range eg:BinaryLiteral . + +eg:s + eg:value "no match"^^eg:BrokenLiteral . + diff --git a/tests/validate/bad-plain-literal.ttl b/tests/validate/bad-plain-literal.ttl new file mode 100644 index 00000000..116faac0 --- /dev/null +++ b/tests/validate/bad-plain-literal.ttl @@ -0,0 +1,12 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range rdf:PlainLiteral . + +eg:s + eg:value "literal"^^rdf:XMLLiteral . + diff --git a/tests/validate/bad-range-instance-not-literal.ttl b/tests/validate/bad-range-instance-not-literal.ttl new file mode 100644 index 00000000..ea7803f6 --- /dev/null +++ b/tests/validate/bad-range-instance-not-literal.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range rdfs:Literal . + +eg:thing + a eg:Thing . + +eg:s + eg:value eg:thing . + diff --git a/tests/validate/bad-range-instance.ttl b/tests/validate/bad-range-instance.ttl new file mode 100644 index 00000000..a04a5476 --- /dev/null +++ b/tests/validate/bad-range-instance.ttl @@ -0,0 +1,21 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class . + +eg:NonThing + a rdfs:Class . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range eg:Thing . + +eg:nonthing + a eg:NonThing . + +eg:s + eg:value eg:nonthing . + diff --git a/tests/validate/bad-range-literal-not-instance.ttl b/tests/validate/bad-range-literal-not-instance.ttl new file mode 100644 index 00000000..f46de8ce --- /dev/null +++ b/tests/validate/bad-range-literal-not-instance.ttl @@ -0,0 +1,15 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range eg:Thing . + +eg:s + eg:value "literal" . + diff --git a/tests/validate/bad-range-literal.ttl b/tests/validate/bad-range-literal.ttl new file mode 100644 index 00000000..cbeb4074 --- /dev/null +++ b/tests/validate/bad-range-literal.ttl @@ -0,0 +1,25 @@ +@prefix eg: . +@prefix rdf: . +@prefix rdfs: . + +eg:Normal + a rdfs:Datatype ; + rdfs:label "normal" ; + owl:onDatatype xsd:double ; + owl:withRestrictions ( + [ + xsd:maxExclusive 1.0 + ] [ + xsd:minExclusive 0.0 + ] + ) . + +eg:value + a rdf:Property ; + rdfs:label "value" ; + rdfs:range eg:Normal . + +eg:s + eg:value 2.0 . + + diff --git a/tests/validate/bad-some-values-from.ttl b/tests/validate/bad-some-values-from.ttl new file mode 100644 index 00000000..259bfb88 --- /dev/null +++ b/tests/validate/bad-some-values-from.ttl @@ -0,0 +1,18 @@ +@prefix eg: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . + +eg:Thing + a rdfs:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty rdfs:label ; + owl:someValuesFrom rdf:PlainLiteral + ] . + +eg:s + a eg:Thing ; + rdfs:label "not plain"^^rdf:XMLLiteral . + + diff --git a/tests/validate/bad-string-literal-value-high.ttl b/tests/validate/bad-string-literal-value-high.ttl new file mode 100644 index 00000000..7119e30a --- /dev/null +++ b/tests/validate/bad-string-literal-value-high.ttl @@ -0,0 +1,19 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:startsWithC + a rdfs:Datatype ; + rdfs:label "starts with C" ; + owl:onDatatype xsd:string ; + owl:withRestrictions ( + [ + xsd:maxExclusive "D" + ] [ + xsd:minInclusive "B" + ] + ) . + +eg:s + rdf:value "Door"^^eg:startsWithC . + diff --git a/tests/validate/bad-string-literal-value-low.ttl b/tests/validate/bad-string-literal-value-low.ttl new file mode 100644 index 00000000..93c2f17e --- /dev/null +++ b/tests/validate/bad-string-literal-value-low.ttl @@ -0,0 +1,19 @@ +@prefix eg: . +@prefix rdf: . +@prefix xsd: . + +eg:betweenBAndD + a rdfs:Datatype ; + rdfs:label "between B and D" ; + owl:onDatatype xsd:string ; + owl:withRestrictions ( + [ + xsd:maxInclusive "D" + ] [ + xsd:minExclusive "B" + ] + ) . + +eg:s + rdf:value "Aardvark"^^eg:betweenBAndD . + diff --git a/tests/validate/bad-unknown-datatype.ttl b/tests/validate/bad-unknown-datatype.ttl new file mode 100644 index 00000000..be2fc132 --- /dev/null +++ b/tests/validate/bad-unknown-datatype.ttl @@ -0,0 +1,6 @@ +@prefix eg: . +@prefix rdfs: . + +eg:s + rdfs:label "bad datatype"^^rdf:UndefinedLiteral . + diff --git a/tests/validate/bad-unknown-property.ttl b/tests/validate/bad-unknown-property.ttl new file mode 100644 index 00000000..0db1e85c --- /dev/null +++ b/tests/validate/bad-unknown-property.ttl @@ -0,0 +1,6 @@ +@prefix eg: . +@prefix rdfs: . + +eg:s + eg:undefined 0 . + diff --git a/tests/validate/manifest.ttl b/tests/validate/manifest.ttl new file mode 100644 index 00000000..46d7574b --- /dev/null +++ b/tests/validate/manifest.ttl @@ -0,0 +1,165 @@ +@prefix mf: . +@prefix rdf: . +@prefix rdfs: . +@prefix rdft: . +@prefix serd: . + +serd:TestTurtleNegativeValidate + a rdfs:Class ; + rdfs:subClassOf rdft:Test . + +<> + rdf:type mf:Manifest ; + rdfs:comment "Serd validation test cases" ; + mf:entries ( + <#bad-all-values-from> + <#bad-cardinality-high> + <#bad-cardinality-low> + <#bad-cardinality> + <#bad-datatype-property> + <#bad-domain> + <#bad-functional-property> + <#bad-inverse-functional-property> + <#bad-literal-pattern> + <#bad-literal-value-high-inclusive> + <#bad-literal-value-low-inclusive> + <#bad-literal-value-high-exclusive> + <#bad-literal-value-low-exclusive> + <#bad-string-literal-value-high> + <#bad-string-literal-value-low> + <#bad-object-property> + <#bad-pattern> + <#bad-plain-literal> + <#bad-range-instance-not-literal> + <#bad-range-instance> + <#bad-range-literal-not-instance> + <#bad-range-literal> + <#bad-some-values-from> + <#bad-unknown-datatype> + <#bad-unknown-property> + ) . + +<#bad-all-values-from> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-all-values-from" ; + mf:action . + +<#bad-cardinality-low> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-cardinality-low" ; + mf:action . + +<#bad-cardinality-high> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-cardinality-high" ; + mf:action . + +<#bad-cardinality> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-cardinality" ; + mf:action . + +<#bad-datatype-property> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-datatype-property" ; + mf:action . + +<#bad-domain> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-domain" ; + mf:action . + +<#bad-functional-property> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-functional-property" ; + mf:action . + +<#bad-inverse-functional-property> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-inverse-functional-property" ; + mf:action . + +<#bad-literal-pattern> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-literal-pattern" ; + mf:action . + +<#bad-literal-value-low-inclusive> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-literal-value-low-inclusive" ; + mf:action . + +<#bad-literal-value-high-inclusive> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-literal-value-high-inclusive" ; + mf:action . + +<#bad-literal-value-low-exclusive> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-literal-value-low-exclusive" ; + mf:action . + +<#bad-literal-value-high-exclusive> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-literal-value-high-exclusive" ; + mf:action . + +<#bad-string-literal-value-low> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-string-literal-value-low" ; + mf:action . + +<#bad-string-literal-value-high> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-string-literal-value-high" ; + mf:action . + +<#bad-object-property> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-object-property" ; + mf:action . + +<#bad-pattern> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-pattern" ; + mf:action . + +<#bad-plain-literal> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-plain-literal" ; + mf:action . + +<#bad-range-instance-not-literal> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-range-instance-not-literal" ; + mf:action . + +<#bad-range-instance> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-range-instance" ; + mf:action . + +<#bad-range-literal-not-instance> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-range-literal-not-instance" ; + mf:action . + +<#bad-range-literal> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-range-literal" ; + mf:action . + +<#bad-some-values-from> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-some-values-from" ; + mf:action . + +<#bad-unknown-datatype> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-unknown-datatype" ; + mf:action . + +<#bad-unknown-property> + rdf:type serd:TestTurtleNegativeValidate ; + mf:name "bad-unknown-property" ; + mf:action . diff --git a/wscript b/wscript index 8e61d5c8..be5a8159 100644 --- a/wscript +++ b/wscript @@ -172,6 +172,7 @@ def build(bld): # Test programs for prog in [('serdi_static', 'src/serdi.c'), + ('serd_validate_static', 'src/serd_validate.c'), ('base64_test', 'tests/base64_test.c'), ('cursor_test', 'tests/cursor_test.c'), ('statement_test', 'tests/statement_test.c'), @@ -181,12 +182,16 @@ def build(bld): ('nodes_test', 'tests/nodes_test.c'), ('overflow_test', 'tests/overflow_test.c'), ('model_test', 'tests/model_test.c')]: - bld(features = 'c cprogram', - source = prog[1], - use = 'libserd_profiled', - target = prog[0], - defines = defines, - **test_args) + obj = bld(features = 'c cprogram', + source = prog[1], + use = 'libserd_profiled', + target = prog[0], + defines = defines, + **test_args) + if prog[0] == 'serd_validate_static': + autowaf.use_lib(bld, obj, 'PCRE') + obj.cflags += bld.env.PTHREAD_CFLAGS + obj.linkflags += bld.env.PTHREAD_LINKFLAGS # Utilities if bld.env.BUILD_UTILS: @@ -390,6 +395,16 @@ def _file_lines_equal(patha, pathb, subst_from='', subst_to=''): return True +def _option_combinations(options): + "Return an iterator that cycles through all combinations of the given options" + import itertools + + thru_options = [] + for n in range(len(options) + 1): + thru_options += list(itertools.combinations(options, n)) + + return itertools.cycle(thru_options) + def test_suite(ctx, base_uri, testdir, report, isyntax, options=[]): import itertools @@ -405,12 +420,9 @@ def test_suite(ctx, base_uri, testdir, report, isyntax, options=[]): def run_tests(test_class, tests, expected_return): thru_flags = [['-e'], ['-b'], ['-r', 'http://example.org/']] - thru_options = [] - for n in range(len(thru_flags) + 1): - thru_options += list(itertools.combinations(thru_flags, n)) - thru_options_iter = itertools.cycle(thru_options) - osyntax = _test_output_syntax(test_class) + extra_options_iter = _option_combinations([['-f']]) + thru_options_iter = _option_combinations(thru_flags) tests_name = '%s.%s' % (testdir, test_class[test_class.find('#') + 1:]) with ctx.group(tests_name) as check: for test in sorted(tests): @@ -418,7 +430,10 @@ def test_suite(ctx, base_uri, testdir, report, isyntax, options=[]): action = os.path.join('tests', testdir, os.path.basename(action_node)) rel_action = os.path.join(os.path.relpath(srcdir), action) uri = base_uri + os.path.basename(action) - command = [serdi, '-a'] + options + [rel_action, uri] + command = ([serdi, '-a'] + + options + + flatten_options(next(extra_options_iter)) + + [rel_action, uri]) # Run strict test if expected_return == 0: @@ -466,6 +481,27 @@ def test_suite(ctx, base_uri, testdir, report, isyntax, options=[]): expected = 1 if 'Negative' in test_class else 0 run_tests(test_class, instances, expected) +def validation_test_suite(tst, base_uri, testdir, isyntax, osyntax, options=''): + srcdir = tst.path.abspath() + schemas = glob.glob(os.path.join(srcdir, 'schemas', '*.ttl')) + + test_class = 'http://drobilla.net/ns/serd#TestTurtleNegativeValidate' + mf = 'http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#' + mf_path = os.path.join(srcdir, 'tests', testdir, 'manifest.ttl') + + model, instances = _load_rdf(mf_path) + with tst.group('validation') as check: + for test in sorted(instances[test_class]): + action_node = model[test][mf + 'action'][0] + action = os.path.join('tests', 'validate', os.path.basename(action_node)) + rel_action = os.path.join(os.path.relpath(srcdir), action) + uri = base_uri + os.path.basename(action) + command = ['./serd_validate_static'] + schemas + [rel_action] + + if (tst.env.HAVE_PCRE + or os.path.basename(action_node) != 'bad-literal-pattern.ttl'): + check(command, expected=11, name=action) + def test(tst): import tempfile @@ -516,6 +552,9 @@ def test(tst): with tempfile.TemporaryFile(mode='r') as stdin: check([serdi, '-'], stdin=stdin) + check(['./serd_validate_static', '-v']) + check(['./serd_validate_static', '-h']) + with tst.group('BadCommands', expected=1) as check: check([serdi]) check([serdi, '/no/such/file']) @@ -533,6 +572,11 @@ def test(tst): check([serdi, '-r']) check([serdi, '-z']) + check(['./serd_validate_static']) + check(['./serd_validate_static', '-k']) + check(['./serd_validate_static', '-k', '-1']) + check(['./serd_validate_static', '-q', '-1']) + with tst.group('IoErrors', expected=1) as check: check([serdi, '-e', 'file://%s/' % srcdir], name='Read directory') check([serdi, 'file://%s/' % srcdir], name='Bulk read directory') @@ -545,6 +589,14 @@ def test(tst): test_suite(tst, serd_base + 'good/', 'good', None, 'Turtle') test_suite(tst, serd_base + 'bad/', 'bad', None, 'Turtle') + # Serd validation test suite + with open('validation_earl.ttl', 'w') as report: + serd_base = 'http://drobilla.net/sw/serd/tests/' + report.write('@prefix earl: .\n' + '@prefix dc: .\n') + validation_test_suite(tst, serd_base + 'validate/', 'validate', + None, 'Turtle', 'NTriples') + # Standard test suites with open('earl.ttl', 'w') as report: report.write('@prefix earl: .\n' -- cgit v1.2.1