# RDF Schema and Semantics tests
## Distributed under both the W3C Test Suite License[1] and the W3C 3-
## clause BSD License[2]. To contribute to a W3C Test Suite, see the
## policies and contribution forms [3]
##
## 1. http://www.w3.org/Consortium/Legal/2008/04-testsuite-license
## 2. http://www.w3.org/Consortium/Legal/2008/03-bsd-license
## 3. http://www.w3.org/2004/10/27-testcases

@prefix rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
@prefix mf: <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#> .
@prefix rdft:   <http://www.w3.org/ns/rdftest#> .
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .

<> rdf:type mf:Manifest ;
  rdfs:label "RDF Schema and Semantics tests" ;
  mf:entries (
    <#datatypes-intensional-xsd-integer-decimal-compatible>
#    <#datatypes-intensional-xsd-integer-string-incompatible> # recinded 2013-12-18
    <#datatypes-non-well-formed-literal-1>
    <#datatypes-non-well-formed-literal-2>
    <#datatypes-semantic-equivalence-within-type-1>
    <#datatypes-semantic-equivalence-within-type-2>
    <#datatypes-semantic-equivalence-between-datatypes>
    <#datatypes-range-clash>
    <#datatypes-test008>
    <#datatypes-test009>
    <#datatypes-test010>
    <#datatypes-plain-literal-and-xsd-string>
    <#horst-01-subClassOf-intensional>
    <#horst-01-subPropertyOf-intensional>
##    <#pfps-10-non-well-formed-literal-1>  # duplicate
    <#rdf-charmod-uris-test003>
    <#rdf-charmod-uris-test004>
    <#rdfms-seq-representation-test002>
    <#rdfms-seq-representation-test003>
    <#rdfms-seq-representation-test004>
    <#rdfms-xmllang-test007a>
    <#rdfms-xmllang-test007b>
    <#rdfms-xmllang-test007c>
    <#rdfs-container-membership-superProperty-test001>
    <#rdfs-domain-and-range-intensionality-range>
    <#rdfs-domain-and-range-intensionality-domain>
    <#rdfs-entailment-test001>
    <#rdfs-entailment-test002>
    <#rdfs-no-cycles-in-subClassOf-test001>
    <#rdfs-no-cycles-in-subPropertyOf-test001>
    <#rdfs-subClassOf-a-Property-test001>
    <#rdfs-subPropertyOf-semantics-test001>
    <#statement-entailment-test001>
    <#statement-entailment-test002>
    <#statement-entailment-test003>
    <#statement-entailment-test004>
    <#tex-01-language-tag-case-1>
    <#tex-01-language-tag-case-2>
    <#xmlsch-02-whitespace-facet-1>
    <#xmlsch-02-whitespace-facet-2>
#    <#xmlsch-02-whitespace-facet-3> # recinded 2013-12-17
    <#xmlsch-02-whitespace-facet-4>
  ) .

<#datatypes-intensional-xsd-integer-decimal-compatible> a mf:NegativeEntailmentTest;
  mf:name "datatypes-intensional-xsd-integer-decimal-compatible";
  rdfs:comment """
    The claim that xsd:integer is a subClassOF xsd:decimal is not
    incompatible with using the intensional semantics for
    datatypes.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:decimal xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes-intensional/test001.nt>;
  mf:result false .
    
<#datatypes-intensional-xsd-integer-string-incompatible> a mf:PositiveEntailmentTest;
  mf:name "datatypes-intensional-xsd-integer-string-incompatible";
  rdfs:comment """
    The claim that xsd:integer is a subClassOF xsd:string is
    incompatible with using the intensional semantics for
    datatypes.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:integer xsd:string ) ;
## This used to be incorrect.
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes-intensional/test002.nt>;
  mf:result false .
    
<#datatypes-non-well-formed-literal-1> a mf:NegativeEntailmentTest;
  mf:name "datatypes-non-well-formed-literal-1";
  rdfs:comment """
    Without datatype knowledge, a 'badly-formed' datatyped literal
    cannot be detected.
  """;
  rdfs:comment """
    Used to be a postitive test to itself.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( xsd:integer ) ;
  mf:action <datatypes/test002.nt>;
  mf:result false .
    
<#datatypes-non-well-formed-literal-2> a mf:PositiveEntailmentTest;
  mf:name "datatypes-non-well-formed-literal-2";
  rdfs:comment """
    With appropriate datatype knowledge, a 'badly-formed'
    datatyped literal can be detected.
  """;
  rdfs:comment """
    Ill-formed datatyped literals now are inconsistent.
    Used to be negative entailment to <datatypes/test002b.nt>
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test002.nt>;
  mf:result false. 
    
<#datatypes-semantic-equivalence-within-type-1> a mf:PositiveEntailmentTest;
  mf:name "datatypes-semantic-equivalence-within-type-1";
  rdfs:comment """
    Demonstrating the semantic equivalence of two lexical forms of
    the same datatyped value.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test003a.nt>;
  mf:result <datatypes/test003b.nt> .
    
<#datatypes-semantic-equivalence-within-type-2> a mf:PositiveEntailmentTest;
  mf:name "datatypes-semantic-equivalence-within-type-2";
  rdfs:comment """
    As semantic-equivalence-within-type-1; the entailment works
    both ways.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test003b.nt>;
  mf:result <datatypes/test003a.nt> .
    
<#datatypes-semantic-equivalence-between-datatypes> a mf:PositiveEntailmentTest;
  mf:name "datatypes-semantic-equivalence-between-datatypes";
  rdfs:comment """
    Members of different datatypes may be semantically equivalent.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( xsd:decimal xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test005a.nt>;
  mf:result <datatypes/test005b.nt> .
    
<#datatypes-range-clash> a mf:PositiveEntailmentTest;
  mf:name "datatypes-range-clash";
  rdfs:comment """
    Where sufficient DT knowledge is available, a range clash may
    be detected; the document then contains a contradiction.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:integer xsd:string ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test006.nt>;
  mf:result false .
    
<#datatypes-test008> a mf:PositiveEntailmentTest;
  mf:name "datatypes-test008";
  rdfs:comment """
    From decisions listed in
    http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2002Oct/0098.html
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "simple" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test008a.nt>;
  mf:result <datatypes/test008b.nt> .
    
<#datatypes-test009> a mf:NegativeEntailmentTest;
  mf:name "datatypes-test009";
  rdfs:comment """
    From decisions listed in
    http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2002Oct/0098.html
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "simple" ;
  mf:recognizedDatatypes (  ) ;
  mf:unrecognizedDatatypes ( xsd:integer ) ;
  mf:action <datatypes/test009a.nt>;
  mf:result <datatypes/test009b.nt> .
    
<#datatypes-test010> a mf:PositiveEntailmentTest;
  mf:name "datatypes-test010";
  rdfs:comment """
    From decisions listed in
    http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2002Oct/0098.html
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:integer ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test010.nt>;
  mf:result false .
    
<#datatypes-plain-literal-and-xsd-string> a mf:PositiveEntailmentTest;
  mf:name "datatypes-plain-literal-and-xsd-string";
  rdfs:comment """
    A plain literal denotes the same thing as its corresponding
    xsd:string, where one exists.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:string ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <datatypes/test011a.nt>;
  mf:result <datatypes/test011b.nt> .
    
<#horst-01-subClassOf-intensional> a mf:NegativeEntailmentTest;
  mf:name "horst-01-subClassOf-intensional";
  rdfs:comment """
    rdfs:subClassOf has intensional semantics, not extensional.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <horst-01/test001.ttl>;
  mf:result <horst-01/test002.ttl> .
    
<#horst-01-subPropertyOf-intensional> a mf:NegativeEntailmentTest;
  mf:name "horst-01-subPropertyOf-intensional";
  rdfs:comment """
    rdfs:subPropertyOf has intensional semantics, not extensional.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <horst-01/test003.ttl>;
  mf:result <horst-01/test004.ttl> .
    
<#pfps-10-non-well-formed-literal-1> a mf:PositiveEntailmentTest;
  mf:name "pfps-10-non-well-formed-literal-1";
  rdfs:comment """
    Test that ICEXT(I(rdfs:Literal)) is a subset of LV.
  """;
  rdfs:comment """
    Duplicate of xmlsch-02-whitespace-facet-3, so this has been removed.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <pfps-10/test001a.nt>;
  mf:result <pfps-10/test001b.nt> .
    
<#rdf-charmod-uris-test003> a mf:NegativeEntailmentTest;
  mf:name "rdf-charmod-uris-test003";
  rdfs:comment """
    An international URI ref and its %-escaped form label
    different nodes in the graph. No model theoretic relationship
    holds between them.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdf-charmod-uris/test001.ttl>;
  mf:result <rdf-charmod-uris/test002.ttl> .
    
<#rdf-charmod-uris-test004> a mf:NegativeEntailmentTest;
  mf:name "rdf-charmod-uris-test004";
  rdfs:comment """
    An international URI ref and its %-escaped form label
    different nodes in the graph. No model theoretic relationship
    holds between them.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdf-charmod-uris/test002.ttl>;
  mf:result <rdf-charmod-uris/test001.ttl> .
    
<#rdfms-seq-representation-test002> a mf:PositiveEntailmentTest;
  mf:name "rdfms-seq-representation-test002";
  rdfs:comment """
    Statement of the MT closure rule.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-seq-representation/empty.nt>;
  mf:result <rdfms-seq-representation/test002.nt> .
    
<#rdfms-seq-representation-test003> a mf:PositiveEntailmentTest;
  mf:name "rdfms-seq-representation-test003";
  rdfs:comment """
    Statement of the MT closure rule.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-seq-representation/test003a.nt>;
  mf:result <rdfms-seq-representation/test003b.nt> .
    
<#rdfms-seq-representation-test004> a mf:PositiveEntailmentTest;
  mf:name "rdfms-seq-representation-test004";
  rdfs:comment """
    Statement of the MT closure rule.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-seq-representation/empty.nt>;
  mf:result <rdfms-seq-representation/test004.nt> .
    
<#rdfms-xmllang-test007a> a mf:NegativeEntailmentTest;
  mf:name "rdfms-xmllang-test007a";
  rdfs:comment """
    Plain literals are distinguishable on the basis of language
    tags.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "simple" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-xmllang/test007a.nt>;
  mf:result <rdfms-xmllang/test007b.nt> .
    
<#rdfms-xmllang-test007b> a mf:NegativeEntailmentTest;
  mf:name "rdfms-xmllang-test007b";
  rdfs:comment """
    Plain literals are distinguishable on the basis of language
    tags.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "simple" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-xmllang/test007b.nt>;
  mf:result <rdfms-xmllang/test007c.nt> .
    
<#rdfms-xmllang-test007c> a mf:NegativeEntailmentTest;
  mf:name "rdfms-xmllang-test007c";
  rdfs:comment """
    Plain literals are distinguishable on the basis of language
    tags.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "simple" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfms-xmllang/test007c.nt>;
  mf:result <rdfms-xmllang/test007a.nt> .
    
<#rdfs-container-membership-superProperty-test001> a mf:NegativeEntailmentTest;
  mf:name "rdfs-container-membership-superProperty-test001";
  rdfs:comment """
    While it is a superproperty, `_:a <rdfs:contains (@@member?)> _:b .`
    does NOT entail `_:a <rdf:_n> _:b . for any _n.`
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-container-membership-superProperty/not1P.ttl>;
  mf:result <rdfs-container-membership-superProperty/not1C.ttl> .
    
<#rdfs-domain-and-range-intensionality-range> a mf:NegativeEntailmentTest;
  mf:name "rdfs-domain-and-range-intensionality-range";
  rdfs:comment """
    RDF Semantics defines rdfs:range to have an intensional
    reading. However, semantic extensions may give an extensional
    reading to range. The premise/conclusion pair is a
    non-entailment for RDFS reasoning, but may hold in semantic
    extensions.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-domain-and-range/premises005.ttl>;
  mf:result <rdfs-domain-and-range/nonconclusions005.ttl> .
    
<#rdfs-domain-and-range-intensionality-domain> a mf:NegativeEntailmentTest;
  mf:name "rdfs-domain-and-range-intensionality-domain";
  rdfs:comment """
    RDF Semantics defines rdfs:range to have an intensional
    reading of domain. However, semantic extensions may give an
    extensional reading to domain. The premise/conclusion pair is
    a non-entailment for RDFS reasoning, but may hold in semantic
    extensions.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-domain-and-range/premises006.ttl>;
  mf:result <rdfs-domain-and-range/nonconclusions006.ttl> .

<#rdfs-entailment-test001> a mf:PositiveEntailmentTest;
  mf:name "rdfs-entailment-test001";
  rdfs:comment """
    Indicating a simple inconsistency drawn from RDFS. RDFS can
    only produce inconsistencies through badly-formed XMLLiteral
    datatypes.
  """;
  rdfs:comment """
    rdf:XMLLiteral support is no longer mandatory.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( rdf:XMLLiteral ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-entailment/test001.nt>;
  mf:result false .
    
<#rdfs-entailment-test002> a mf:PositiveEntailmentTest;
  mf:name "rdfs-entailment-test002";
  rdfs:comment """
    Datatype clashes can occur in RDFS entailment.
  """;
  rdfs:comment """
    Use to be from an inconsistent graph, any entailment can be drawn. This
    is an example.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:string rdf:langString ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-entailment/test002p.nt> ;
  mf:result false.
## was <rdfs-entailment/test002.nt>
    
<#rdfs-no-cycles-in-subClassOf-test001> a mf:PositiveEntailmentTest;
  mf:name "rdfs-no-cycles-in-subClassOf-test001";
  rdfs:comment """
    Cycles are permitted in subClassOf; therefore, no error occurs
    and the following entailment holds trivially.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-no-cycles-in-subClassOf/test001.ttl>;
  mf:result <rdfs-no-cycles-in-subClassOf/test001.nt> .
    
<#rdfs-no-cycles-in-subPropertyOf-test001> a mf:PositiveEntailmentTest;
  mf:name "rdfs-no-cycles-in-subPropertyOf-test001";
  rdfs:comment """
    Cycles are permitted in subPropertyOf; therefore, no error
    occurs and the following entailment holds trivially.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-no-cycles-in-subPropertyOf/test001.ttl>;
  mf:result <rdfs-no-cycles-in-subPropertyOf/test001.nt> .
    
<#rdfs-subClassOf-a-Property-test001> a mf:NegativeEntailmentTest;
  mf:name "rdfs-subClassOf-a-Property-test001";
  rdfs:comment """
    an instance of the Property class may have an rdfs:subClassOf
    property. the meaning of such a property is defined by the
    model theory. The wording of the formal resolution is a bit
    bare, so let me add a few words of explanation. What this
    means is that a resource can be both a class and a property.
    This test is encoded as follows: a Property may have a
    subclass (that is, such an RDF graph is satisfiable)
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-subClassOf-a-Property/test001.nt>;
  mf:result false .
    
<#rdfs-subPropertyOf-semantics-test001> a mf:PositiveEntailmentTest;
  mf:name "rdfs-subPropertyOf-semantics-test001";
  rdfs:comment """
    The inheritance semantics of the subPropertyOf relationship
    needs to be clarified. => subProperties inherit conjunctively
    the domain and range of their superproperties
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <rdfs-subPropertyOf-semantics/test001.nt>;
  mf:result <rdfs-subPropertyOf-semantics/test002.nt> .
    
<#statement-entailment-test001> a mf:NegativeEntailmentTest;
  mf:name "statement-entailment-test001";
  rdfs:comment """
    RDFCore WG RESOLVED that a reified statement was a stating,
    not a statement. The following entailment does not, therefore,
    hold.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <statement-entailment/test001a.nt>;
  mf:result <statement-entailment/test001b.nt> .
    
<#statement-entailment-test002> a mf:NegativeEntailmentTest;
  mf:name "statement-entailment-test002";
  rdfs:comment """
    RDFCore WG RESOLVED that a statement does NOT entail its
    reification. The following entailment does not, therefore,
    hold.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <statement-entailment/test002a.nt>;
  mf:result <statement-entailment/test002b.nt> .
    
<#statement-entailment-test003> a mf:NegativeEntailmentTest;
  mf:name "statement-entailment-test003";
  rdfs:comment """
    RDFCore WG RESOLVED that a reified statement was a stating,
    not a statement. The following entailment does not, therefore,
    hold. This is the same as test001, but using RDFS-entailment.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <statement-entailment/test001a.nt>;
  mf:result <statement-entailment/test001b.nt> .
    
<#statement-entailment-test004> a mf:NegativeEntailmentTest;
  mf:name "statement-entailment-test004";
  rdfs:comment """
    RDFCore WG RESOLVED that a statement does NOT entail its
    reification. The following entailment does not, therefore,
    hold. This is the same as test002, but using RDFS-entailment.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <statement-entailment/test002a.nt>;
  mf:result <statement-entailment/test002b.nt> .
    
<#tex-01-language-tag-case-1> a mf:PositiveEntailmentTest;
  mf:name "tex-01-language-tag-case-1";
  rdfs:comment """
    The case of the language tag is not significant.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <tex-01/test001.ttl>;
  mf:result <tex-01/test002.ttl> .
    
<#tex-01-language-tag-case-2> a mf:PositiveEntailmentTest;
  mf:name "tex-01-language-tag-case-2";
  rdfs:comment """
    The case of the language tag is not significant.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDF" ;
  mf:recognizedDatatypes ( ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <tex-01/test002.ttl>;
  mf:result <tex-01/test001.ttl> .
    
<#xmlsch-02-whitespace-facet-1> a mf:NegativeEntailmentTest;
  mf:name "xmlsch-02-whitespace-facet-1";
  rdfs:comment """
    A well-formed typed literal is not related to an ill-formed
    literal. Even if they only differ by whitespace.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:int ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <xmlsch-02/test001.ttl>;
  mf:result <xmlsch-02/test002.ttl> .
    
<#xmlsch-02-whitespace-facet-2> a mf:PositiveEntailmentTest;
  mf:name "xmlsch-02-whitespace-facet-2";
  rdfs:comment """
    A well-formed typed literal is not related to an ill-formed
    literal. Even if they only differ by whitespace.
  """;
  rdfs:comment """
    Ill-formed datatyped literals now are inconsistent.
    Used to be negative entailment to <xmlsch-02/test001.ttl> .
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:int ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <xmlsch-02/test002.ttl>;
  mf:result false .
    
<#xmlsch-02-whitespace-facet-3> a mf:PositiveEntailmentTest;
  mf:name "xmlsch-02-whitespace-facet-3";
  rdfs:comment """
    A simple test for well-formedness of a typed literal.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:int ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <xmlsch-02/test001.ttl>;
  mf:result <xmlsch-02/test003.ttl> .
    
<#xmlsch-02-whitespace-facet-4> a mf:PositiveEntailmentTest;
  mf:name "xmlsch-02-whitespace-facet-4";
  rdfs:comment """
    An integer with whitespace is ill-formed.
  """;
  rdfs:comment """
    Ill-formed datatyped literals now are inconsistent.
    Used to be negative entailment.
  """;
  rdft:approval rdft:Approved;
  mf:entailmentRegime "RDFS" ;
  mf:recognizedDatatypes ( xsd:int ) ;
  mf:unrecognizedDatatypes ( ) ;
  mf:action <xmlsch-02/test002.ttl>;
  mf:result false .
## was <xmlsch-02/test003.ttl>
    
