@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 xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix : <#> .

<>  rdf:type mf:Manifest ;
    rdfs:comment "LD-Patch tests" ;
    mf:include (
        <manifest-syntax.ttl>
        <turtle/manifest-ldpatch.ttl>
    ) ;
    mf:entries
    (
        # atomic evaluation tests
        <#empty>
        <#add-1triple>
        <#add-abbr-1triple>
        <#addnew-1triple>
        <#addnew-abbr-1triple>
        <#delete-1triple>
        <#delete-abbr-1triple>
        <#deleteexisting-1triple>
        <#deleteexisting-abbr-1triple>
        <#bind>
        <#bind-abbr>
        <#bind-overriden>
        <#path-forward>
        <#path-backward>
        <#path-at>
        <#path-unicity>
        <#path-unicity-fail>
        <#path-filter>
        <#path-filter-equal>
        <#path-starting-with-literal>
        <#add-noop>
        <#addnew-noop-fail>
        <#delete-noop>
        <#deleteexisting-noop-fail>
        <#cut>
        <#cut-abbr>
        <#cut-fail>
        <#updatelist>
        <#updatelist-abbr>
        <#updatelist-nil>
        <#updatelist-ambiguous>
        <#updatelist-not-a-list>
        <#updatelist-malformed-2first>
        <#updatelist-malformed-2rest>
        <#updatelist-exceed-size>
        <#updatelist-exceed-size-negative>
        <#prefix-simple>
        <#prefix-override>
        <#bnode-fresh>
        <#bnode-not-deleted>
        <#bnode-same-id>

        # evaluation tests for the examples in the specification
        <#spec_examples-1-2-3>
        <#spec_examples-4-5-6>
        <#spec_examples-4-7-8>
        <#spec_examples-4-9-10>
        <#spec_examples-4-11-12>
        <#spec_examples-4-13-14>
        <#spec_examples-4-15-16>
        <#spec_examples-4-17-18>
        # examples 20 to 23 are part of example 2,
        # and they are not self-sufficient, so we skip them
        <#spec_example24_positive>
        <#spec_example24_negative>
    ) ;
    .



<#empty> rdf:type :PositiveEvaluationTest ;
   mf:name      "empty" ;
   rdfs:comment "Empty patch" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <s_empty_patch.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#add-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "add-1triple" ;
   rdfs:comment "Add statement with a single triple" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <add-1triple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#add-abbr-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "add-abbr-1triple" ;
   rdfs:comment "Abbreviated Add statement with a single triple" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <add-abbr-1triple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#addnew-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "addnew-1triple" ;
   rdfs:comment "AddNew statement with a single triple" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <addnew-1triple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#addnew-abbr-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "addnew-abbr-1triple" ;
   rdfs:comment "Abbreviated AddNew statement with a single triple" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <addnew-abbr-1triple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#delete-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "delete-1triple" ;
   rdfs:comment "Delete statement with a single triple" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <delete-1triple.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#delete-abbr-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "delete-abbr-1triple" ;
   rdfs:comment "Abbreviated Delete statement with a single triple" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <delete-abbr-1triple.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#deleteexisting-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "deleteexisting-1triple" ;
   rdfs:comment "DeleteExisting statement with a single triple" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <deleteexisting-1triple.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#deleteexisting-abbr-1triple> rdf:type :PositiveEvaluationTest ;
   mf:name      "deleteexisting-abbr-1triple" ;
   rdfs:comment "Abbreviated DeleteExisting statement with a single triple" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <deleteexisting-abbr-1triple.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#bind> rdf:type :PositiveEvaluationTest ;
   mf:name      "bind" ;
   rdfs:comment "Binding statement" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <bind.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#bind-abbr> rdf:type :PositiveEvaluationTest ;
   mf:name      "bind-abbr" ;
   rdfs:comment "Abbreviated Bind statement" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <bind-abbr.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#bind-overriden> rdf:type :PositiveEvaluationTest ;
   mf:name      "bind-overriden" ;
   rdfs:comment "Overridden Bind statement" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <bind-overriden.ldpatch> 
   ];
   mf:result <2triples.nt>
   .


<#path-forward> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-forward" ;
   rdfs:comment "Path containing a StepForward" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-forward.ldpatch> 
   ];
   mf:result <path-forward.ttl>
   .

<#path-backward> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-backward" ;
   rdfs:comment "Path containing a StepBackward" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-backward.ldpatch> 
   ];
   mf:result <path-backward.ttl>
   .

<#path-at> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-at" ;
   rdfs:comment "Path containing a StepAt" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-at.ldpatch> 
   ];
   mf:result <path-at.ttl>
   .

<#path-unicity> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-unicity" ;
   rdfs:comment "Path containing a succesful unicity constraint" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-unicity.ldpatch> 
   ];
   mf:result <paths.ttl>
   .

<#path-unicity-fail> rdf:type :NegativeEvaluationTest ;
   mf:name      "path-unicity-fail" ;
   rdfs:comment "Path containing a failed unicity constraint" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-unicity-fail.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#path-filter> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-filter" ;
   rdfs:comment "Path containing a filter" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-filter.ldpatch> 
   ];
   mf:result <path-filter.ttl>
   .

<#path-filter-equal> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-filter-equal" ;
   rdfs:comment "Path containing a filter with an equal sign" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-filter-equal.ldpatch> 
   ];
   mf:result <path-filter-equal.ttl>
   .

<#path-starting-with-literal> rdf:type :PositiveEvaluationTest ;
   mf:name      "path-starting-with-literal" ;
   rdfs:comment "Path starting with a literal" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <path-starting-with-literal.ldpatch> 
   ];
   mf:result <path-starting-with-literal.ttl>
   .

<#add-noop> rdf:type :PositiveEvaluationTest ;
   mf:name      "add-noop" ;
   rdfs:comment "Add statement with an existing triple" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <add-1triple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#addnew-noop-fail> rdf:type :NegativeEvaluationTest ;
   mf:name      "addnew-noop-fail" ;
   rdfs:comment "AddNew statement with an existing triple, failing" ;
   mf:action [
     :data  <2triples.nt> ;
     :patch <addnew-1triple.ldpatch> 
   ];
   :statusCode 422
   .

<#delete-noop> rdf:type :PositiveEvaluationTest ;
   mf:name      "delete-noop" ;
   rdfs:comment "Delete statement with a non-existing triple" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <delete-1triple.ldpatch> 
   ];
   mf:result <1triple.nt>
   .

<#deleteexisting-noop-fail> rdf:type :NegativeEvaluationTest ;
   mf:name      "deleteexisting-noop-fail" ;
   rdfs:comment "DeleteExisting statement with a non-existing triple, failing" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <deleteexisting-1triple.ldpatch> 
   ];
   :statusCode 422
   .

<#cut> rdf:type :PositiveEvaluationTest ;
   mf:name      "cut" ;
   rdfs:comment "Cut" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <cut.ldpatch> 
   ];
   mf:result <cut.ttl>
   .

<#cut-abbr> rdf:type :PositiveEvaluationTest ;
   mf:name      "cut-abbr" ;
   rdfs:comment "Cut abbreviated" ;
   mf:action [
     :data  <paths.ttl> ;
     :patch <cut-abbr.ldpatch> 
   ];
   mf:result <cut.ttl>
   .

<#cut-fail> rdf:type :NegativeEvaluationTest ;
   mf:name      "cut-fail" ;
   rdfs:comment "Cut fails if no triple is deleted." ;
   mf:action [
     :data  <2triples_blank.nt> ;
     :patch <cut-fail.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist> rdf:type :PositiveEvaluationTest ;
   mf:name      "updatelist" ;
   rdfs:comment "UpdateList" ;
   mf:action [
     :data  <spec_example4.ttl> ;
     :patch <updatelist.ldpatch> 
   ];
   mf:result <updatelist.ttl>
   .

<#updatelist-abbr> rdf:type :PositiveEvaluationTest ;
   mf:name      "updatelist-abbr" ;
   rdfs:comment "UpdateList abbreviated" ;
   mf:action [
     :data  <spec_example4.ttl> ;
     :patch <updatelist-abbr.ldpatch> 
   ];
   mf:result <updatelist.ttl>
   .

<#updatelist-nil> rdf:type :PositiveEvaluationTest ;
   mf:name      "updatelist-nil" ;
   rdfs:comment "UpdateList used on an empty list (must not impact other empty lists)" ;
   mf:action [
     :data  <updatelist-nil.ttl> ;
     :patch <updatelist-nil.ldpatch> 
   ];
   mf:result <updatelist-nil-result.ttl>
   .

<#updatelist-ambiguous> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-ambiguous" ;
   rdfs:comment "UpdateList fails if its subject-predicate does not point to a single list." ;
   mf:action [
     :data  <updatelist-ambiguous.ttl> ;
     :patch <updatelist.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist-not-a-list> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-not-a-list" ;
   rdfs:comment "UpdateList fails if its subject-predicate points to a non-list." ;
   mf:action [
     :data  <updatelist-not-a-list.ttl> ;
     :patch <updatelist.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist-malformed-2first> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-malformed-2first" ;
   rdfs:comment "UpdateList fails if its subject-predicate points to malformed list (with two rdf:first)." ;
   mf:action [
     :data  <updatelist-malformed-2first.ttl> ;
     :patch <updatelist.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist-malformed-2rest> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-malformed-2rest" ;
   rdfs:comment "UpdateList fails if its subject-predicate points to malformed list (with two rdf:rest)." ;
   mf:action [
     :data  <updatelist-malformed-2rest.ttl> ;
     :patch <updatelist.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist-exceed-size> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-exceed-size" ;
   rdfs:comment "UpdateList with a slice exceeding the size of the list." ;
   mf:action [
     :data  <spec_example4.ttl> ;
     :patch <updatelist-exceed-size.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#updatelist-exceed-size-negative> rdf:type :NegativeEvaluationTest ;
   mf:name      "updatelist-exceed-size-negative" ;
   rdfs:comment "UpdateList with a slice (using a negative index) exceeding the size of the list." ;
   mf:action [
     :data  <spec_example4.ttl> ;
     :patch <updatelist-exceed-size-negative.ldpatch> 
   ];
   :statusCode 422 ;
   .

<#prefix-simple> rdf:type :PositiveEvaluationTest ;
   mf:name      "prefix-simple" ;
   rdfs:comment "Simple prefix" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <prefix-simple.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#prefix-override> rdf:type :PositiveEvaluationTest ;
   mf:name      "prefix-override" ;
   rdfs:comment "Overridden prefix" ;
   mf:action [
     :data  <1triple.nt> ;
     :patch <prefix-override.ldpatch> 
   ];
   mf:result <2triples.nt>
   .

<#bnode-fresh> rdf:type :PositiveEvaluationTest ;
   mf:name      "bnode-fresh" ;
   rdfs:comment "A bnode in the patch generates a fresh bnode in the graph, even if the bnode-id in the patch already exisists in the graph source." ;
   mf:action [
     :data  <1triple_blank.nt> ;
     :patch <bnode-fresh.ldpatch> 
   ];
   mf:result <2triples_blank.nt>
   .

<#bnode-not-deleted> rdf:type :PositiveEvaluationTest ;
   mf:name      "bnode-not-deleted" ;
   rdfs:comment "A bnode in a Delete statement does not match anything." ;
   mf:action [
     :data  <1triple_blank.nt> ;
     :patch <bnode-no-delete.ldpatch> 
   ];
   mf:result <1triple_blank.nt>
   .

<#bnode-same-id> rdf:type :PositiveEvaluationTest ;
   mf:name      "bnode-same-id" ;
   rdfs:comment "A bnode id in the patch always denotes the same bnode." ;
   mf:action [
     :data  <1triple_blank.nt> ;
     :patch <bnode-same-id.ldpatch> 
   ];
   mf:result <3triples_blank.nt>
   .

<#spec_examples-1-2-3> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-1-2-3" ;
   rdfs:comment "Examples #1 to #3 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example1.ttl> ;
        :patch <spec_example2.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example3.ttl> ;
   .

<#spec_examples-4-5-6> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-5-6" ;
   rdfs:comment "Examples #4 to #6 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example5.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example6.ttl> ;
   .

<#spec_examples-4-7-8> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-7-8" ;
   rdfs:comment "Examples #4, #7 and #8 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example7.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example8.ttl> ;
   .

<#spec_examples-4-9-10> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-9-10" ;
   rdfs:comment "Examples #4, #9 and #10 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example9.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example10.ttl> ;
   .

<#spec_examples-4-11-12> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-11-12" ;
   rdfs:comment "Examples #4, #11 and #12 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example11.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example12.ttl> ;
   .

<#spec_examples-4-13-14> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-13-14" ;
   rdfs:comment "Examples #4, #13 and #14 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example13.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example14.ttl> ;
   .

<#spec_examples-4-15-16> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-15-16" ;
   rdfs:comment "Examples #4, #15 and #16 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example15.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example16.ttl> ;
   .

<#spec_examples-4-17-18> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_examples-4-17-18" ;
   rdfs:comment "Examples #4, #17 and #18 from the LD-Patch specification" ;
   mf:action    [
        :data  <spec_example4.ttl> ;
        :patch <spec_example17.ldpatch> ;
        :base  "http://example.com/timbl"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example18.ttl> ;
   .

<#spec_example24_positive> rdf:type :PositiveEvaluationTest ;
   mf:name      "spec_example24_positive" ;
   rdfs:comment "Successful binding of unambiguous bnodes in a pathological graph." ;
   mf:action    [
        :data  <spec_example24.ttl> ;
        :patch <spec_example24_positive.ldpatch> ;
        :base  "http://example.com/pathological"^^xsd:anyURI ;
        ] ;
   mf:result    <spec_example24_patched.ttl> ;
   .

<#spec_example24_negative> rdf:type :NegativeEvaluationTest ;
   mf:name      "spec_example24_negative" ;
   rdfs:comment "Unsuccessful binding in a pathological graph." ;
   mf:action    [
        :data  <spec_example24.ttl> ;
        :patch <spec_example24_negative.ldpatch> ;
        ] ;
   :statusCode 422 ;
   .



#### Specific test vocabulary ####

:PositiveSyntaxTest rdf:type rdfs:Class ;
      rdfs:label "Positive Syntax Test" ;
      rdfs:comment "A type of test specifically for syntax testing. Syntax tests are not required to have an associated result, only an action (an LD-Patch file)." .

:NegativeSyntaxTest rdf:type rdfs:Class ;
      rdfs:label "Negative Syntax Test" ;
      rdfs:comment "A type of test specifically for syntax testing. Syntax tests are not required to have an associated result, only an action (an LD-Patch file). Negative syntax tests are tests of which the result should be a parser error." .

:PositiveEvaluationTest rdf:type rdfs:Class ;
      rdfs:label "Positive Evaluation Test" ;
      rdfs:comment "A type of test specifically for patch evaluation testing. Positive evaluation tests are required to have an action with :data and :patch properties, and an expected output (a Turtle file)." .

:NegativeEvaluationTest rdf:type rdfs:Class ;
      rdfs:label "Negative Evaluation Test" ;
      rdfs:comment "A type of test specifically for patch evaluation testing. Negative evaluation tests are not required to have any associated result, only an action with :data and :patch properties. Negative evaluation tests are tests of which the result should be an execution error" .


:data rdf:type rdf:Property ;
    rdfs:comment "Data file on which to perform action" ;
    # rdfs:domain  ?? ; ## object of the mf:action property
    # rdfs:range   ?? ; ## TTL file
    .	

:patch rdf:type rdf:Property ;
    rdfs:comment "LD-Patch file with which to perform action" ;
    # rdfs:domain  ?? ; ## object of the mf:action property
    # rdfs:range   ?? ; ## LD-Patch file
    .	

:base rdf:type rdf:Property ;
    rdfs:comment "Base IRI for data and patch, if different from actual location" ;
    # rdfs:domain  ?? ; ## object of the mf:action property
    rdfs:range xsd:anyURI ;
    .	

:statusCode rdf:type rdf:Property ;
    rdfs:comment "HTTP status code expected for a negative evaluation test" ;
    rdfs:domain :NegativeEvaluationTest ;
    rdfs:range xsd:integer ;
    .