SPARQL 1.1 Query and Update Implementation Report

Ruby SPARQL gem test results

This document reports conformance for for SPARQL 1.1 Query and SPARQL 1.1 Update

This report is also available in Turtle

Ruby SPARQL
Description
SPARQL Implements SPARQL 1.1 Query, Update, Protocol and result formats for the Ruby RDF.rb library suite.
Programming Language
Ruby
Home Page
https://github.com/ruby-rdf/sparql
Developer
Test Suite Compliance
10/10 (100.0%)
Add 8/8 (100.0%)
Aggregates 31/31 (100.0%)
Algebra 14/14 (100.0%)
ASK 4/4 (100.0%)
Basic 25/27 (92.6%)
Basic Update 13/13 (100.0%)
BIND 10/10 (100.0%)
bnode co-reference 1/1 (100.0%)
Boolean Effective Value 7/7 (100.0%)
bound 1/1 (100.0%)
Built-in Functions 68/68 (100.0%)
Built-ins 23/24 (95.8%)
Casting 6/6 (100.0%)
Casting 7/7 (100.0%)
CLEAR 4/4 (100.0%)
CONSTRUCT 6/6 (100.0%)
CONSTRUCT 5/5 (100.0%)
Copy 6/6 (100.0%)
CSV/TSV Result Format 5/6 (83.3%)
dataset 12/12 (100.0%)
DELETE 19/19 (100.0%)
DELETE DATA 6/6 (100.0%)
DELETE INSERT 16/16 (100.0%)
DELETE WHERE 6/6 (100.0%)
DISTINCT 9/11 (81.8%)
DROP 4/4 (100.0%)
entailment regime test cases 25/70 (35.7%)
equality of values 12/12 (100.0%)
GRAPH 11/11 (100.0%)
Grouping 6/6 (100.0%)
I18N 5/5 (100.0%)
JSON Result Format 4/4 (100.0%)
Move 6/6 (100.0%)
Negation 11/11 (100.0%)
open world value testing tests 17/18 (94.4%)
OPTIONAL 7/7 (100.0%)
OPTIONAL FILTER 5/6 (83.3%)
Positive Exists 5/5 (100.0%)
Project Expression 7/7 (100.0%)
Property Path 22/24 (91.7%)
Property Path min/max 6/6 (100.0%)
REDUCED Untested
REGEX 4/4 (100.0%)
Solution Sequence 13/13 (100.0%)
SORT 13/13 (100.0%)
SPARQL 1.1 Update test cases for SILENT 13/13 (100.0%)
SPARQL Graph Store Protocol Untested
SPARQL Protocol 35/35 (100.0%)
SPARQL Service Untested
Sub query 13/14 (92.9%)
Syntax 1 80/81 (98.8%)
Syntax 2 51/53 (96.2%)
Syntax 3 51/51 (100.0%)
Syntax 4 12/12 (100.0%)
Syntax 5 2/2 (100.0%)
Syntax Federation 3/3 (100.0%)
Syntax Query 91/92 (98.9%)
Syntax Update 1 50/54 (92.6%)
Syntax Update 2 1/1 (100.0%)
Triple Match 4/4 (100.0%)
Type Promotion 30/30 (100.0%)
XPath operators 7/7 (100.0%)
XSD Functions and Operators 20/20 (100.0%)
SPARQL-star Evaluation Tests 34/34 (100.0%)
SPARQL-star Syntax Tests 63/63 (100.0%)

Individual Test Results

Test Ruby SPARQL
Test values1: Post-query VALUES with subj-var, 1 row PASS
Test values2: Post-query VALUES with obj-var, 1 row PASS
Test values3: Post-query VALUES with 2 obj-vars, 1 row PASS
Test values4: Post-query VALUES with 2 obj-vars, 1 row with UNDEF PASS
Test values5: Post-query VALUES with 2 obj-vars, 2 rows with UNDEF PASS
Test values6: Post-query VALUES with pred-var, 1 row PASS
Test values7: Post-query VALUES with (OPTIONAL) obj-var, 1 row PASS
Test values8: Post-query VALUES with subj/obj-vars, 2 rows with UNDEF PASS
Test inline1: Inline VALUES graph pattern PASS
Test inline2: Post-subquery VALUES PASS
Percentage passed out of 10 Tests 100.0%

Add

Test Ruby SPARQL
Test add01: ADD 1 PASS
Test add02: ADD 2 PASS
Test add03: ADD 3 PASS
Test add04: ADD 4 PASS
Test add05: ADD 5 PASS
Test add06: ADD 6 PASS
Test add07: ADD 7 PASS
Test add08: ADD 8 PASS
Percentage passed out of 8 Tests 100.0%

Aggregates

Test Ruby SPARQL
Test agg01: COUNT 1 PASS
Test agg02: COUNT 2 PASS
Test agg03: COUNT 3 PASS
Test agg04: COUNT 4 PASS
Test agg05: COUNT 5 PASS
Test agg06: COUNT 6 PASS
Test agg07: COUNT 7 PASS
Test agg08: COUNT 8 PASS
Test agg08b: COUNT 8b PASS
Test agg09: COUNT 9 PASS
Test agg10: COUNT 10 PASS
Test agg11: COUNT 11 PASS
Test agg12: COUNT 12 PASS
Test agg-groupconcat-01: GROUP_CONCAT 1 PASS
Test agg-groupconcat-02: GROUP_CONCAT 2 PASS
Test agg-groupconcat-03: GROUP_CONCAT with SEPARATOR PASS
Test agg-sum-01: SUM PASS
Test agg-sum-02: SUM with GROUP BY PASS
Test agg-avg-01: AVG PASS
Test agg-avg-02: AVG with GROUP BY PASS
Test agg-min-01: MIN PASS
Test agg-min-02: MIN with GROUP BY PASS
Test agg-max-01: MAX PASS
Test agg-max-02: MAX with GROUP BY PASS
Test agg-sample-01: SAMPLE PASS
Test agg-err-01: Error in AVG PASS
Test agg-err-02: Protect from error in AVG PASS
Test agg-empty-group-max-1: agg on empty set, explicit grouping PASS
Test agg-empty-group-max-2: agg on empty set, no grouping PASS
Test agg-empty-group-count-1: COUNT: no match, with group PASS
Test agg-empty-group-count-2: COUNT: no match, no group PASS
Percentage passed out of 31 Tests 100.0%

Algebra

Test Ruby SPARQL
Test nested-opt-1: Nested Optionals - 1 PASS
Test nested-opt-2: Nested Optionals - 2 PASS
Test opt-filter-1: Optional-filter - 1 PASS
Test opt-filter-2: Optional-filter - 2 filters PASS
Test opt-filter-3: Optional-filter - scope of variable PASS
Test filter-place-1: Filter-placement - 1 PASS
Test filter-place-2: Filter-placement - 2 PASS
Test filter-place-3: Filter-placement - 3 PASS
Test filter-nested-1: Filter-nested - 1 PASS
Test filter-nested-2: Filter-nested - 2 PASS
Test filter-scope-1: Filter-scope - 1 PASS
Test join-scope-1: Join scope - 1 PASS
Test join-combo-1: Join operator with OPTs, BGPs, and UNIONs PASS
Test join-combo-2: Join operator with Graph and Union PASS
Percentage passed out of 14 Tests 100.0%

ASK

Test Ruby SPARQL
Test ask-1: ASK-1 (SPARQL XML results) PASS
Test ask-4: ASK-4 (SPARQL XML results) PASS
Test ask-7: ASK-7 (SPARQL XML results) PASS
Test ask-8: ASK-8 (SPARQL XML results) PASS
Percentage passed out of 4 Tests 100.0%

Basic

Test Ruby SPARQL
Test base-prefix-1: Basic - Prefix/Base 1 PASS
Test base-prefix-2: Basic - Prefix/Base 2 PASS
Test base-prefix-3: Basic - Prefix/Base 3 PASS
Test base-prefix-4: Basic - Prefix/Base 4 PASS
Test base-prefix-5: Basic - Prefix/Base 5 PASS
Test list-1: Basic - List 1 PASS
Test list-2: Basic - List 2 PASS
Test list-3: Basic - List 3 PASS
Test list-4: Basic - List 4 PASS
Test quotes-1: Basic - Quotes 1 PASS
Test quotes-2: Basic - Quotes 2 PASS
Test quotes-3: Basic - Quotes 3 PASS
Test quotes-4: Basic - Quotes 4 PASS
Test term-1: Basic - Term 1 PASS
Test term-2: Basic - Term 2 PASS
Test term-3: Basic - Term 3 PASS
Test term-4: Basic - Term 4 PASS
Test term-5: Basic - Term 5 PASS
Test term-6: Basic - Term 6 (Decimal format changed in SPARQL 1.1) UNTESTED
Test term-7: Basic - Term 7 (Decimal format changed in SPARQL 1.1) UNTESTED
Test term-8: Basic - Term 8 PASS
Test term-9: Basic - Term 9 PASS
Test var-1: Basic - Var 1 PASS
Test var-2: Basic - Var 2 PASS
Test bgp-no-match: Non-matching triple pattern PASS
Test spoo-1: Basic graph pattern - spoo PASS
Test prefix-name-1: Prefix name 1 PASS
Percentage passed out of 27 Tests 92.6%

Basic Update

Test Ruby SPARQL
Test insert-data-spo1: Simple insert data 1 PASS
Test insert-data-spo-named1: Simple insert data named 1 PASS
Test insert-data-spo-named2: Simple insert data named 2 PASS
Test insert-data-spo-named3: Simple insert data named 3 PASS
Test insert-where-01: INSERT 01 PASS
Test insert-where-02: INSERT 02 PASS
Test insert-where-03: INSERT 03 PASS
Test insert-where-04: INSERT 04 PASS
Test insert-using-01: INSERT USING 01 PASS
Test insert-05a: INSERT same bnode twice PASS
Test insert-data-same-bnode: INSERTing the same bnode with INSERT DATA into two different Graphs is the same bnode PASS
Test insert-where-same-bnode: INSERTing the same bnode with two INSERT WHERE statement within one request is NOT the same bnode PASS
Test insert-where-same-bnode2: INSERTing the same bnode with two INSERT WHERE statement within one request is NOT the same bnode even if both WHERE clauses have the empty solution mapping as the only solution. PASS
Percentage passed out of 13 Tests 100.0%

BIND

Test Ruby SPARQL
Test bind01: bind01 - BIND PASS
Test bind02: bind02 - BIND PASS
Test bind03: bind03 - BIND PASS
Test bind04: bind04 - BIND PASS
Test bind05: bind05 - BIND PASS
Test bind06: bind06 - BIND PASS
Test bind07: bind07 - BIND PASS
Test bind08: bind08 - BIND PASS
Test bind10: bind10 - BIND scoping - Variable in filter not in scope PASS
Test bind11: bind11 - BIND scoping - Variable in filter in scope PASS
Percentage passed out of 10 Tests 100.0%

bnode co-reference

Test Ruby SPARQL
Test dawg-bnode-coref-001: dawg-bnode-coreference PASS
Percentage passed out of 1 Tests 100.0%

Boolean Effective Value

Test Ruby SPARQL
Test dawg-boolean-literal: Test literal 'true' PASS
Test dawg-bev-1: Test 'boolean effective value' - true PASS
Test dawg-bev-2: Test 'boolean effective value' - false PASS
Test dawg-bev-3: Test 'boolean effective value' - && PASS
Test dawg-bev-4: Test 'boolean effective value' - || PASS
Test dawg-bev-5: Test 'boolean effective value' - optional PASS
Test dawg-bev-6: Test 'boolean effective value' - unknown types PASS
Percentage passed out of 7 Tests 100.0%

bound

Test Ruby SPARQL
Test dawg-bound-query-001: dawg-bound-query-001 PASS
Percentage passed out of 1 Tests 100.0%

Built-in Functions

Test Ruby SPARQL
Test strdt01: STRDT() PASS
Test strdt02: STRDT(STR()) PASS
Test strdt03-rdf11: STRDT() TypeErrors (updated for RDF 1.1) PASS
Test strlang01: STRLANG() PASS
Test strlang02: STRLANG(STR()) PASS
Test strlang03-rdf11: STRLANG() TypeErrors (updated for RDF 1.1) PASS
Test isnumeric01: isNumeric() PASS
Test abs01: ABS() PASS
Test ceil01: CEIL() PASS
Test floor01: FLOOR() PASS
Test round01: ROUND() PASS
Test concat01: CONCAT() PASS
Test concat02: CONCAT() 2 PASS
Test substring01: SUBSTR() (3-argument) PASS
Test substring01-non-bmp: SUBSTR() (3-argument) on non-BMP unicode strings PASS
Test substring02: SUBSTR() (2-argument) PASS
Test substring02-non-bmp: SUBSTR() (2-argument) on non-BMP unicode strings PASS
Test length01: STRLEN() PASS
Test length01-non-bmp: STRLEN() on non-BMP unicode strings PASS
Test ucase01: UCASE() PASS
Test ucase01-non-bmp: UCASE() on non-BMP unicode strings PASS
Test lcase01: LCASE() PASS
Test lcase01-non-bmp: LCASE() on non-BMP unicode strings PASS
Test encode01: ENCODE_FOR_URI() PASS
Test encode01-non-bmp: ENCODE_FOR_URI() on non-BMP unicode strings PASS
Test contains01: CONTAINS() PASS
Test starts01: STRSTARTS() PASS
Test ends01: STRENDS() PASS
Test plus-1-corrected: plus-1-corrected PASS
Test plus-2-corrected: plus-2-corrected PASS
Test md5-01: MD5() PASS
Test md5-02: MD5() over Unicode data PASS
Test sha1-01: SHA1() PASS
Test sha1-02: SHA1() on Unicode data PASS
Test sha256-01: SHA256() PASS
Test sha256-02: SHA256() on Unicode data PASS
Test sha512-01: SHA512() PASS
Test sha512-02: SHA512() on Unicode data PASS
Test minutes: MINUTES() PASS
Test seconds: SECONDS() PASS
Test hours: HOURS() PASS
Test month: MONTH() PASS
Test year: YEAR() PASS
Test day: DAY() PASS
Test timezone: TIMEZONE() PASS
Test tz: TZ() PASS
Test bnode01: BNODE(str) PASS
Test bnode02: BNODE() PASS
Test in01: IN 1 PASS
Test in02: IN 2 PASS
Test notin01: NOT IN 1 PASS
Test notin02: NOT IN 2 PASS
Test now01: NOW() PASS
Test rand01: RAND() PASS
Test iri01: IRI()/URI() PASS
Test if01: IF() PASS
Test if02: IF() error propogation PASS
Test coalesce01: COALESCE() PASS
Test strbefore01a: STRBEFORE() PASS
Test strbefore02: STRBEFORE() datatyping PASS
Test strafter01a: STRAFTER() PASS
Test strafter02: STRAFTER() datatyping PASS
Test replace01: REPLACE() PASS
Test replace02: REPLACE() with overlapping pattern PASS
Test replace03: REPLACE() with captured substring PASS
Test uuid01: UUID() pattern match PASS
Test uuid02: UUID() per binding PASS
Test struuid01: STRUUID() pattern match PASS
Percentage passed out of 68 Tests 100.0%

Built-ins

Test Ruby SPARQL
Test dawg-str-1: str-1 PASS
Test dawg-str-2: str-2 PASS
Test dawg-str-3: str-3 PASS
Test dawg-str-4: str-4 PASS
Test dawg-isBlank-1: isBlank-1 PASS
Test dawg-isLiteral-1: isLiteral PASS
Test dawg-datatype-1: datatype-1 PASS
Test dawg-datatype-2: datatype-2 : Literals with a datatype (datatype now returns rdf:langString for language-tagged literals) UNTESTED
Test dawg-datatype-3: datatype-3 : Literals with a datatype of xsd:string PASS
Test dawg-lang-1: lang-1 : Literals with a lang tag of some kind PASS
Test dawg-lang-2: lang-2 : Literals with a lang tag of '' PASS
Test dawg-lang-3: lang-3 : Graph matching with lang tag being a different case PASS
Test dawg-isURI-1: isURI-1 PASS
Test dawg-isIRI-1: isIRI-1 PASS
Test dawg-langMatches-1: LangMatches-1 PASS
Test dawg-langMatches-2: LangMatches-2 PASS
Test dawg-langMatches-3: LangMatches-3 PASS
Test dawg-langMatches-4: LangMatches-4 PASS
Test dawg-langMatches-basic: LangMatches-basic PASS
Test lang-case-insensitive-eq: lang-case-insensitive-eq PASS
Test lang-case-insensitive-ne: lang-case-insensitive-ne PASS
Test sameTerm-simple: sameTerm-simple PASS
Test sameTerm-eq: sameTerm-eq PASS
Test sameTerm-not-eq: sameTerm-not-eq PASS
Percentage passed out of 24 Tests 95.8%

Casting

Test Ruby SPARQL
Test cast-bool: xsd:boolean cast PASS
Test cast-int: xsd:integer cast PASS
Test cast-float: xsd:float cast PASS
Test cast-double: xsd:double cast PASS
Test cast-decimal: xsd:decimal cast PASS
Test cast-string: xsd:string cast PASS
Percentage passed out of 6 Tests 100.0%

Casting

Test Ruby SPARQL
Test cast-str: Cast to xsd:string PASS
Test cast-flt: Cast to xsd:float PASS
Test cast-dbl: Cast to xsd:double PASS
Test cast-dec: Cast to xsd:decimal PASS
Test cast-int: Cast to xsd:integer PASS
Test cast-dT: Cast to xsd:dateTime PASS
Test cast-bool: Cast to xsd:boolean PASS
Percentage passed out of 7 Tests 100.0%

CLEAR

Test Ruby SPARQL
Test dawg-clear-default-01: CLEAR DEFAULT PASS
Test dawg-clear-graph-01: CLEAR GRAPH PASS
Test dawg-clear-named-01: CLEAR NAMED PASS
Test dawg-clear-all-01: CLEAR ALL PASS
Percentage passed out of 4 Tests 100.0%

CONSTRUCT

Test Ruby SPARQL
Test constructwhere01: constructwhere01 - CONSTRUCT WHERE PASS
Test constructwhere02: constructwhere02 - CONSTRUCT WHERE PASS
Test constructwhere03: constructwhere03 - CONSTRUCT WHERE PASS
Test constructwhere04: constructwhere04 - CONSTRUCT WHERE PASS
Test constructwhere05: constructwhere05 - CONSTRUCT WHERE PASS
Test constructwhere06: constructwhere06 - CONSTRUCT WHERE PASS
Percentage passed out of 6 Tests 100.0%

CONSTRUCT

Test Ruby SPARQL
Test construct-1: dawg-construct-identity PASS
Test construct-2: dawg-construct-subgraph PASS
Test construct-3: dawg-construct-reification-1 PASS
Test construct-4: dawg-construct-reification-2 PASS
Test construct-5: dawg-construct-optional PASS
Percentage passed out of 5 Tests 100.0%

Copy

Test Ruby SPARQL
Test copy01: COPY 1 PASS
Test copy02: COPY 2 PASS
Test copy03: COPY 3 PASS
Test copy04: COPY 4 PASS
Test copy06: COPY 6 PASS
Test copy07: COPY 7 PASS
Percentage passed out of 6 Tests 100.0%

CSV/TSV Result Format

Test Ruby SPARQL
Test csv01: csv01 - CSV Result Format PASS
Test tsv01: tsv01 - TSV Result Format PASS
Test csv02: cvs02 - CSV Result Format PASS
Test tsv02: tvs02 - TSV Result Format (Empty vs. Unbound) FAIL
Test csv03: csv03 - CSV Result Format PASS
Test tsv03: tsv03 - TSV Result Format PASS
Percentage passed out of 6 Tests 83.3%

dataset

Test Ruby SPARQL
Test dawg-dataset-01: dataset-01 PASS
Test dawg-dataset-02: dataset-02 PASS
Test dawg-dataset-03: dataset-03 PASS
Test dawg-dataset-04: dataset-04 PASS
Test dawg-dataset-05: dataset-05 PASS
Test dawg-dataset-06: dataset-06 PASS
Test dawg-dataset-07: dataset-07 PASS
Test dawg-dataset-08: dataset-08 PASS
Test dawg-dataset-11: dataset-11 PASS
Test dawg-dataset-09b: dataset-09b PASS
Test dawg-dataset-10b: dataset-10b PASS
Test dawg-dataset-12b: dataset-12b PASS
Percentage passed out of 12 Tests 100.0%

DELETE

Test Ruby SPARQL
Test dawg-delete-01: Simple DELETE 1 PASS
Test dawg-delete-02: Simple DELETE 2 PASS
Test dawg-delete-03: Simple DELETE 3 PASS
Test dawg-delete-04: Simple DELETE 4 PASS
Test dawg-delete-05: Graph-specific DELETE 1 PASS
Test dawg-delete-06: Graph-specific DELETE 2 PASS
Test dawg-delete-07: Simple DELETE 7 PASS
Test dawg-delete-with-01: Simple DELETE 1 (WITH) PASS
Test dawg-delete-with-02: Simple DELETE 2 (WITH) PASS
Test dawg-delete-with-03: Simple DELETE 3 (WITH) PASS
Test dawg-delete-with-04: Simple DELETE 4 (WITH) PASS
Test dawg-delete-with-05: Graph-specific DELETE 1 (WITH) PASS
Test dawg-delete-with-06: Graph-specific DELETE 2 (WITH) PASS
Test dawg-delete-using-01: Simple DELETE 1 (USING) PASS
Test dawg-delete-using-02a: Simple DELETE 2 (USING) PASS
Test dawg-delete-using-03: Simple DELETE 3 (USING) PASS
Test dawg-delete-using-04: Simple DELETE 4 (USING) PASS
Test dawg-delete-using-05: Graph-specific DELETE 1 (USING) PASS
Test dawg-delete-using-06a: Graph-specific DELETE 2 (USING) PASS
Percentage passed out of 19 Tests 100.0%

DELETE DATA

Test Ruby SPARQL
Test dawg-delete-data-01: Simple DELETE DATA 1 PASS
Test dawg-delete-data-02: Simple DELETE DATA 2 PASS
Test dawg-delete-data-03: Simple DELETE DATA 3 PASS
Test dawg-delete-data-04: Simple DELETE DATA 4 PASS
Test dawg-delete-data-05: Graph-specific DELETE DATA 1 PASS
Test dawg-delete-data-06: Graph-specific DELETE DATA 2 PASS
Percentage passed out of 6 Tests 100.0%

DELETE INSERT

Test Ruby SPARQL
Test dawg-delete-insert-01: DELETE INSERT 1 PASS
Test dawg-delete-insert-01b: DELETE INSERT 1b PASS
Test dawg-delete-insert-01c: DELETE INSERT 1c PASS
Test dawg-delete-insert-02: DELETE INSERT 2 PASS
Test dawg-delete-insert-03: DELETE INSERT 3 PASS
Test dawg-delete-insert-03b: DELETE INSERT 3b PASS
Test dawg-delete-insert-04: DELETE INSERT 4 PASS
Test dawg-delete-insert-04b: DELETE INSERT 4b PASS
Test dawg-delete-insert-05: DELETE INSERT 5 PASS
Test dawg-delete-insert-05b: DELETE INSERT 5b PASS
Test dawg-delete-insert-06: DELETE INSERT 6 PASS
Test dawg-delete-insert-06b: DELETE INSERT 6b PASS
Test dawg-delete-insert-07: DELETE INSERT 7 PASS
Test dawg-delete-insert-07b: DELETE INSERT 7b PASS
Test dawg-delete-insert-08: DELETE INSERT 8 PASS
Test dawg-delete-insert-09: DELETE INSERT 9 PASS
Percentage passed out of 16 Tests 100.0%

DELETE WHERE

Test Ruby SPARQL
Test dawg-delete-where-01: Simple DELETE WHERE 1 PASS
Test dawg-delete-where-02: Simple DELETE WHERE 2 PASS
Test dawg-delete-where-03: Simple DELETE WHERE 3 PASS
Test dawg-delete-where-04: Simple DELETE WHERE 4 PASS
Test dawg-delete-where-05: Graph-specific DELETE WHERE 1 PASS
Test dawg-delete-where-06: Graph-specific DELETE WHERE 2 PASS
Percentage passed out of 6 Tests 100.0%

DISTINCT

Test Ruby SPARQL
Test no-distinct-1: Numbers: No distinct PASS
Test distinct-1: Numbers: Distinct PASS
Test no-distinct-2: Strings: No distinct PASS
Test distinct-2: Strings: Distinct (More compact representation) UNTESTED
Test no-distinct-3: Nodes: No distinct PASS
Test distinct-3: Nodes: Distinct PASS
Test no-distinct-4: Opt: No distinct PASS
Test distinct-4: Opt: Distinct PASS
Test no-distinct-9: All: No distinct PASS
Test distinct-9: All: Distinct (More compact representation) UNTESTED
Test distinct-star-1: SELECT DISTINCT * PASS
Percentage passed out of 11 Tests 81.8%

DROP

Test Ruby SPARQL
Test dawg-drop-default-01: DROP DEFAULT PASS
Test dawg-drop-graph-01: DROP GRAPH PASS
Test dawg-drop-named-01: DROP NAMED PASS
Test dawg-drop-all-01: DROP ALL PASS
Percentage passed out of 4 Tests 100.0%

entailment regime test cases

Test Ruby SPARQL
Test bind01: bind01 - BIND fixed data for OWL DL (Entailment) PASS
Test bind02: bind02 - BIND fixed data for OWL DL (Entailment) PASS
Test bind03: bind03 - BIND fixed data for OWL DL (Entailment) PASS
Test bind04: bind04 - BIND fixed data for OWL DL (Entailment) PASS
Test bind05: bind05 - BIND fixed data for OWL DL (Entailment) PASS
Test bind06: bind06 - BIND fixed data for OWL DL (Entailment) PASS
Test bind07: bind07 - BIND fixed data for OWL DL (Entailment) PASS
Test bind08: bind08 - BIND fixed data for OWL DL (Entailment) PASS
Test d-ent-01: D-Entailment test to show that neither literals in subject position nor newly introduced surrogate blank nodes are to be returned in query answers (Entailment) PASS
Test lang: Literal with language tag test (Entailment) PASS
Test owlds01: bnodes are not existentials (Entailment) PASS
Test owlds02: bnodes are not existentials with answer (Entailment) PASS
Test paper-sparqldl-Q1: paper-sparqldl-Q1 (Entailment) FAIL
Test paper-sparqldl-Q1-rdfs: paper-sparqldl-Q1-rdfs (Entailment) FAIL
Test paper-sparqldl-Q2: paper-sparqldl-Q2 (Entailment) FAIL
Test paper-sparqldl-Q3: paper-sparqldl-Q3 (Entailment) FAIL
Test paper-sparqldl-Q4: paper-sparqldl-Q4 (Entailment) FAIL
Test paper-sparqldl-Q5: paper-sparqldl-Q5 (Entailment) PASS
Test parent10: filtered subclass query with (hasChild some Thing) restriction (Entailment) FAIL
Test parent2: parent query with distinguished variable (Entailment) PASS
Test parent3: parent query with (hasChild some Thing) restriction (Entailment) FAIL
Test parent4: parent query with (hasChild min 1) restriction (Entailment) FAIL
Test parent5: parent query with (hasChild some Female) restriction (Entailment) FAIL
Test parent6: parent query with (hasChild min 1 Female) restriction (Entailment) FAIL
Test parent7: parent query with (hasChild max 1 Female) restriction (Entailment) FAIL
Test parent8: parent query with (hasChild exactly 1 Female) restriction (Entailment) FAIL
Test parent9: subclass query with (hasChild some Thing) restriction (Entailment) FAIL
Test plainLit: Plain literals with language tag are not the same as the same literal without (Entailment) PASS
Test rdf01: RDF inference test (Entailment) FAIL
Test rdf02: RDF inference test (Entailment) PASS
Test rdf03: RDF test for blank node cardinalities (Entailment) PASS
Test rdf04: simple triple pattern match (Entailment) PASS
Test rdfs01: RDFS inference test rdfs:subPropertyOf (Entailment) FAIL
Test rdfs02: RDFS inference test rdfs:subPropertyOf (Entailment) FAIL
Test rdfs03: RDFS inference test combining subPropertyOf and domain (Entailment) FAIL
Test rdfs04: RDFS inference test subClassOf (Entailment) FAIL
Test rdfs05: RDFS inference test subClassOf (Entailment) FAIL
Test rdfs06: RDFS inference test domain (Entailment) FAIL
Test rdfs07: RDFS inference test range (Entailment) FAIL
Test rdfs08: RDFS inference test rdf:XMLLiteral subclass of rdfs:Literal (Entailment) PASS
Test rdfs09: RDFS inference test transitivity of subClassOf (Entailment) FAIL
Test rdfs10: RDFS inference test transitivity of subPropertyOf (Entailment) FAIL
Test rdfs11: RDFS inference test subProperty and instances (Entailment) FAIL
Test rdfs12: RDFS inference test containers (Entailment) PASS
Test rdfs13: RDFS inference test to show that neither literals in subject position nor newly introduced surrogate blank nodes are to be returned in query answers (Entailment) PASS
Test rif01: RIF Logical Entailment (referencing RIF XML) (Entailment) FAIL
Test rif03: RIF Core WG tests: Frames (Entailment) FAIL
Test rif04: RIF Core WG tests: Modeling Brain Anatomy (Entailment) FAIL
Test rif06: RIF Core WG tests: RDF Combination Blank Node (Entailment) FAIL
Test simple1: simple 1 (Entailment) FAIL
Test simple2: simple 2 (Entailment) FAIL
Test simple3: simple 3 (Entailment) FAIL
Test simple4: simple 4 (Entailment) FAIL
Test simple5: simple 5 (Entailment) FAIL
Test simple6: simple 6 (Entailment) FAIL
Test simple7: simple 7 (Entailment) FAIL
Test simple8: simple 8 (Entailment) FAIL
Test sparqldl-01: sparqldl-01.rq: triple pattern (Entailment) PASS
Test sparqldl-02: sparqldl-02.rq: simple combined query (Entailment) FAIL
Test sparqldl-03: sparqldl-03.rq: combined query with complex class description (Entailment) FAIL
Test sparqldl-04: sparqldl-04.rq: bug fixing test (Entailment) PASS
Test sparqldl-05: sparqldl-05.rq: simple undistinguished variable test. (Entailment) PASS
Test sparqldl-06: sparqldl-06.rq: cycle of undistinguished variables (Entailment) PASS
Test sparqldl-07: sparqldl-07.rq: two distinguished variables + undist. (Entailment) FAIL
Test sparqldl-08: sparqldl-08.rq: two distinguished variables + undist. (Entailment) FAIL
Test sparqldl-09: sparqldl-09.rq: undist vars test (Entailment) FAIL
Test sparqldl-10: sparqldl-10.rq: undist vars test (Entailment) FAIL
Test sparqldl-11: sparqldl-11.rq: domain test (Entailment) FAIL
Test sparqldl-12: sparqldl-12.rq: range test (Entailment) FAIL
Test sparqldl-13: sparqldl-13.rq: sameAs (Entailment) FAIL
Percentage passed out of 70 Tests 35.7%

equality of values

Test Ruby SPARQL
Test eq-1: Equality 1-1 PASS
Test eq-2: Equality 1-2 PASS
Test eq-3: Equality 1-3 PASS
Test eq-4: Equality 1-4 PASS
Test eq-5: Equality 1-5 PASS
Test eq-2-1: Equality - 2 var - test equals PASS
Test eq-2-2: Equality - 2 var - test not equals PASS
Test eq-graph-1: Equality 1-1 -- graph PASS
Test eq-graph-2: Equality 1-2 -- graph PASS
Test eq-graph-3: Equality 1-3 -- graph PASS
Test eq-graph-4: Equality 1-4 -- graph PASS
Test eq-graph-5: Equality 1-5 -- graph PASS
Percentage passed out of 12 Tests 100.0%

GRAPH

Test Ruby SPARQL
Test dawg-graph-01: graph-01 PASS
Test dawg-graph-02: graph-02 PASS
Test dawg-graph-03: graph-03 PASS
Test dawg-graph-04: graph-04 PASS
Test dawg-graph-05: graph-05 PASS
Test dawg-graph-06: graph-06 PASS
Test dawg-graph-07: graph-07 PASS
Test dawg-graph-08: graph-08 PASS
Test dawg-graph-09: graph-09 PASS
Test dawg-graph-10b: graph-10b PASS
Test dawg-graph-11: graph-11 PASS
Percentage passed out of 11 Tests 100.0%

Grouping

Test Ruby SPARQL
Test group01: Group-1 PASS
Test group03: Group-3 PASS
Test group04: Group-4 PASS
Test group05: Group-5 PASS
Test group06: Group-6 PASS
Test group07: Group-7 PASS
Percentage passed out of 6 Tests 100.0%

I18N

Test Ruby SPARQL
Test kanji-1: kanji-01 PASS
Test kanji-2: kanji-02 PASS
Test normalization-1: normalization-01 PASS
Test normalization-2: normalization-02 PASS
Test normalization-3: normalization-03 PASS
Percentage passed out of 5 Tests 100.0%

JSON Result Format

Test Ruby SPARQL
Test jsonres01: jsonres01 - JSON Result Format PASS
Test jsonres02: jsonres02 - JSON Result Format PASS
Test jsonres03: jsonres03 - JSON Result Format PASS
Test jsonres04: jsonres04 - JSON Result Format PASS
Percentage passed out of 4 Tests 100.0%

Move

Test Ruby SPARQL
Test move01: MOVE 1 PASS
Test move02: MOVE 2 PASS
Test move03: MOVE 3 PASS
Test move04: MOVE 4 PASS
Test move06: MOVE 6 PASS
Test move07: MOVE 7 PASS
Percentage passed out of 6 Tests 100.0%

Negation

Test Ruby SPARQL
Test subset-by-exclusion-nex-1: Subsets by exclusion (NOT EXISTS) PASS
Test subset-by-exclusion-minus-1: Subsets by exclusion (MINUS) PASS
Test temporal-proximity-by-exclusion-nex-1: Medical, temporal proximity by exclusion (NOT EXISTS) PASS
Test subset-01: Calculate which sets are subsets of others (include A subsetOf A) PASS
Test subset-02: Calculate which sets are subsets of others (exclude A subsetOf A) PASS
Test set-equals-1: Calculate which sets have the same elements PASS
Test subset-03: Calculate proper subset PASS
Test exists-01: Positive EXISTS 1 PASS
Test exists-02: Positive EXISTS 2 PASS
Test full-minuend: Subtraction with MINUS from a fully bound minuend PASS
Test partial-minuend: Subtraction with MINUS from a partially bound minuend PASS
Percentage passed out of 11 Tests 100.0%

open world value testing tests

Test Ruby SPARQL
Test open-eq-01: open-eq-01 PASS
Test open-eq-02: open-eq-02 PASS
Test open-eq-03: open-eq-03 PASS
Test open-eq-04: open-eq-04 PASS
Test open-eq-05: open-eq-05 PASS
Test open-eq-06: open-eq-06 PASS
Test open-eq-07: open-eq-07 PASS
Test open-eq-08: open-eq-08 PASS
Test open-eq-09: open-eq-09 PASS
Test open-eq-10: open-eq-10 PASS
Test open-eq-11: open-eq-11 PASS
Test open-eq-12: open-eq-12 PASS
Test date-1: date-1 (Different results on unapproved tests) FAIL
Test date-2: date-2 PASS
Test date-3: date-3 PASS
Test date-4: date-4 PASS
Test open-cmp-01: open-cmp-01 PASS
Test open-cmp-02: open-cmp-02 PASS
Percentage passed out of 18 Tests 94.4%

OPTIONAL

Test Ruby SPARQL
Test dawg-optional-001: One optional clause PASS
Test dawg-optional-002: Two optional clauses PASS
Test dawg-union-001: Union is not optional PASS
Test dawg-optional-complex-1: Complex optional semantics: 1 PASS
Test dawg-optional-complex-2: Complex optional semantics: 2 PASS
Test dawg-optional-complex-3: Complex optional semantics: 3 PASS
Test dawg-optional-complex-4: Complex optional semantics: 4 PASS
Percentage passed out of 7 Tests 100.0%

OPTIONAL FILTER

Test Ruby SPARQL
Test dawg-optional-filter-001: OPTIONAL-FILTER PASS
Test dawg-optional-filter-002: OPTIONAL - Outer FILTER PASS
Test dawg-optional-filter-003: OPTIONAL - Outer FILTER with BOUND PASS
Test dawg-optional-filter-004: OPTIONAL - Inner FILTER with negative EBV for outer variables PASS
Test dawg-optional-filter-005-simplified: dawg-optional-filter-005-simplified PASS
Test dawg-optional-filter-005-not-simplified: dawg-optional-filter-005-not-simplified (Different results on unapproved tests) FAIL
Percentage passed out of 6 Tests 83.3%

Positive Exists

Test Ruby SPARQL
Test exists01: Exists with one constant PASS
Test exists02: Exists with ground triple PASS
Test exists03: Exists within graph pattern PASS
Test exists04: Nested positive exists PASS
Test exists05: Nested negative exists in positive exists PASS
Percentage passed out of 5 Tests 100.0%

Project Expression

Test Ruby SPARQL
Test projexp01: Expression is equality PASS
Test projexp02: Expression raise an error PASS
Test projexp03: Reuse a project expression variable in select PASS
Test projexp04: Reuse a project expression variable in order by PASS
Test projexp05: Expression may return no value PASS
Test projexp06: Expression has undefined variable PASS
Test projexp07: Expression has variable that may be unbound PASS
Percentage passed out of 7 Tests 100.0%

Property Path

Test Ruby SPARQL
Test pp01: (pp01) Simple path PASS
Test pp02: (pp02) Star path PASS
Test pp03: (pp03) Simple path with loop PASS
Test pp06: (pp06) Path with two graphs PASS
Test pp07: (pp07) Path with one graph PASS
Test pp08: (pp08) Reverse path PASS
Test pp09: (pp09) Reverse sequence path PASS
Test pp10: (pp10) Path with negation PASS
Test pp11: (pp11) Simple path and two paths to same target node (Expects multiple equivalent property path solutions) FAIL
Test pp12: (pp12) Variable length path and two paths to same target node PASS
Test pp14: (pp14) Star path over foaf:knows PASS
Test pp16: (pp16) Duplicate paths and cycles through foaf:knows* PASS
Test pp21: (pp21) Diamond -- :p+ PASS
Test pp23: (pp23) Diamond, with tail -- :p+ PASS
Test pp25: (pp25) Diamond, with loop -- :p+ PASS
Test pp28a: (pp28a) Diamond, with loop -- (:p/:p)? PASS
Test pp30: (pp30) Operator precedence 1 PASS
Test pp31: (pp31) Operator precedence 2 (Expects multiple equivalent property path solutions) FAIL
Test pp32: (pp32) Operator precedence 3 PASS
Test pp33: (pp33) Operator precedence 4 PASS
Test pp34: (pp34) Named Graph 1 PASS
Test pp35: (pp35) Named Graph 2 PASS
Test pp36: (pp36) Arbitrary path with bound endpoints PASS
Test pp37: (pp37) Nested (*)* PASS
Percentage passed out of 24 Tests 91.7%

Property Path min/max

Test Ruby SPARQL
Test ppmm-0: path0 PASS
Test ppmm--2: path,2 PASS
Test ppmm-0-2: path0,2 PASS
Test ppmm-1-2: path1,2 PASS
Test ppmm-1-: path1, PASS
Test ppmm-2: path2 PASS
Percentage passed out of 6 Tests 100.0%

REDUCED

Test
Test reduced-1: SELECT REDUCED * (REDUCED equivalent to DISTINCT)
Test reduced-2: SELECT REDUCED ?x with strings (REDUCED equivalent to DISTINCT)
Percentage passed out of 2 Tests

REGEX

Test Ruby SPARQL
Test dawg-regex-001: regex-query-001 PASS
Test dawg-regex-002: regex-query-002 PASS
Test dawg-regex-003: regex-query-003 PASS
Test dawg-regex-004: regex-query-004 PASS
Percentage passed out of 4 Tests 100.0%

Solution Sequence

Test Ruby SPARQL
Test limit-1: Limit 1 PASS
Test limit-2: Limit 2 PASS
Test limit-3: Limit 3 PASS
Test limit-4: Limit 4 PASS
Test offset-1: Offset 1 PASS
Test offset-2: Offset 2 PASS
Test offset-3: Offset 3 PASS
Test offset-4: Offset 4 PASS
Test slice-1: Slice 1 PASS
Test slice-2: Slice 2 PASS
Test slice-3: Slice 3 PASS
Test slice-4: Slice 4 PASS
Test slice-5: Slice 5 PASS
Percentage passed out of 13 Tests 100.0%

SORT

Test Ruby SPARQL
Test dawg-sort-1: sort-1 PASS
Test dawg-sort-2: sort-2 PASS
Test dawg-sort-3: sort-3 PASS
Test dawg-sort-4: sort-4 PASS
Test dawg-sort-5: sort-5 PASS
Test dawg-sort-6: sort-6 PASS
Test dawg-sort-7: sort-7 PASS
Test dawg-sort-8: sort-8 PASS
Test dawg-sort-9: sort-9 PASS
Test dawg-sort-10: sort-10 PASS
Test dawg-sort-numbers: Expression sort PASS
Test dawg-sort-builtin: Builtin sort PASS
Test dawg-sort-function: Function sort PASS
Percentage passed out of 13 Tests 100.0%

SPARQL 1.1 Update test cases for SILENT

Test Ruby SPARQL
Test load-silent: LOAD SILENT PASS
Test load-into-silent: LOAD SILENT INTO PASS
Test clear-silent: CLEAR SILENT GRAPH iri PASS
Test clear-default-silent: CLEAR SILENT DEFAULT PASS
Test create-silent: CREATE SILENT iri PASS
Test drop-silent: DROP SILENT GRAPH iri PASS
Test drop-default-silent: DROP SILENT DEFAULT PASS
Test copy-silent: COPY SILENT PASS
Test copy-to-default-silent: COPY SILENT TO DEFAULT PASS
Test move-silent: MOVE SILENT PASS
Test move-to-default-silent: MOVE SILENT TO DEFAULT PASS
Test add-silent: ADD SILENT PASS
Test add-to-default-silent: ADD SILENT TO DEFAULT PASS
Percentage passed out of 13 Tests 100.0%

SPARQL Graph Store Protocol

Test
Test put__initial_state: PUT - Initial state
Test get_of_put__initial_state: GET of PUT - Initial state
Test put__graph_already_in_store: PUT - graph already in store
Test get_of_put__graph_already_in_store: GET of PUT - graph already in store
Test put__default_graph: PUT - default graph
Test get_of_put__default_graph: GET of PUT - default graph
Test put__mismatched_payload: PUT - mismatched payload
Test delete__existing_graph: DELETE - existing graph
Test get_of_delete__existing_graph: GET of DELETE - existing graph
Test delete__nonexistent_graph: DELETE - non-existent graph)
Test post__existing_graph: POST - existing graph
Test get_of_post__existing_graph: GET of POST - existing graph
Test post__multipart_formdata: POST - multipart/form-data
Test get_of_post__multipart_formdata: GET of POST - multipart/form-data
Test post__create__new_graph: POST - create new graph
Test get_of_post__create__new_graph: GET of POST - create new graph
Test get_of_post__after_noop: GET of POST - after noop
Test head_on_an_existing_graph:
Test head_on_a_nonexisting_graph: HEAD on a non-existing graph
Percentage passed out of 19 Tests

SPARQL Protocol

Test Ruby SPARQL
Test query_get: query via GET PASS
Test query_post_form: query via URL-encoded POST PASS
Test query_post_direct: query via POST directly PASS
Test query_dataset_default_graph: query with protocol-specified default graph PASS
Test query_dataset_default_graphs_get: GET query with protocol-specified default graphs PASS
Test query_dataset_default_graphs_post: POST query with protocol-specified default graphs PASS
Test query_dataset_named_graphs_post: POST query with protocol-specified named graphs PASS
Test query_dataset_named_graphs_get: GET query with protocol-specified named graphs PASS
Test query_dataset_full: query with protocol-specified dataset (both named and default graphs) PASS
Test query_multiple_dataset: query specifying dataset in both query string and protocol; test for use of protocol-specified dataset PASS
Test query_content_type_select: SELECT query appropriate content type (expect one of: XML, JSON, CSV, TSV) PASS
Test query_content_type_ask: ASK query appropriate content type (expect one of: XML, JSON) PASS
Test query_content_type_describe: DESCRIBE query appropriate content type (expect one of: RDF/XML, Turtle, N-Triples, RDFa, JSON-LD) PASS
Test query_content_type_construct: CONSTRUCT query appropriate content type (expect one of: RDF/XML, Turtle, N-Triples, RDFa, JSON-LD)) PASS
Test update_dataset_default_graph: update with protocol-specified default graph PASS
Test update_dataset_default_graphs: update with protocol-specified default graphs PASS
Test update_dataset_named_graphs: update with protocol-specified named graphs PASS
Test update_dataset_full: update with protocol-specified dataset (both named and default graphs) PASS
Test update_post_form: update via URL-encoded POST PASS
Test update_post_direct: update via POST directly PASS
Test update_base_uri: test for service-defined BASE URI ("which MAY be the service endpoint") PASS
Test bad_query_method: invoke query operation with a method other than GET or POST PASS
Test bad_multiple_queries: invoke query operation with more than one query string PASS
Test bad_query_wrong_media_type: invoke query operation with a POST with media type that's not url-encoded or application/sparql-query PASS
Test bad_query_missing_form_type: invoke query operation with url-encoded body, but without application/x-www-form-urlencoded media type PASS
Test bad_query_missing_direct_type: invoke query operation with SPARQL body, but without application/sparql-query media type PASS
Test bad_query_non_utf8: invoke query operation with direct POST, but with a non-UTF8 encoding (UTF-16) PASS
Test bad_query_syntax: invoke query operation with invalid query syntax (4XX result) PASS
Test bad_update_get: invoke update operation with GET PASS
Test bad_multiple_updates: invoke update operation with more than one update string PASS
Test bad_update_wrong_media_type: invoke update operation with a POST with media type that's not url-encoded or application/sparql-update PASS
Test bad_update_missing_form_type: invoke update operation with url-encoded body, but without application/x-www-form-urlencoded media type PASS
Test bad_update_non_utf8: invoke update operation with direct POST, but with a non-UTF8 encoding PASS
Test bad_update_syntax: invoke update operation with invalid update syntax (4XX result) PASS
Test bad_update_dataset_conflict: invoke update with both using-graph-uri/using-named-graph-uri parameter and USING/WITH clause PASS
Percentage passed out of 35 Tests 100.0%

SPARQL Service

Test Ruby SPARQL
Test service1: SERVICE test 1 (Federated Query) FAIL
Test service2: SERVICE test 2 (Federated Query) FAIL
Test service3: SERVICE test 3 (Federated Query) FAIL
Test service4a: SERVICE test 4a with VALUES clause (Federated Query) FAIL
Test service5: SERVICE test 5 (Federated Query) FAIL
Test service6: SERVICE test 6 (Federated Query) FAIL
Test service7: SERVICE test 7 (Federated Query) FAIL
Percentage passed out of 7 Tests 0.0%

SPARQL-star Evaluation Tests

Test Ruby SPARQL
Test sparql-star-results-1j: SPARQL-star - all graph triples (JSON results) PASS
Test sparql-star-results-1x: SPARQL-star - all graph triples (XML results) PASS
Test sparql-star-basic-2: SPARQL-star - match constant quoted triple PASS
Test sparql-star-basic-3: SPARQL-star - match quoted triple, var subject PASS
Test sparql-star-basic-4: SPARQL-star - match quoted triple, var predicate PASS
Test sparql-star-basic-5: SPARQL-star - match quoted triple, var object PASS
Test sparql-star-basic-6: SPARQL-star - no match of quoted triple PASS
Test sparql-star-pattern-1: SPARQL-star - Asserted and quoted triple PASS
Test sparql-star-pattern-2: SPARQL-star - Asserted and quoted triple PASS
Test sparql-star-pattern-3: SPARQL-star - Pattern - Variable for quoted triple PASS
Test sparql-star-pattern-4: SPARQL-star - Pattern - No match PASS
Test sparql-star-pattern-5: SPARQL-star - Pattern - match variables in triple terms PASS
Test sparql-star-pattern-6: SPARQL-star - Pattern - Nesting 1 PASS
Test sparql-star-pattern-7: SPARQL-star - Pattern - Nesting - 2 PASS
Test sparql-star-pattern-8: SPARQL-star - Pattern - Match and nesting PASS
Test sparql-star-pattern-9: SPARQL-star - Pattern - Same variable PASS
Test sparql-star-construct-1: SPARQL-star - CONSTRUCT with constant template PASS
Test sparql-star-construct-2: SPARQL-star - CONSTRUCT WHERE with constant template PASS
Test sparql-star-construct-3: SPARQL-star - CONSTRUCT - about every triple PASS
Test sparql-star-construct-4: SPARQL-star - CONSTRUCT with annotation syntax PASS
Test sparql-star-construct-5: SPARQL-star - CONSTRUCT WHERE with annotation syntax PASS
Test sparql-star-graphs-1: SPARQL-star - GRAPH PASS
Test sparql-star-graphs-2: SPARQL-star - GRAPHs with blank node PASS
Test sparql-star-expr-1: SPARQL-star - Embedded triple - BIND - CONSTRUCT PASS
Test sparql-star-expr-2: SPARQL-star - Embedded triple - Functions PASS
Test sparql-star-op-1: SPARQL-star - Embedded triple - sameTerm PASS
Test sparql-star-op-2: SPARQL-star - Embedded triple - value-equality PASS
Test sparql-star-op-3: SPARQL-star - Embedded triple - value-inequality PASS
Test sparql-star-op-4: SPARQL-star - Embedded triple - value-inequality PASS
Test sparql-star-order-1: SPARQL-star - Embedded triple - ORDER BY PASS
Test sparql-star-order-2: SPARQL-star - Embedded triple - ordering PASS
Test sparql-star-update-1: SPARQL-star - Update PASS
Test sparql-star-update-2: SPARQL-star - Update - annotation PASS
Test sparql-star-update-3: SPARQL-star - Update - data PASS
Percentage passed out of 34 Tests 100.0%

SPARQL-star Syntax Tests

Test Ruby SPARQL
Test sparql-star-1: SPARQL-star - subject quoted triple PASS
Test sparql-star-2: SPARQL-star - object quoted triple PASS
Test sparql-star-3: SPARQL-star - subject quoted triple - vars PASS
Test sparql-star-4: SPARQL-star - object quoted triple - vars PASS
Test sparql-star-5: SPARQL-star - Embedded triple in VALUES PASS
Test sparql-star-6: SPARQL-star - Embedded triple in CONSTRUCT PASS
Test sparql-star-7: SPARQL-star - Embedded triples in CONSTRUCT WHERE PASS
Test sparql-star-inside-1: SPARQL-star - quoted triple inside blankNodePropertyList PASS
Test sparql-star-inside-2: SPARQL-star - quoted triple inside collection PASS
Test sparql-star-nested-1: SPARQL-star - nested quoted triple, subject position PASS
Test sparql-star-nested-2: SPARQL-star - nested quoted triple, object position PASS
Test sparql-star-compound-1: SPARQL-star - compound forms PASS
Test sparql-star-bnode-1: SPARQL-star - blank node subject PASS
Test sparql-star-bnode-2: SPARQL-star - blank node object PASS
Test sparql-star-bnode-3: SPARQL-star - blank node PASS
Test sparql-star-ann-01: SPARQL-star - Annotation form PASS
Test sparql-star-ann-02: SPARQL-star - Annotation example PASS
Test sparql-star-ann-03: SPARQL-star - Annotation example PASS
Test sparql-star-ann-04: SPARQL-star - Annotation with quoting PASS
Test sparql-star-ann-05: SPARQL-star - Annotation on triple with quoted object PASS
Test sparql-star-ann-06: SPARQL-star - Annotation with path PASS
Test sparql-star-ann-07: SPARQL-star - Annotation with nested path PASS
Test sparql-star-ann-08: SPARQL-star - Annotation in CONSTRUCT PASS
Test sparql-star-ann-09: SPARQL-star - Annotation in CONSTRUCT WHERE PASS
Test sparql-star-expr-1: SPARQL-star - Expressions - Embedded triple PASS
Test sparql-star-expr-2: SPARQL-star - Expressions - Embedded triple PASS
Test sparql-star-expr-3: SPARQL-star - Expressions - Functions PASS
Test sparql-star-expr-4: SPARQL-star - Expressions - TRIPLE PASS
Test sparql-star-expr-5: SPARQL-star - Expressions - Functions PASS
Test sparql-star-expr-6: SPARQL-star - Expressions - BIND - CONSTRUCT PASS
Test sparql-star-bad-1: SPARQL-star - bad - quoted triple as predicate PASS
Test sparql-star-bad-2: SPARQL-star - bad - quoted triple outside triple PASS
Test sparql-star-bad-3: SPARQL-star - bad - collection list in quoted triple PASS
Test sparql-star-bad-4: SPARQL-star - bad - literal in subject position of quoted triple PASS
Test sparql-star-bad-5: SPARQL-star - bad - blank node as predicate in quoted triple PASS
Test sparql-star-bad-6: SPARQL-star - bad - compound blank node expression PASS
Test sparql-star-bad-7: SPARQL-star - bad - incomplete quoted triple PASS
Test sparql-star-bad-8: SPARQL-star - bad - quad quoted triple PASS
Test sparql-star-bad-9: SPARQL-star - bad - variable in quoted triple in VALUES PASS
Test sparql-star-bad-10: SPARQL-star - bad - blank node in quoted triple in VALUES PASS
Test sparql-star-bad-11: SPARQL-star - bad - blank node in quoted triple in FILTER PASS
Test sparql-star-bad-12: SPARQL-star - bad - blank node in quoted triple in BIND PASS
Test sparql-star-bad-ann-1: SPARQL-star - bad - empty annotation PASS
Test sparql-star-bad-ann-2: SPARQL-star - bad - triples in annotation PASS
Test sparql-star-bad-ann-path-1: SPARQL-star - bad - path - seq PASS
Test sparql-star-bad-ann-path-2: SPARQL-star - bad - path - alt PASS
Test sparql-star-bad-ann-path-3: SPARQL-star - bad - path - p* PASS
Test sparql-star-bad-ann-path-4: SPARQL-star - bad - path - p+ PASS
Test sparql-star-bad-ann-path-5: SPARQL-star - bad - path - p? PASS
Test sparql-star-bad-ann-path-6: SPARQL-star - bad - path in CONSTRUCT PASS
Test sparql-star-bad-ann-path-7: SPARQL-star - bad - path in CONSTRUCT PASS
Test sparql-star-update-1: SPARQL-star - update PASS
Test sparql-star-update-2: SPARQL-star - update PASS
Test sparql-star-update-3: SPARQL-star - update PASS
Test sparql-star-update-4: SPARQL-star - update with quoting PASS
Test sparql-star-update-5: SPARQL-star - update with quoted object PASS
Test sparql-star-update-6: SPARQL-star - update with annotation template PASS
Test sparql-star-update-7: SPARQL-star - update with annotation, template and pattern PASS
Test sparql-star-update-8: SPARQL-star - update DATA with annotation PASS
Test sparql-star-bad-update-1: SPARQL-star - update - bad syntax PASS
Test sparql-star-bad-update-2: SPARQL-star - update - bad syntax PASS
Test sparql-star-bad-update-3: SPARQL-star - update - bad syntax PASS
Test sparql-star-bad-update-4: SPARQL-star - update - bad syntax PASS
Percentage passed out of 63 Tests 100.0%

Sub query

Test Ruby SPARQL
Test subquery01: sq01 - Subquery within graph pattern PASS
Test subquery02: sq02 - Subquery within graph pattern, graph variable is bound PASS
Test subquery03: sq03 - Subquery within graph pattern, graph variable is not bound (Graph variable binding differences) FAIL
Test subquery04: sq04 - Subquery within graph pattern, default graph does not apply PASS
Test subquery05: sq05 - Subquery within graph pattern, from named applies PASS
Test subquery06: sq06 - Subquery with graph pattern, from named applies PASS
Test subquery07: sq07 - Subquery with from PASS
Test subquery08: sq08 - Subquery with aggregate PASS
Test subquery09: sq09 - Nested Subqueries PASS
Test subquery10: sq10 - Subquery with exists PASS
Test subquery11: sq11 - Subquery limit per resource PASS
Test subquery12: sq12 - Subquery in CONSTRUCT with built-ins PASS
Test subquery13: sq13 - Subqueries don't inject bindings PASS
Test subquery14: sq14 - limit by resource PASS
Percentage passed out of 14 Tests 92.9%

Syntax 1

Test Ruby SPARQL
Test syntax-basic-01: syntax-basic-01.rq PASS
Test syntax-basic-02: syntax-basic-02.rq PASS
Test syntax-basic-03: syntax-basic-03.rq PASS
Test syntax-basic-04: syntax-basic-04.rq PASS
Test syntax-basic-05: syntax-basic-05.rq PASS
Test syntax-basic-06: syntax-basic-06.rq PASS
Test syntax-qname-01: syntax-qname-01.rq PASS
Test syntax-qname-02: syntax-qname-02.rq PASS
Test syntax-qname-03: syntax-qname-03.rq PASS
Test syntax-qname-04: syntax-qname-04.rq PASS
Test syntax-qname-05: syntax-qname-05.rq PASS
Test syntax-qname-06: syntax-qname-06.rq PASS
Test syntax-qname-07: syntax-qname-07.rq PASS
Test syntax-qname-08: syntax-qname-08.rq PASS
Test syntax-lit-01: syntax-lit-01.rq PASS
Test syntax-lit-02: syntax-lit-02.rq PASS
Test syntax-lit-03: syntax-lit-03.rq PASS
Test syntax-lit-04: syntax-lit-04.rq PASS
Test syntax-lit-05: syntax-lit-05.rq PASS
Test syntax-lit-06: syntax-lit-06.rq PASS
Test syntax-lit-07: syntax-lit-07.rq PASS
Test syntax-lit-08: syntax-lit-08.rq (Decimal format changed in SPARQL 1.1) UNTESTED
Test syntax-lit-09: syntax-lit-09.rq PASS
Test syntax-lit-10: syntax-lit-10.rq PASS
Test syntax-lit-11: syntax-lit-11.rq PASS
Test syntax-lit-12: syntax-lit-12.rq PASS
Test syntax-lit-13: syntax-lit-13.rq PASS
Test syntax-lit-14: syntax-lit-14.rq PASS
Test syntax-lit-15: syntax-lit-15.rq PASS
Test syntax-lit-16: syntax-lit-16.rq PASS
Test syntax-lit-17: syntax-lit-17.rq PASS
Test syntax-lit-18: syntax-lit-18.rq PASS
Test syntax-lit-19: syntax-lit-19.rq PASS
Test syntax-lit-20: syntax-lit-20.rq PASS
Test syntax-struct-01: syntax-struct-01.rq PASS
Test syntax-struct-02: syntax-struct-02.rq PASS
Test syntax-struct-03: syntax-struct-03.rq PASS
Test syntax-struct-05: syntax-struct-05.rq PASS
Test syntax-struct-06: syntax-struct-06.rq PASS
Test syntax-struct-07: syntax-struct-07.rq PASS
Test syntax-struct-08: syntax-struct-08.rq PASS
Test syntax-struct-09: syntax-struct-09.rq PASS
Test syntax-struct-10: syntax-struct-10.rq PASS
Test syntax-struct-11: syntax-struct-11.rq PASS
Test syntax-struct-12: syntax-struct-12.rq PASS
Test syntax-struct-13: syntax-struct-13.rq PASS
Test syntax-struct-14: syntax-struct-14.rq PASS
Test syntax-lists-01: syntax-lists-01.rq PASS
Test syntax-lists-02: syntax-lists-02.rq PASS
Test syntax-lists-03: syntax-lists-03.rq PASS
Test syntax-lists-04: syntax-lists-04.rq PASS
Test syntax-lists-05: syntax-lists-05.rq PASS
Test syntax-bnodes-01: syntax-bnodes-01.rq PASS
Test syntax-bnodes-02: syntax-bnodes-02.rq PASS
Test syntax-bnodes-03: syntax-bnodes-03.rq PASS
Test syntax-bnodes-04: syntax-bnodes-04.rq PASS
Test syntax-bnodes-05: syntax-bnodes-05.rq PASS
Test syntax-forms-01: syntax-forms-01.rq PASS
Test syntax-forms-02: syntax-forms-02.rq PASS
Test syntax-union-01: syntax-union-01.rq PASS
Test syntax-union-02: syntax-union-02.rq PASS
Test syntax-expr-01: syntax-expr-01.rq PASS
Test syntax-expr-02: syntax-expr-02.rq PASS
Test syntax-expr-03: syntax-expr-03.rq PASS
Test syntax-expr-04: syntax-expr-04.rq PASS
Test syntax-expr-05: syntax-expr-05.rq PASS
Test syntax-order-01: syntax-order-01.rq PASS
Test syntax-order-02: syntax-order-02.rq PASS
Test syntax-order-03: syntax-order-03.rq PASS
Test syntax-order-04: syntax-order-04.rq PASS
Test syntax-order-05: syntax-order-05.rq PASS
Test syntax-order-06: syntax-order-06.rq PASS
Test syntax-order-07: syntax-order-07.rq PASS
Test syntax-limit-offset-01: syntax-limit-offset-01.rq PASS
Test syntax-limit-offset-02: syntax-limit-offset-02.rq PASS
Test syntax-limit-offset-03: syntax-limit-offset-03.rq PASS
Test syntax-limit-offset-04: syntax-limit-offset-04.rq PASS
Test syntax-pat-01: syntax-pat-01.rq PASS
Test syntax-pat-02: syntax-pat-02.rq PASS
Test syntax-pat-03: syntax-pat-03.rq PASS
Test syntax-pat-04: syntax-pat-04.rq PASS
Percentage passed out of 81 Tests 98.8%

Syntax 2

Test Ruby SPARQL
Test syntax-general-01: syntax-general-01.rq PASS
Test syntax-general-02: syntax-general-02.rq PASS
Test syntax-general-03: syntax-general-03.rq PASS
Test syntax-general-04: syntax-general-04.rq PASS
Test syntax-general-05: syntax-general-05.rq PASS
Test syntax-general-06: syntax-general-06.rq PASS
Test syntax-general-07: syntax-general-07.rq PASS
Test syntax-general-08: syntax-general-08.rq PASS
Test syntax-general-09: syntax-general-09.rq PASS
Test syntax-general-10: syntax-general-10.rq PASS
Test syntax-general-11: syntax-general-11.rq PASS
Test syntax-general-12: syntax-general-12.rq PASS
Test syntax-general-13: syntax-general-13.rq PASS
Test syntax-general-14: syntax-general-14.rq PASS
Test syntax-keywords-01: syntax-keywords-01.rq PASS
Test syntax-keywords-02: syntax-keywords-02.rq PASS
Test syntax-keywords-03: syntax-keywords-03.rq PASS
Test syntax-lists-01: syntax-lists-01.rq PASS
Test syntax-lists-02: syntax-lists-02.rq PASS
Test syntax-lists-03: syntax-lists-03.rq PASS
Test syntax-lists-04: syntax-lists-04.rq PASS
Test syntax-lists-05: syntax-lists-05.rq PASS
Test syntax-bnode-01: syntax-bnode-01.rq PASS
Test syntax-bnode-02: syntax-bnode-02.rq PASS
Test syntax-bnode-03: syntax-bnode-03.rq PASS
Test syntax-function-01: syntax-function-01.rq PASS
Test syntax-function-02: syntax-function-02.rq PASS
Test syntax-function-03: syntax-function-03.rq PASS
Test syntax-function-04: syntax-function-04.rq PASS
Test syntax-form-select-01: syntax-form-select-01.rq PASS
Test syntax-form-select-02: syntax-form-select-02.rq PASS
Test syntax-form-ask-02: syntax-form-ask-02.rq PASS
Test syntax-form-construct01: syntax-form-construct01.rq PASS
Test syntax-form-construct02: syntax-form-construct02.rq PASS
Test syntax-form-construct03: syntax-form-construct03.rq PASS
Test syntax-form-construct04: syntax-form-construct04.rq PASS
Test syntax-form-construct06: syntax-form-construct06.rq PASS
Test syntax-form-describe01: syntax-form-describe01.rq PASS
Test syntax-form-describe02: syntax-form-describe02.rq PASS
Test syntax-dataset-01: syntax-dataset-01.rq PASS
Test syntax-dataset-02: syntax-dataset-02.rq PASS
Test syntax-dataset-03: syntax-dataset-03.rq PASS
Test syntax-dataset-04: syntax-dataset-04.rq PASS
Test syntax-graph-01: syntax-graph-01.rq PASS
Test syntax-graph-02: syntax-graph-02.rq PASS
Test syntax-graph-03: syntax-graph-03.rq PASS
Test syntax-graph-04: syntax-graph-04.rq PASS
Test syntax-graph-05: syntax-graph-05.rq PASS
Test syntax-esc-01: syntax-esc-01.rq PASS
Test syntax-esc-02: syntax-esc-02.rq PASS
Test syntax-esc-03: syntax-esc-03.rq PASS
Test syntax-esc-04: syntax-esc-04.rq (PNAME_LN changed in SPARQL 1.1) UNTESTED
Test syntax-esc-05: syntax-esc-05.rq (PNAME_LN changed in SPARQL 1.1) UNTESTED
Percentage passed out of 53 Tests 96.2%

Syntax 3

Test Ruby SPARQL
Test syn-01: syn-01.rq PASS
Test syn-02: syn-02.rq PASS
Test syn-03: syn-03.rq PASS
Test syn-04: syn-04.rq PASS
Test syn-05: syn-05.rq PASS
Test syn-06: syn-06.rq PASS
Test syn-07: syn-07.rq PASS
Test syn-08: syn-08.rq PASS
Test syn-bad-01: syn-bad-01.rq PASS
Test syn-bad-02: syn-bad-02.rq PASS
Test syn-bad-03: syn-bad-03.rq PASS
Test syn-bad-04: syn-bad-04.rq PASS
Test syn-bad-05: syn-bad-05.rq PASS
Test syn-bad-06: syn-bad-06.rq PASS
Test syn-bad-07: syn-bad-07.rq PASS
Test syn-bad-08: syn-bad-08.rq PASS
Test syn-bad-09: syn-bad-09.rq PASS
Test syn-bad-10: syn-bad-10.rq PASS
Test syn-bad-11: syn-bad-11.rq PASS
Test syn-bad-12: syn-bad-12.rq PASS
Test syn-bad-13: syn-bad-13.rq PASS
Test syn-bad-14: syn-bad-14.rq PASS
Test syn-bad-15: syn-bad-15.rq PASS
Test syn-bad-16: syn-bad-16.rq PASS
Test syn-bad-17: syn-bad-17.rq PASS
Test syn-bad-18: syn-bad-18.rq PASS
Test syn-bad-19: syn-bad-19.rq PASS
Test syn-bad-20: syn-bad-20.rq PASS
Test syn-bad-21: syn-bad-21.rq PASS
Test syn-bad-22: syn-bad-22.rq PASS
Test syn-bad-23: syn-bad-23.rq PASS
Test syn-bad-24: syn-bad-24.rq PASS
Test syn-bad-25: syn-bad-25.rq PASS
Test syn-bad-26: syn-bad-26.rq PASS
Test syn-bad-27: syn-bad-27.rq PASS
Test syn-bad-28: syn-bad-28.rq PASS
Test syn-bad-29: syn-bad-29.rq PASS
Test syn-bad-30: syn-bad-30.rq PASS
Test syn-bad-31: syn-bad-31.rq PASS
Test bnode-dot: syn-bad-bnode-dot.rq PASS
Test bnodes-missing-pvalues-01: syn-bad-bnodes-missing-pvalues-01.rq PASS
Test bnodes-missing-pvalues-02: syn-bad-bnodes-missing-pvalues-02.rq PASS
Test empty-optional-01: syn-bad-empty-optional-01.rq PASS
Test empty-optional-02: syn-bad-empty-optional-02.rq PASS
Test filter-missing-parens: syn-bad-filter-missing-parens.rq PASS
Test lone-list: syn-bad-lone-list.rq PASS
Test lone-node: syn-bad-lone-node.rq PASS
Test blabel-cross-filter: syn-blabel-cross-filter PASS
Test blabel-cross-graph-bad: syn-blabel-cross-graph-bad PASS
Test blabel-cross-optional-bad: syn-blabel-cross-optional-bad PASS
Test blabel-cross-union-bad: syn-blabel-cross-union-bad PASS
Percentage passed out of 51 Tests 100.0%

Syntax 4

Test Ruby SPARQL
Test syn-09: syn-09.rq PASS
Test syn-10: syn-10.rq PASS
Test syn-11: syn-11.rq PASS
Test syn-bad-34: syn-bad-34.rq PASS
Test syn-bad-35: syn-bad-35.rq PASS
Test syn-bad-36: syn-bad-36.rq PASS
Test syn-bad-37: syn-bad-37.rq PASS
Test syn-bad-38: syn-bad-38.rq PASS
Test syn-bad-OPT-breaks-BGP: syn-bad-OPT-breaks-BGP PASS
Test syn-bad-UNION-breaks-BGP: syn-bad-UNION-breaks-BGP PASS
Test syn-bad-GRAPH-breaks-BGP: syn-bad-GRAPH-breaks-BGP PASS
Test syn-leading-digits-in-prefixed-names: syn-leading-digits-in-prefixed-names.rq PASS
Percentage passed out of 12 Tests 100.0%

Syntax 5

Test Ruby SPARQL
Test syntax-reduced-01: syntax-reduced-01.rq PASS
Test syntax-reduced-02: syntax-reduced-02.rq PASS
Percentage passed out of 2 Tests 100.0%

Syntax Federation

Test Ruby SPARQL
Test test_1: syntax-service-01.rq PASS
Test test_2: syntax-service-02.rq PASS
Test test_3: syntax-service-03.rq PASS
Percentage passed out of 3 Tests 100.0%

Syntax Query

Test Ruby SPARQL
Test test_1: syntax-select-expr-01.rq PASS
Test test_2: syntax-select-expr-02.rq PASS
Test test_3: syntax-select-expr-03.rq PASS
Test test_4: syntax-select-expr-04.rq PASS
Test test_5: syntax-select-expr-05.rq PASS
Test test_6: syntax-aggregate-01.rq PASS
Test test_7: syntax-aggregate-02.rq PASS
Test test_8: syntax-aggregate-03.rq PASS
Test test_9: syntax-aggregate-04.rq PASS
Test test_10: syntax-aggregate-05.rq PASS
Test test_11: syntax-aggregate-06.rq PASS
Test test_12: syntax-aggregate-07.rq PASS
Test test_13: syntax-aggregate-08.rq PASS
Test test_14: syntax-aggregate-09.rq PASS
Test test_15: syntax-aggregate-10.rq PASS
Test test_16: syntax-aggregate-11.rq PASS
Test test_17: syntax-aggregate-12.rq PASS
Test test_18: syntax-aggregate-13.rq PASS
Test test_19: syntax-aggregate-14.rq PASS
Test test_20: syntax-aggregate-15.rq PASS
Test test_21: syntax-subquery-01.rq PASS
Test test_22: syntax-subquery-02.rq PASS
Test test_23: syntax-subquery-03.rq PASS
Test test_24: syntax-not-exists-01.rq PASS
Test test_25: syntax-not-exists-02.rq PASS
Test test_26: syntax-not-exists-03.rq PASS
Test test_27: syntax-exists-01.rq PASS
Test test_28: syntax-exists-02.rq PASS
Test test_29: syntax-exists-03.rq PASS
Test test_30: syntax-minus-01.rq PASS
Test test_31: syntax-oneof-01.rq PASS
Test test_32: syntax-oneof-02.rq PASS
Test test_33: syntax-oneof-03.rq PASS
Test test_34: syntax-bindingBINDscopes-01.rq PASS
Test test_35a: syntax-bindings-02a.rq with VALUES clause PASS
Test test_36a: syntax-bindings-03a.rq with VALUES clause PASS
Test test_38a: syntax-bindings-05a.rq with VALUES clause PASS
Test test_40: syntax-bind-02.rq PASS
Test test_41: syntax-construct-where-01.rq PASS
Test test_42: syntax-construct-where-02.rq PASS
Test test_43: syn-bad-01.rq PASS
Test test_44: syn-bad-02.rq PASS
Test test_45: syn-bad-03.rq PASS
Test test_46: syn-bad-04.rq PASS
Test test_47: syn-bad-05.rq PASS
Test test_48: syn-bad-06.rq PASS
Test test_49: syn-bad-07.rq PASS
Test test_50: syn-bad-08.rq PASS
Test test_51: syntax-bindings-09.rq PASS
Test test_53: PrefixName with hex-encoded colons PASS
Test test_54: PrefixName with unescaped colons PASS
Test test_55: syntax-BINDscope1.rq PASS
Test test_56: syntax-BINDscope2.rq PASS
Test test_57: syntax-BINDscope3.rq PASS
Test test_58: syntax-BINDscope4.rq PASS
Test test_59: syntax-BINDscope5.rq PASS
Test test_60: syntax-BINDscope6.rq PASS
Test test_61a: syntax-BINDscope7.rq PASS
Test test_62a: syntax-BINDscope8.rq PASS
Test test_63: syntax-propertyPaths-01.rq PASS
Test test_64: syntax-SELECTscope1.rq PASS
Test test_65: syntax-SELECTscope2 PASS
Test test_66: syntax-SELECTscope3.rq PASS
Test test_pn_01: syn-pname-01 PASS
Test test_pn_02: syn-pname-02 PASS
Test test_pn_03: syn-pname-03 PASS
Test test_pn_04: syn-pname-04 PASS
Test test_pn_05: syn-pname-05 PASS
Test test_pn_06: syn-pname-06 PASS
Test test_pn_07: syn-pname-07 PASS
Test test_pn_08: syn-pname-08 PASS
Test test_pn_09: syn-pname-09 PASS
Test test_pn_bad_01: syn-bad-pname-01 PASS
Test test_pn_bad_02: syn-bad-pname-02 PASS
Test test_pn_bad_03: syn-bad-pname-03 PASS
Test test_pn_bad_04: syn-bad-pname-04 PASS
Test test_pn_bad_05: syn-bad-pname-05 PASS
Test test_pn_bad_06: syn-bad-pname-06 (Raw PNAME validation) FAIL
Test test_pn_bad_07: syn-bad-pname-07 PASS
Test test_pn_bad_08: syn-bad-pname-08 PASS
Test test_pn_bad_09: syn-bad-pname-09 PASS
Test test_pn_bad_10: syn-bad-pname-10 PASS
Test test_pn_bad_11: syn-bad-pname-11 PASS
Test test_pn_bad_12: syn-bad-pname-12 PASS
Test test_pn_bad_13: syn-bad-pname-13 PASS
Test test_pp_coll: syn-pp-in-collection PASS
Test test_codepoint_escape_01: \U unicode codepoint escaping in literal PASS
Test test_codepoint_escape_bad_02: Invalid multi-pass codepoint escaping (\u then \U) PASS
Test test_codepoint_escape_bad_03: Invalid multi-pass codepoint escaping (\U then \u) PASS
Test test_codepoint_boundaries_04: utf8 literal using codepoints at notable unicode boundaries PASS
Test test_codepoint_boundaries_escaped_05: \U and \u unicode codepoint escaping in literal using codepoints at notable unicode boundaries PASS
Test test_codepoint_invalid_escaped_bad_06: \u unicode codepoint escaping in literal using partial surrogate pair PASS
Percentage passed out of 92 Tests 98.9%

Syntax Update 1

Test Ruby SPARQL
Test test_1: syntax-update-01.ru PASS
Test test_2: syntax-update-02.ru PASS
Test test_3: syntax-update-03.ru PASS
Test test_4: syntax-update-04.ru PASS
Test test_5: syntax-update-05.ru PASS
Test test_6: syntax-update-06.ru PASS
Test test_7: syntax-update-07.ru PASS
Test test_8: syntax-update-08.ru PASS
Test test_9: syntax-update-09.ru PASS
Test test_10: syntax-update-10.ru PASS
Test test_11: syntax-update-11.ru PASS
Test test_12: syntax-update-12.ru PASS
Test test_13: syntax-update-13.ru PASS
Test test_14: syntax-update-14.ru PASS
Test test_15: syntax-update-15.ru PASS
Test test_16: syntax-update-16.ru PASS
Test test_17: syntax-update-17.ru PASS
Test test_18: syntax-update-18.ru PASS
Test test_19: syntax-update-19.ru PASS
Test test_20: syntax-update-20.ru PASS
Test test_21: syntax-update-21.ru PASS
Test test_22: syntax-update-22.ru PASS
Test test_23: syntax-update-23.ru PASS
Test test_24: syntax-update-24.ru PASS
Test test_25: syntax-update-25.ru PASS
Test test_26: syntax-update-26.ru (Whitespace in string tokens) UNTESTED
Test test_27: syntax-update-27.ru (Whitespace in string tokens) UNTESTED
Test test_28: syntax-update-28.ru (Whitespace in string tokens) UNTESTED
Test test_29: syntax-update-29.ru PASS
Test test_30: syntax-update-30.ru PASS
Test test_31: syntax-update-31.ru PASS
Test test_32: syntax-update-32.ru PASS
Test test_33: syntax-update-33.ru PASS
Test test_34: syntax-update-34.ru PASS
Test test_35: syntax-update-35.ru PASS
Test test_36: syntax-update-36.ru (Whitespace in string tokens) UNTESTED
Test test_37: syntax-update-37.ru PASS
Test test_38: syntax-update-38.ru PASS
Test test_39: syntax-update-39.ru PASS
Test test_40: syntax-update-40.ru PASS
Test test_41: syntax-update-bad-01.ru PASS
Test test_42: syntax-update-bad-02.ru PASS
Test test_43: syntax-update-bad-03.ru PASS
Test test_44: syntax-update-bad-04.ru PASS
Test test_45: syntax-update-bad-05.ru PASS
Test test_46: syntax-update-bad-06.ru PASS
Test test_47: syntax-update-bad-07.ru PASS
Test test_48: syntax-update-bad-08.ru PASS
Test test_49: syntax-update-bad-09.ru PASS
Test test_50: syntax-update-bad-10.ru PASS
Test test_51: syntax-update-bad-11.ru PASS
Test test_52: syntax-update-bad-12.ru PASS
Test test_53: syntax-update-53.ru PASS
Test test_54: syntax-update-54.ru PASS
Percentage passed out of 54 Tests 92.6%

Syntax Update 2

Test Ruby SPARQL
Test syntax-update-other-01: syntax-update-other-01 PASS
Percentage passed out of 1 Tests 100.0%

Triple Match

Test Ruby SPARQL
Test dawg-triple-pattern-001: dawg-triple-pattern-001 PASS
Test dawg-triple-pattern-002: dawg-triple-pattern-002 PASS
Test dawg-triple-pattern-003: dawg-triple-pattern-003 PASS
Test dawg-triple-pattern-004: dawg-triple-pattern-004 PASS
Percentage passed out of 4 Tests 100.0%

Type Promotion

Test Ruby SPARQL
Test type-promotion-01: tP-double-double PASS
Test type-promotion-02: tP-double-float PASS
Test type-promotion-03: tP-double-decimal PASS
Test type-promotion-04: tP-float-float PASS
Test type-promotion-05: tP-float-decimal PASS
Test type-promotion-06: tP-decimal-decimal PASS
Test type-promotion-07: tP-integer-short PASS
Test type-promotion-08: tP-nonPositiveInteger-short PASS
Test type-promotion-09: tP-negativeInteger-short PASS
Test type-promotion-10: tP-long-short PASS
Test type-promotion-11: tP-int-short PASS
Test type-promotion-12: tP-short-short PASS
Test type-promotion-13: tP-byte-short PASS
Test type-promotion-14: tP-nonNegativeInteger-short PASS
Test type-promotion-15: tP-unsignedLong-short PASS
Test type-promotion-16: tP-unsignedInt-short PASS
Test type-promotion-17: tP-unsignedShort-short PASS
Test type-promotion-18: tP-unsignedByte-short PASS
Test type-promotion-19: tP-positiveInteger-short PASS
Test type-promotion-20: tP-short-double PASS
Test type-promotion-21: tP-short-float PASS
Test type-promotion-22: tP-short-decimal PASS
Test type-promotion-23: tP-short-short-fail PASS
Test type-promotion-24: tP-byte-short-fail PASS
Test type-promotion-25: tP-short-long-fail PASS
Test type-promotion-26: tP-short-int-fail PASS
Test type-promotion-27: tP-short-byte-fail PASS
Test type-promotion-28: tP-double-float-fail PASS
Test type-promotion-29: tP-double-decimal-fail PASS
Test type-promotion-30: tP-float-decimal-fail PASS
Percentage passed out of 30 Tests 100.0%

XPath operators

Test Ruby SPARQL
Test ge-1: Greater-than or equals PASS
Test le-1: Less-than or equals PASS
Test mul-1: Multiplication PASS
Test plus-1: Addition PASS
Test minus-1: Subtraction PASS
Test unplus-1: Unary Plusn PASS
Test unminus-1: Unary Minus PASS
Percentage passed out of 7 Tests 100.0%

XSD Functions and Operators

Test Ruby SPARQL
Test compare_duration01: compare xsd:duration values 01 PASS
Test compare_yearMonthDuration01: compare xsd:yearMonthDuration values 01 PASS
Test compare_dayTimeDuration01: compare xsd:dayTimeDuration values 01 PASS
Test compare_time01: compare xsd:date values 01 PASS
Test extract_date01: extract xsd:date components 01 PASS
Test extract_time01: extract xsd:time components 01 PASS
Test adjust_dateTime01: xsd:dateTime timezone adjustment 01 PASS
Test adjust_date01: xsd:date timezone adjustment 01 PASS
Test adjust_time01: xsd:time timezone adjustment 01 PASS
Test dateTime_subtract01: xsd:dateTime, xsd:date, xsd:time subtraction 01 PASS
Test duration_yearMonth_add01: xsd:yearMonthDuration addition 01 PASS
Test duration_dayTime_add01: xsd:dayTimeDuration addition 01 PASS
Test duration_yearMonth_subtract01: xsd:yearMonthDuration subtraction 01 PASS
Test duration_dayTime_subtract01: xsd:dayTimeDuration subtraction 01 PASS
Test constructor_date01: xsd:date construction 01 PASS
Test constructor_date02: xsd:date construction 02 PASS
Test constructor_time01: xsd:time construction 01 PASS
Test constructor_time02: xsd:time construction 02 PASS
Test constructor_duration01: xsd:duration construction 01 PASS
Test constructor_duration02: xsd:duration construction 02 PASS
Percentage passed out of 20 Tests 100.0%

Report Generation Software

This report generated by earl-report version 0.8.0 an Unlicensed Ruby application. More information is available at https://github.com/gkellogg/earl-report .