diff --git a/test/data/suites/rdflib/sparql/unicode.srx b/test/data/suites/rdflib/sparql/unicode.srx index 485f2f3ac7..79ac7fedec 100644 --- a/test/data/suites/rdflib/sparql/unicode.srx +++ b/test/data/suites/rdflib/sparql/unicode.srx @@ -1,14 +1,16 @@ - - + + urn:a - urn:p + + + urn:p diff --git a/test/test_sparql/test_result.py b/test/test_sparql/test_result.py index 53120119d1..a861d91b1f 100644 --- a/test/test_sparql/test_result.py +++ b/test/test_sparql/test_result.py @@ -8,6 +8,7 @@ from dataclasses import dataclass from io import BytesIO, StringIO from pathlib import Path +from test.utils.result import ResultType from typing import ( IO, BinaryIO, @@ -111,13 +112,6 @@ def check_serialized(format: str, result: Result, data: str) -> None: assert result == parsed_result -class ResultType(str, enum.Enum): - CONSTRUCT = "CONSTRUCT" - DESCRIBE = "DESCRIBE" - SELECT = "SELECT" - ASK = "ASK" - - class ResultFormatTrait(enum.Enum): HAS_SERIALIZER = enum.auto() HAS_PARSER = enum.auto() diff --git a/test/test_w3c_spec/test_sparql10_w3c.py b/test/test_w3c_spec/test_sparql10_w3c.py new file mode 100644 index 0000000000..7f537576c6 --- /dev/null +++ b/test/test_w3c_spec/test_sparql10_w3c.py @@ -0,0 +1,128 @@ +""" +Runs the SPARQL 1.0 test suite from. +""" +from test.data import TEST_DATA_DIR +from test.utils import ensure_suffix +from test.utils.dawg_manifest import MarksDictType, params_from_sources +from test.utils.iri import URIMapper +from test.utils.sparql_checker import ( + SKIP_TYPES, + SPARQLEntry, + check_entry, + ctx_configure_rdflib, +) +from typing import Generator + +import pytest +from pytest import MonkeyPatch + +REMOTE_BASE_IRI = "http://www.w3.org/2001/sw/DataAccess/tests/data-r2/" +LOCAL_BASE_DIR = TEST_DATA_DIR / "suites/w3c/dawg-data-r2/" +MAPPER = URIMapper.from_mappings( + (REMOTE_BASE_IRI, ensure_suffix(LOCAL_BASE_DIR.as_uri(), "/")), +) +MARK_DICT: MarksDictType = { + f"{REMOTE_BASE_IRI}basic/manifest#term-6": pytest.mark.xfail( + reason="query misinterpreted." + ), + f"{REMOTE_BASE_IRI}basic/manifest#term-7": pytest.mark.xfail(reason="..."), + f"{REMOTE_BASE_IRI}expr-builtin/manifest#dawg-datatype-2": pytest.mark.xfail( + reason="additional row in output" + ), + f"{REMOTE_BASE_IRI}open-world/manifest#date-1": pytest.mark.xfail( + reason="RDFLib has more rows than it should have." + ), + f"{REMOTE_BASE_IRI}open-world/manifest#date-2": pytest.mark.xfail( + reason="RDFLib result has one too few rows." + ), + f"{REMOTE_BASE_IRI}optional-filter/manifest#dawg-optional-filter-005-simplified": pytest.mark.xfail( + reason="one row is missing a column" + ), + f"{REMOTE_BASE_IRI}reduced/manifest#reduced-2": pytest.mark.xfail( + reason="fails 2/3rds or the time" + ), + f"{REMOTE_BASE_IRI}syntax-sparql1/manifest#syntax-bnodes-03": pytest.mark.xfail( + reason="Issue with bnodes in query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql1/manifest#syntax-forms-01": pytest.mark.xfail(), + f"{REMOTE_BASE_IRI}syntax-sparql1/manifest#syntax-lists-01": pytest.mark.xfail( + reason="Issue with list in query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql1/manifest#syntax-lit-08": pytest.mark.skip( + reason="bad test, positive syntax has invalid syntax." + ), + f"{REMOTE_BASE_IRI}syntax-sparql2/manifest#syntax-form-describe01": pytest.mark.xfail( + reason="Describe not supported." + ), + f"{REMOTE_BASE_IRI}syntax-sparql2/manifest#syntax-general-08": pytest.mark.xfail( + reason="Not parsing with no spaces." + ), + f"{REMOTE_BASE_IRI}syntax-sparql2/manifest#syntax-lists-04": pytest.mark.xfail( + reason="Not handling lists in query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql3/manifest#blabel-cross-graph-bad": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql3/manifest#blabel-cross-optional-bad": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql3/manifest#blabel-cross-union-bad": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql3/manifest#syn-bad-26": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-34": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-35": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-36": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-37": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-38": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-GRAPH-breaks-BGP": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-OPT-breaks-BGP": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/manifest#syn-bad-UNION-breaks-BGP": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}syntax-sparql4/syn-bad-37.rq": pytest.mark.xfail( + reason="Accepts invalid query." + ), +} + + +@pytest.fixture(scope="module", autouse=True) +def configure_rdflib() -> Generator[None, None, None]: + with ctx_configure_rdflib(): + yield None + + +@pytest.mark.parametrize( + ["manifest_entry"], + params_from_sources( + MAPPER, + SPARQLEntry, + LOCAL_BASE_DIR / "manifest-evaluation.ttl", + LOCAL_BASE_DIR / "manifest-syntax.ttl", + mark_dict=MARK_DICT, + markers=( + lambda entry: pytest.mark.skip(reason="tester not implemented") + if entry.type in SKIP_TYPES + else None, + ), + report_prefix="rdflib_w3c_sparql10", + ), +) +def test_entry_sparql10(monkeypatch: MonkeyPatch, manifest_entry: SPARQLEntry) -> None: + check_entry(monkeypatch, manifest_entry) diff --git a/test/test_w3c_spec/test_sparql11_w3c.py b/test/test_w3c_spec/test_sparql11_w3c.py new file mode 100644 index 0000000000..af54675479 --- /dev/null +++ b/test/test_w3c_spec/test_sparql11_w3c.py @@ -0,0 +1,269 @@ +""" +Runs the SPARQL 1.1 test suite from. +""" +from test.data import TEST_DATA_DIR +from test.utils import ensure_suffix +from test.utils.dawg_manifest import MarksDictType, params_from_sources +from test.utils.iri import URIMapper +from test.utils.sparql_checker import ( + SKIP_TYPES, + SPARQLEntry, + check_entry, + ctx_configure_rdflib, +) +from typing import Generator + +import pytest +from pytest import MonkeyPatch + +REMOTE_BASE_IRI = "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/" +LOCAL_BASE_DIR = TEST_DATA_DIR / "suites/w3c/sparql11/" +MAPPER = URIMapper.from_mappings( + (REMOTE_BASE_IRI, ensure_suffix(LOCAL_BASE_DIR.as_uri(), "/")), +) +MARK_DICT: MarksDictType = { + f"{REMOTE_BASE_IRI}aggregates/manifest#agg-err-01": pytest.mark.xfail( + reason="Error in AVG should return no binding but it does." + ), + f"{REMOTE_BASE_IRI}aggregates/manifest#agg08": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}aggregates/manifest#agg09": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}aggregates/manifest#agg10": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}aggregates/manifest#agg11": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}aggregates/manifest#agg12": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}delete/manifest#dawg-delete-using-02a": pytest.mark.xfail( + reason="known issue" + ), + f"{REMOTE_BASE_IRI}delete/manifest#dawg-delete-using-06a": pytest.mark.xfail( + reason="known issue" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#paper-sparqldl-Q1-rdfs": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#paper-sparqldl-Q1": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#paper-sparqldl-Q2": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#paper-sparqldl-Q3": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#paper-sparqldl-Q4": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent10": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent3": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent4": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent5": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent6": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent7": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent8": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#parent9": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdf01": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs01": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs02": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs03": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs04": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs05": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs06": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs07": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs09": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs10": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#rdfs11": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple1": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple2": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple3": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple4": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple5": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple6": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple7": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#simple8": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-02": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-03": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-10": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-11": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-12": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}entailment/manifest#sparqldl-13": pytest.mark.xfail( + reason="entailment not implemented" + ), + f"{REMOTE_BASE_IRI}functions/manifest#strdt01": pytest.mark.xfail( + reason="Reason for test failure is not clear." + ), + f"{REMOTE_BASE_IRI}functions/manifest#strdt03": pytest.mark.xfail( + reason="Reason for test failure is not clear." + ), + f"{REMOTE_BASE_IRI}grouping/manifest#group06": pytest.mark.xfail( + reason="Accepts invalid query." + ), + f"{REMOTE_BASE_IRI}grouping/manifest#group07": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}property-path/manifest#pp37": pytest.mark.xfail( + reason="RDFLib produces one extra row" + ), + f"{REMOTE_BASE_IRI}service/manifest#service1": pytest.mark.skip( + reason="need custom handling" + ), + f"{REMOTE_BASE_IRI}service/manifest#service2": pytest.mark.skip( + reason="need custom handling" + ), + f"{REMOTE_BASE_IRI}service/manifest#service3": pytest.mark.skip( + reason="need custom handling" + ), + f"{REMOTE_BASE_IRI}service/manifest#service4a": pytest.mark.skip( + reason="need custom handling" + ), + f"{REMOTE_BASE_IRI}service/manifest#service5": pytest.mark.skip( + reason="test not supported" + ), + f"{REMOTE_BASE_IRI}service/manifest#service6": pytest.mark.skip( + reason="need custom handling" + ), + f"{REMOTE_BASE_IRI}service/manifest#service7": pytest.mark.skip( + reason="test not supported" + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_43": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_44": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_45": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_60": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_61a": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_62a": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-query/manifest#test_65": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_43": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_44": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_50": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_51": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_52": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}syntax-update-1/manifest#test_54": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), + f"{REMOTE_BASE_IRI}csv-tsv-res/manifest#csv01": pytest.mark.xfail( + reason="Bug in blank node serialization." + ), + f"{REMOTE_BASE_IRI}csv-tsv-res/manifest#csv02": pytest.mark.xfail( + reason="Bug in blank node serialization." + ), +} + + +@pytest.fixture(scope="module", autouse=True) +def configure_rdflib() -> Generator[None, None, None]: + with ctx_configure_rdflib(): + yield None + + +@pytest.mark.parametrize( + ["manifest_entry"], + params_from_sources( + MAPPER, + SPARQLEntry, + LOCAL_BASE_DIR / "manifest-all.ttl", + mark_dict=MARK_DICT, + markers=( + lambda entry: pytest.mark.skip(reason="tester not implemented") + if entry.type in SKIP_TYPES + else None, + ), + report_prefix="rdflib_w3c_sparql11", + ), +) +def test_entry_sparql11(monkeypatch: MonkeyPatch, manifest_entry: SPARQLEntry) -> None: + check_entry(monkeypatch, manifest_entry) diff --git a/test/test_w3c_spec/test_sparql_rdflib.py b/test/test_w3c_spec/test_sparql_rdflib.py new file mode 100644 index 0000000000..496d5eda1a --- /dev/null +++ b/test/test_w3c_spec/test_sparql_rdflib.py @@ -0,0 +1,65 @@ +""" +Runs the RDFLib SPARQL test suite. +""" +from test.data import TEST_DATA_DIR +from test.utils import ensure_suffix +from test.utils.dawg_manifest import MarksDictType, params_from_sources +from test.utils.iri import URIMapper +from test.utils.sparql_checker import ( + SKIP_TYPES, + SPARQLEntry, + check_entry, + ctx_configure_rdflib, +) +from typing import Generator + +import pytest +from pytest import MonkeyPatch + +REMOTE_BASE_IRI = ( + "http://raw.github.com/RDFLib/rdflib/master/test/data/suites/rdflib/sparql/" +) +LOCAL_BASE_DIR = TEST_DATA_DIR / "suites/rdflib/sparql/" +MAPPER = URIMapper.from_mappings( + (REMOTE_BASE_IRI, ensure_suffix(LOCAL_BASE_DIR.as_uri(), "/")), +) + +MARK_DICT: MarksDictType = { + f"{REMOTE_BASE_IRI}manifest.ttl#test-codepoint-escape-02": pytest.mark.xfail( + reason="known codepoint escape issue" + ), + f"{REMOTE_BASE_IRI}manifest.ttl#test-codepoint-escape-03": pytest.mark.xfail( + reason="known codepoint escape issue" + ), + f"{REMOTE_BASE_IRI}manifest.ttl#test-codepoint-escape-04": pytest.mark.xfail( + reason="known codepoint escape issue" + ), + f"{REMOTE_BASE_IRI}manifest.ttl#test-codepoint-escape-bad": pytest.mark.xfail( + reason="Parses sucessfully instead of failing." + ), +} + + +@pytest.fixture(scope="module", autouse=True) +def configure_rdflib() -> Generator[None, None, None]: + with ctx_configure_rdflib(): + yield None + + +@pytest.mark.parametrize( + ["manifest_entry"], + params_from_sources( + MAPPER, + SPARQLEntry, + LOCAL_BASE_DIR / "manifest.ttl", + mark_dict=MARK_DICT, + markers=( + lambda entry: pytest.mark.skip(reason="tester not implemented") + if entry.type in SKIP_TYPES + else None, + ), + report_prefix="rdflib_sparql", + ), +) +def test_entry_rdflib(monkeypatch: MonkeyPatch, manifest_entry: SPARQLEntry) -> None: + check_entry(monkeypatch, manifest_entry) diff --git a/test/test_w3c_spec/test_sparql_w3c.py b/test/test_w3c_spec/test_sparql_w3c.py deleted file mode 100644 index 1f5792b780..0000000000 --- a/test/test_w3c_spec/test_sparql_w3c.py +++ /dev/null @@ -1,568 +0,0 @@ -from __future__ import print_function - -import sys -from io import TextIOWrapper -from pathlib import PurePath - -# Needed to pass -# http://www.w3.org/2009/sparql/docs/tests/data-sparql11/ -# syntax-update-2/manifest#syntax-update-other-01 -from test.utils import file_uri_to_path -from test.utils.manifest import RDFTest, ResultType, read_manifest -from test.utils.namespace import MF, UT - -import pytest - -sys.setrecursionlimit(6000) # default is 1000 - - -import typing -from collections import Counter -from io import BytesIO -from typing import Callable, Dict, List, Optional, Tuple, cast -from urllib.parse import urljoin - -from rdflib import BNode, Dataset, Graph, URIRef -from rdflib.compare import isomorphic -from rdflib.compat import bopen, decodeStringEscape -from rdflib.plugins import sparql as rdflib_sparql_module -from rdflib.plugins.sparql.algebra import pprintAlgebra, translateQuery, translateUpdate -from rdflib.plugins.sparql.parser import parseQuery, parseUpdate -from rdflib.plugins.sparql.results.rdfresults import RDFResultParser -from rdflib.plugins.sparql.update import evalUpdate -from rdflib.query import Result -from rdflib.term import Identifier, Node - - -def eq(a, b, msg): - # return eq_(a, b, msg + ": (%r!=%r)" % (a, b)) - assert a == b, msg + ": (%r!=%r)" % (a, b) - - -def setFlags(): - import rdflib - - # Several tests rely on lexical form of literals being kept! - rdflib.NORMALIZE_LITERALS = False - - # we need an explicit default graph - rdflib_sparql_module.SPARQL_DEFAULT_GRAPH_UNION = False - - # we obviously need this - rdflib.DAWG_LITERAL_COLLATION = True - - -def resetFlags(): - import rdflib - - # Several tests rely on lexical form of literals being kept! - rdflib.NORMALIZE_LITERALS = True - - # we need an explicit default graph - rdflib_sparql_module.SPARQL_DEFAULT_GRAPH_UNION = True - - # we obviously need this - rdflib.DAWG_LITERAL_COLLATION = False - - -DEBUG_FAIL = True -DEBUG_FAIL = False - -DEBUG_ERROR = True -DEBUG_ERROR = False - -SPARQL10Tests = True -# SPARQL10Tests = False - -SPARQL11Tests = True -# SPARQL11Tests=False - -RDFLibTests = True - -DETAILEDASSERT = True -# DETAILEDASSERT=False - - -NAME = None - -fails: typing.Counter[str] = Counter() -errors: typing.Counter[str] = Counter() - -failed_tests = [] -error_tests = [] - - -def bopen_read_close(fn): - with bopen(fn) as f: - return f.read() - - -from test.test_w3c_spec.test_sparql_w3c_skipped import skiptests - - -def _fmt(f): - if f.endswith(".rdf"): - return "xml" - return "turtle" - - -def bindingsCompatible(a, b): - """ - - Are two binding-sets compatible. - - From the spec: http://www.w3.org/2009/sparql/docs/tests/#queryevaltests - - A SPARQL implementation passes a query evaluation test if the - graph produced by evaluating the query against the RDF dataset - (and encoding in the DAWG result set vocabulary, if necessary) is - equivalent [RDF-CONCEPTS] to the graph named in the result (after - encoding in the DAWG result set vocabulary, if necessary). Note - that, solution order only is considered relevant, if the result is - expressed in the test suite in the DAWG result set vocabulary, - with explicit rs:index triples; otherwise solution order is - considered irrelevant for passing. Equivalence can be tested by - checking that the graphs are isomorphic and have identical IRI and - literal nodes. Note that testing whether two result sets are - isomorphic is simpler than full graph isomorphism. Iterating over - rows in one set, finding a match with the other set, removing this - pair, then making sure all rows are accounted for, achieves the - same effect. - """ - - def rowCompatible(x, y): - m = {} - y = y.asdict() - for v1, b1 in x.asdict().items(): - if v1 not in y: - return False - if isinstance(b1, BNode): - if b1 in m: - if y[v1] != m[b1]: - return False - else: - m[b1] = y[v1] - else: - # if y[v1]!=b1: - # return False - try: - if y[v1].neq(b1): - return False - except TypeError: - return False - return True - - if not a: - if b: - return False - return True - - x = next(iter(a)) - - for y in b: - if rowCompatible(x, y): - if bindingsCompatible(a - set((x,)), b - set((y,))): - return True - - return False - - -def pp_binding(solutions): - """ - Pretty print a single binding - for less eye-strain when debugging - """ - return ( - "\n[" - + ",\n\t".join( - "{" + ", ".join("%s:%s" % (x[0], x[1].n3()) for x in bindings.items()) + "}" - for bindings in solutions - ) - + "]\n" - ) - - -def update_test(t: RDFTest): - - # the update-eval tests refer to graphs on http://example.org - rdflib_sparql_module.SPARQL_LOAD_GRAPHS = False - - uri, name, comment, data, graphdata, query, res, syntax = t - # These casts are here because the RDFTest type is not sufficently - # expressive to capture the two different flavors of tests. - res = cast(Optional[ResultType], res) - graphdata = cast(Optional[List[Tuple[Identifier, Identifier]]], graphdata) - - query_path: PurePath = file_uri_to_path(query) - - if uri in skiptests: - pytest.xfail() - - try: - g = Dataset() - - if not res: - if syntax: - with bopen(query_path) as f: - translateUpdate(parseUpdate(f)) - else: - try: - with bopen(query_path) as f: - translateUpdate(parseUpdate(f)) - raise AssertionError("Query shouldn't have parsed!") - except: - pass # negative syntax test - return - - res = cast(ResultType, res) - resdata: Identifier - resgraphdata: List[Tuple[Identifier, Identifier]] - resdata, resgraphdata = res # type: ignore[assignment] - - # read input graphs - if data: - g.default_context.parse(data, format=_fmt(data)) - - if graphdata: - for x, l in graphdata: - g.parse(x, publicID=URIRef(l), format=_fmt(x)) - - with bopen(query_path) as f: - req = translateUpdate(parseUpdate(f)) - evalUpdate(g, req) - - # read expected results - resg = Dataset() - if resdata: - resg.default_context.parse(resdata, format=_fmt(resdata)) - - if resgraphdata: - for x, l in resgraphdata: - resg.parse(x, publicID=URIRef(l), format=_fmt(x)) - - eq( - set(ctx.identifier for ctx in g.contexts() if ctx != g.default_context), - set( - ctx.identifier for ctx in resg.contexts() if ctx != resg.default_context - ), - "named graphs in datasets do not match", - ) - assert isomorphic( - g.default_context, resg.default_context - ), "Default graphs are not isomorphic" - - for ctx in g.contexts(): - if ctx == g.default_context: - continue - assert isomorphic(ctx, resg.get_context(ctx.identifier)), ( - "Graphs with ID %s are not isomorphic" % ctx.identifier - ) - - except Exception as e: - - if isinstance(e, AssertionError): - failed_tests.append(uri) - fails[str(e)] += 1 - else: - error_tests.append(uri) - errors[str(e)] += 1 - - if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL: - print("======================================") - print(uri) - print(name) - print(comment) - - if not res: - if syntax: - print("Positive syntax test") - else: - print("Negative syntax test") - - if data: - print("----------------- DATA --------------------") - print(">>>", data) - data_path: PurePath = file_uri_to_path(data) - print(bopen_read_close(data_path)) - if graphdata: - print("----------------- GRAPHDATA --------------------") - for x, l in graphdata: - print(">>>", x, l) - x_path: PurePath = file_uri_to_path(x) - print(bopen_read_close(x_path)) - - print("----------------- Request -------------------") - print(">>>", query) - print(bopen_read_close(query_path)) - - if res: - if resdata: - print("----------------- RES DATA --------------------") - print(">>>", resdata) - resdata_path: PurePath = file_uri_to_path(resdata) - print(bopen_read_close(resdata_path)) - if resgraphdata: - print("----------------- RES GRAPHDATA -------------------") - for x, l in resgraphdata: - print(">>>", x, l) - x_path = file_uri_to_path(x) - print(bopen_read_close(x_path)) - - print("------------- MY RESULT ----------") - print(g.serialize(format="trig")) - - try: - pq = translateUpdate(parseUpdate(bopen_read_close(query_path))) - print("----------------- Parsed ------------------") - pprintAlgebra(pq) - # print pq - except: - print("(parser error)") - - print(decodeStringEscape(str(e))) - - import pdb - - pdb.post_mortem(sys.exc_info()[2]) - raise - - -def query_test(t: RDFTest): - uri, name, comment, data, graphdata, query, resfile, syntax = t - - # These casts are here because the RDFTest type is not sufficently - # expressive to capture the two different flavors of tests. - graphdata = cast(Optional[List[Identifier]], graphdata) - resfile = cast(Optional[Identifier], resfile) - - # the query-eval tests refer to graphs to load by resolvable filenames - rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True - - query_path: PurePath = file_uri_to_path(query) - - resfile_path = file_uri_to_path(resfile) if resfile else None - - if uri in skiptests: - pytest.xfail() - - def skip(reason="(none)"): - print("Skipping %s from now on." % uri) - with bopen("skiptests.list", "a") as f: - f.write("%s\t%s\n" % (uri, reason)) - - try: - g = Dataset() - if data: - g.default_context.parse(data, format=_fmt(data)) - - if graphdata: - for x in graphdata: - g.parse(x, format=_fmt(x)) - - if not resfile: - # no result - syntax test - - if syntax: - translateQuery( - parseQuery(bopen_read_close(query_path)), base=urljoin(query, ".") - ) - else: - # negative syntax test - try: - translateQuery( - parseQuery(bopen_read_close(query_path)), - base=urljoin(query, "."), - ) - - assert False, "Query should not have parsed!" - except: - pass # it's fine - the query should not parse - return - - # eval test - carry out query - res2 = g.query(bopen_read_close(query_path), base=urljoin(query, ".")) - - if resfile.endswith("ttl"): - resg = Graph() - resg.parse(resfile, format="turtle", publicID=resfile) - res = RDFResultParser().parse(resg) - elif resfile.endswith("rdf"): - resg = Graph() - resg.parse(resfile, publicID=resfile) - res = RDFResultParser().parse(resg) - else: - with bopen(resfile_path) as f: - if resfile.endswith("srj"): - res = Result.parse(f, format="json") - elif resfile.endswith("tsv"): - res = Result.parse(TextIOWrapper(f), format="tsv") - - elif resfile.endswith("csv"): - res = Result.parse(f, format="csv") - - # CSV is lossy, round-trip our own resultset to - # lose the same info :) - - # write bytes, read strings... - s = BytesIO() - res2.serialize(s, format="csv") - s.seek(0) - res2 = Result.parse(s, format="csv") - s.close() - - else: - res = Result.parse(f, format="xml") - - if not DETAILEDASSERT: - eq(res.type, res2.type, "Types do not match") - if res.type == "SELECT": - assert res2.vars is not None - eq(set(res.vars), set(res2.vars), "Vars do not match") - comp = bindingsCompatible(set(res), set(res2)) - assert comp, "Bindings do not match" - elif res.type == "ASK": - eq(res.askAnswer, res2.askAnswer, "Ask answer does not match") - elif res.type in ("DESCRIBE", "CONSTRUCT"): - assert isomorphic(res.graph, res2.graph), "graphs are not isomorphic!" - else: - raise Exception("Unknown result type: %s" % res.type) - else: - eq( - res.type, - res2.type, - "Types do not match: %r != %r" % (res.type, res2.type), - ) - if res.type == "SELECT": - assert res2.vars is not None - eq( - set(res.vars), - set(res2.vars), - "Vars do not match: %r != %r" % (set(res.vars), set(res2.vars)), - ) - assert bindingsCompatible( - set(res), set(res2) - ), "Bindings do not match: \nexpected:\n%r\n!=\ngot:\n%r" % ( - res.serialize(format="txt", namespace_manager=g.namespace_manager), - res2.serialize(format="txt", namespace_manager=g.namespace_manager), - ) - elif res.type == "ASK": - eq( - res.askAnswer, - res2.askAnswer, - "Ask answer does not match: %r != %r" - % (res.askAnswer, res2.askAnswer), - ) - elif res.type in ("DESCRIBE", "CONSTRUCT"): - assert isomorphic(res.graph, res2.graph), "graphs are not isomorphic!" - else: - raise Exception("Unknown result type: %s" % res.type) - - except Exception as e: - - if isinstance(e, AssertionError): - failed_tests.append(uri) - fails[str(e)] += 1 - else: - error_tests.append(uri) - errors[str(e)] += 1 - - if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL: - print("======================================") - print(uri) - print(name) - print(comment) - - if not resfile: - if syntax: - print("Positive syntax test") - else: - print("Negative syntax test") - - if data: - print("----------------- DATA --------------------") - print(">>>", data) - data_path: PurePath = file_uri_to_path(data) - print(bopen_read_close(data_path)) - if graphdata: - print("----------------- GRAPHDATA --------------------") - for x in graphdata: - print(">>>", x) - x_path: PurePath = file_uri_to_path(x) - print(bopen_read_close(x_path)) - - print("----------------- Query -------------------") - print(">>>", query) - print(bopen_read_close(query_path)) - if resfile: - print("----------------- Res -------------------") - print(">>>", resfile) - print(bopen_read_close(resfile_path)) - - try: - pq = parseQuery(bopen_read_close(query_path)) - print("----------------- Parsed ------------------") - pprintAlgebra(translateQuery(pq, base=urljoin(query, "."))) - except: - print("(parser error)") - - print(decodeStringEscape(str(e))) - - import pdb - - pdb.post_mortem(sys.exc_info()[2]) - raise - - -testers: Dict[Node, Callable[[RDFTest], None]] = { - UT.UpdateEvaluationTest: update_test, - MF.UpdateEvaluationTest: update_test, - MF.PositiveUpdateSyntaxTest11: update_test, - MF.NegativeUpdateSyntaxTest11: update_test, - MF.QueryEvaluationTest: query_test, - MF.NegativeSyntaxTest11: query_test, - MF.PositiveSyntaxTest11: query_test, - MF.CSVResultFormatTest: query_test, -} - - -@pytest.fixture(scope="module", autouse=True) -def handle_flags(): - setFlags() - yield - resetFlags() - - -@pytest.mark.parametrize( - "rdf_test_uri, type, rdf_test", - read_manifest("test/data/suites/w3c/dawg-data-r2/manifest-evaluation.ttl"), -) -def test_dawg_data_sparql10(rdf_test_uri: URIRef, type: Node, rdf_test: RDFTest): - testers[type](rdf_test) - - -@pytest.mark.parametrize( - "rdf_test_uri, type, rdf_test", - read_manifest("test/data/suites/w3c/sparql11/manifest-all.ttl"), -) -def test_dawg_data_sparql11(rdf_test_uri: URIRef, type: Node, rdf_test: RDFTest): - testers[type](rdf_test) - - -EXPECTED_FAILURES: Dict[str, str] = {} - -for test in [ - "test-codepoint-escape-02", - "test-codepoint-escape-03", - "test-codepoint-escape-04", -]: - EXPECTED_FAILURES[test] = "known codepoint escape issue" - - -@pytest.mark.parametrize( - "rdf_test_uri, type, rdf_test", - read_manifest("test/data/suites/rdflib/sparql/manifest.ttl"), -) -def test_dawg_rdflib(rdf_test_uri: URIRef, type: Node, rdf_test: RDFTest): - suffix = rdf_test_uri.split("#")[1] - if suffix in EXPECTED_FAILURES: - pytest.xfail(EXPECTED_FAILURES[suffix]) - testers[type](rdf_test) diff --git a/test/test_w3c_spec/test_sparql_w3c_skipped.py b/test/test_w3c_spec/test_sparql_w3c_skipped.py deleted file mode 100644 index 5a21166e27..0000000000 --- a/test/test_w3c_spec/test_sparql_w3c_skipped.py +++ /dev/null @@ -1,59 +0,0 @@ -from rdflib import URIRef - -# Avoid in-this-case-tedious black reformatting ... - -testlist = { - "http://www.w3.org/2001/sw/DataAccess/tests/data-r2/basic/manifest#term-6": "allegedly “NOT SPARQL 1.1”", - "http://www.w3.org/2001/sw/DataAccess/tests/data-r2/basic/manifest#term-7": "allegedly “NOT SPARQL 1.1”", - "http://www.w3.org/2001/sw/DataAccess/tests/data-r2/expr-builtin/manifest#dawg-datatype-2": "“remove test - changes for SPARQL 1.1 and RDF 1.1 (rdf:langString)”", - "http://www.w3.org/2001/sw/DataAccess/tests/data-r2/open-world/manifest#date-2": "xsd:date not supported", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/delete/manifest#dawg-delete-using-02a": "known issue with update and datasets", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/delete/manifest#dawg-delete-using-06a": "known issue with update and datasets", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#paper-sparqldl-Q1": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#paper-sparqldl-Q1-rdfs": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#paper-sparqldl-Q2": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#paper-sparqldl-Q3": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent10": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent3": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent4": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent5": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent6": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent7": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#parent9": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdf01": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs01": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs02": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs03": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs04": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs05": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs06": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs07": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs08": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs09": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs10": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs11": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#rdfs12": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple1": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple2": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple3": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple4": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple5": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple6": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple7": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#simple8": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#sparqldl-02": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#sparqldl-03": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#sparqldl-10": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#sparqldl-12": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/entailment/manifest#sparqldl-13": "entailment not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service1": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service2": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service3": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service4a": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service5": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service6": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/service/manifest#service7": "service not implemented", - "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/aggregates/manifest#agg-empty-group": "unclear", -} - -skiptests = dict([(URIRef(k), v) for k, v in testlist.items()]) diff --git a/test/utils/result.py b/test/utils/result.py new file mode 100644 index 0000000000..98e31b98f9 --- /dev/null +++ b/test/utils/result.py @@ -0,0 +1,147 @@ +import enum +import logging +import pprint +from dataclasses import dataclass +from functools import lru_cache +from typing import Dict, FrozenSet, Mapping, Optional, Sequence, Set, Tuple, Union + +from rdflib.term import BNode, Identifier, Literal, Variable + +logger = logging.getLogger(__name__) + + +ResultTypeInfoDict = Dict["ResultType", "ResultTypeInfo"] + + +class ResultTypeTrait(enum.Enum): + GRAPH_RESULT = enum.auto() + + +class ResultType(str, enum.Enum): + CONSTRUCT = "CONSTRUCT" + DESCRIBE = "DESCRIBE" + SELECT = "SELECT" + ASK = "ASK" + + @classmethod + @lru_cache(maxsize=None) + def info_dict(cls) -> "ResultTypeInfoDict": + return ResultTypeInfo.make_dict( + ResultTypeInfo(ResultType.CONSTRUCT, {ResultTypeTrait.GRAPH_RESULT}), + ResultTypeInfo(ResultType.DESCRIBE, {ResultTypeTrait.GRAPH_RESULT}), + ResultTypeInfo(ResultType.CONSTRUCT, set()), + ResultTypeInfo(ResultType.CONSTRUCT, set()), + ) + + @property + def info(self) -> "ResultTypeInfo": + return self.info_dict()[self] + + @classmethod + @lru_cache(maxsize=None) + def set(cls) -> Set["ResultType"]: + return set(*cls) + + +@dataclass(frozen=True) +class ResultTypeInfo: + type: ResultType + traits: Set[ResultTypeTrait] + + @classmethod + def make_dict(cls, *items: "ResultTypeInfo") -> ResultTypeInfoDict: + return dict((info.type, info) for info in items) + + +BindingsType = Mapping[Variable, Optional[Identifier]] +BindingsSequenceType = Sequence[BindingsType] +CLiteralType = Union["CLiteral", "CLiteral"] + + +CIdentifier = Union[Identifier, CLiteralType] +CBindingSetType = FrozenSet[Tuple[Variable, CIdentifier]] +CBindingsType = Mapping[Variable, Optional[CIdentifier]] +CBindingsSequenceType = Sequence[CBindingsType] + + +@dataclass +class CLiteral: + literal: Literal + + def __eq__(self, __o: object) -> bool: + if not isinstance(__o, CLiteral): + return False + try: + return self.literal.eq(__o.literal) + except TypeError: + return self.literal == __o.literal + + +def comparable_node(node: Identifier) -> CIdentifier: + if isinstance(node, Literal): + return CLiteral(node) + if isinstance(node, BNode): + return BNode("urn:fdc:rdflib.github.io:20220526:collapsed-bnode") + return node + + +def comparable_bindings( + bindings: BindingsType, +) -> CBindingsType: + result = {} + for key, value in bindings.items(): + if value is None: + # TODO: FIXME: This may be a bug in how we generate bindings + continue + result[key] = comparable_node(value) + return result + + +def bindings_diff( + lhs: CBindingsSequenceType, rhs: CBindingsSequenceType +) -> Tuple[CBindingsSequenceType, CBindingsSequenceType, CBindingsSequenceType]: + rhs_only = [] + common = [] + lhs_matched = set() + for rhs_bindings in rhs: + found = False + for lhs_index, lhs_bindings in enumerate(lhs): + if lhs_index in lhs_matched: + # cant match same entry more than once + continue + if rhs_bindings == lhs_bindings: + lhs_matched.add(lhs_index) + found = True + break + if found: + common.append(rhs_bindings) + continue + else: + rhs_only.append(rhs_bindings) + lhs_only = [ + lhs_bindings + for lhs_index, lhs_bindings in enumerate(lhs) + if lhs_index not in lhs_matched + ] + return lhs_only, rhs_only, common + + +def assert_bindings_sequences_equal( + lhs: BindingsSequenceType, + rhs: BindingsSequenceType, + invert: bool = False, +) -> None: + clhs = [comparable_bindings(item) for item in lhs] + crhs = [comparable_bindings(item) for item in rhs] + lhs_only, rhs_only, common = bindings_diff(clhs, crhs) + if logger.isEnabledFor(logging.DEBUG): + logging.debug("common = \n%s", pprint.pformat(common, indent=1, width=80)) + logging.debug("lhs_only = \n%s", pprint.pformat(lhs_only, indent=1, width=80)) + logging.debug("rhs_only = \n%s", pprint.pformat(rhs_only, indent=1, width=80)) + if invert: + assert lhs_only != [] or rhs_only != [] + assert (len(common) != len(lhs)) or (len(common) != len(rhs)) + else: + assert lhs_only == [] + assert rhs_only == [] + assert (len(common) == len(lhs)) and (len(common) == len(rhs)) diff --git a/test/utils/sparql_checker.py b/test/utils/sparql_checker.py new file mode 100644 index 0000000000..f6375a4ddf --- /dev/null +++ b/test/utils/sparql_checker.py @@ -0,0 +1,421 @@ +"""This runs the nt tests for the W3C RDF Working Group's N-Quads +test suite.""" +import enum +import logging +import pprint +from contextlib import ExitStack, contextmanager +from dataclasses import dataclass, field +from io import BytesIO, StringIO +from pathlib import Path +from test.utils import BNodeHandling, GraphHelper +from test.utils.dawg_manifest import Manifest, ManifestEntry +from test.utils.iri import URIMapper +from test.utils.namespace import MF, QT, UT +from test.utils.result import ResultType, assert_bindings_sequences_equal +from typing import Any, Callable, Dict, Generator, Optional, Set, Tuple, Type, Union +from urllib.parse import urljoin + +import pytest +from pytest import MonkeyPatch + +import rdflib +from rdflib.graph import Dataset, Graph +from rdflib.namespace import RDFS +from rdflib.plugins import sparql as rdflib_sparql_module +from rdflib.plugins.sparql.algebra import translateQuery, translateUpdate +from rdflib.plugins.sparql.parser import parseQuery, parseUpdate +from rdflib.plugins.sparql.results.rdfresults import RDFResultParser +from rdflib.plugins.sparql.sparql import QueryContext +from rdflib.query import Result +from rdflib.term import BNode, IdentifiedNode, Identifier, Literal, Node, URIRef +from rdflib.util import guess_format + +logger = logging.getLogger(__name__) + +# TESTS: https://www.w3.org/2009/sparql/docs/tests/ +# Implementation Report: https://www.w3.org/2009/sparql/implementations/ +# Summary: https://www.w3.org/2009/sparql/docs/tests/summary.html +# README: https://www.w3.org/2009/sparql/docs/tests/README.html + + +ENCODING = "utf-8" + + +class QueryType(enum.Enum): + QUERY = enum.auto() + UPDATE = enum.auto() + + +@dataclass +class TypeInfo: + id: Identifier + query_type: Optional[QueryType] + syntax: bool = False + skipped: bool = False + negative: bool = False + ns: Union[Type[QT], Type[UT], None] = field(init=False, default=None) + query_property: Optional[URIRef] = field(init=False, default=None) + graph_data_property: Optional[URIRef] = field(init=False, default=None) + expected_outcome_property: Optional[URIRef] = field(init=False, default=None) + + def __post_init__(self) -> None: + if self.query_type is QueryType.QUERY: + self.ns = QT + self.query_property = QT.query + self.graph_data_property = QT.graphData + elif self.query_type is QueryType.UPDATE: + self.ns = UT + self.query_property = UT.request + self.graph_data_property = UT.graphData + self.expected_outcome_property = UT.result + + @classmethod + def make_dict(cls, *test_types: "TypeInfo") -> Dict[Identifier, "TypeInfo"]: + return dict((test_type.id, test_type) for test_type in test_types) + + +type_info_dict = TypeInfo.make_dict( + TypeInfo(MF.CSVResultFormatTest, QueryType.QUERY), + TypeInfo(MF.NegativeSyntaxTest, QueryType.QUERY, syntax=True, negative=True), + TypeInfo(MF.NegativeSyntaxTest11, QueryType.QUERY, syntax=True, negative=True), + TypeInfo(MF.PositiveSyntaxTest, QueryType.QUERY, syntax=True), + TypeInfo(MF.PositiveSyntaxTest11, QueryType.QUERY, syntax=True), + TypeInfo(MF.QueryEvaluationTest, QueryType.QUERY), + TypeInfo(UT.UpdateEvaluationTest, QueryType.UPDATE), + TypeInfo(MF.UpdateEvaluationTest, QueryType.UPDATE), + TypeInfo(MF.PositiveUpdateSyntaxTest11, QueryType.UPDATE, syntax=True), + TypeInfo( + MF.NegativeUpdateSyntaxTest11, QueryType.UPDATE, syntax=True, negative=True + ), + TypeInfo(MF.ServiceDescriptionTest, None, skipped=True), + TypeInfo(MF.ProtocolTest, None, skipped=True), +) + + +@dataclass(frozen=True) +class GraphData: + graph_id: URIRef + label: Optional[Literal] = None + + @classmethod + def from_graph(cls, graph: Graph, identifier: Identifier) -> "GraphData": + if isinstance(identifier, URIRef): + return cls(identifier) + elif isinstance(identifier, BNode): + po_list = list(graph.predicate_objects(identifier)) + assert len(po_list) == 2 + po_dict: Dict[Node, Node] = dict(po_list) + graph_id = po_dict[UT.graph] + assert isinstance(graph_id, URIRef) + label = po_dict[RDFS.label] + assert isinstance(label, Literal) + return cls(graph_id, label) + else: + raise ValueError(f"invalid identifier {identifier!r}") + + def load_into(self, manifest: Manifest, dataset: Dataset) -> None: + graph_local, graph_path = manifest.uri_mapper.to_local(self.graph_id) + graph_text = graph_path.read_text(encoding=ENCODING) + public_id = URIRef(f"{self.label}") if self.label is not None else self.graph_id + logging.debug( + "public_id = %s - graph = %s\n%s", public_id, graph_path, graph_text + ) + dataset.parse( + data=graph_text, publicID=public_id, format=guess_format(graph_path) + ) + + +@dataclass +class SPARQLEntry(ManifestEntry): + type_info: TypeInfo = field(init=False) + query: Optional[IdentifiedNode] = field(init=False, default=None) + action_data: Optional[IdentifiedNode] = field(init=False, default=None) + action_graph_data: Optional[Set[GraphData]] = field(init=False, default=None) + result_data: Optional[IdentifiedNode] = field(init=False, default=None) + result_graph_data: Optional[Set[GraphData]] = field(init=False, default=None) + expected_outcome: Optional[URIRef] = field(init=False, default=None) + + def __post_init__(self) -> None: + super().__post_init__() + self.type_info = type_info_dict[self.type] + + if self.type_info.syntax is True: + assert self.result is None + self.query = self.action + assert isinstance(self.query, URIRef) + return + + if self.type_info.query_type is not None: + assert self.result is not None + self.query = self.graph.value(self.action, self.type_info.query_property) + assert isinstance(self.query, URIRef) + assert self.type_info.ns is not None + self.action_data = self.graph.value(self.action, self.type_info.ns.data) + self.expected_outcome = self.graph.value( + self.action, self.type_info.expected_outcome_property + ) + for action_graph_data_id in self.graph.objects( + self.action, self.type_info.ns.graphData + ): + assert isinstance(action_graph_data_id, IdentifiedNode) + graph_data = GraphData.from_graph(self.graph, action_graph_data_id) + if self.action_graph_data is None: + self.action_graph_data = set() + self.action_graph_data.add(graph_data) + if isinstance(self.result, BNode): + self.result_data = self.graph.value(self.result, self.type_info.ns.data) + else: + self.result_data = self.result + assert isinstance(self.result_data, URIRef) + for result_graph_data_id in self.graph.objects( + self.result, self.type_info.ns.graphData + ): + assert isinstance(result_graph_data_id, IdentifiedNode) + graph_data = GraphData.from_graph(self.graph, result_graph_data_id) + if self.result_graph_data is None: + self.result_graph_data = set() + self.result_graph_data.add(graph_data) + + def load_dataset( + self, data: Optional[IdentifiedNode], graph_data_set: Optional[Set[GraphData]] + ) -> Dataset: + dataset = Dataset() + if data is not None: + data_path = self.uri_mapper.to_local_path(data) + data_text = data_path.read_text(encoding=ENCODING) + logging.debug( + "data (%s) = %s\n%s", + data, + data_path, + data_text, + ) + dataset.default_context.parse( + data=data_text, format=guess_format(data_path) + ) + if graph_data_set is not None: + for graph_data in graph_data_set: + graph_data.load_into(self.manifest, dataset) + return dataset + + def action_dataset(self) -> Dataset: + return self.load_dataset(self.action_data, self.action_graph_data) + + def result_dataset(self) -> Dataset: + return self.load_dataset(self.result_data, self.result_graph_data) + + def query_text(self) -> str: + assert self.query is not None + query_path = self.uri_mapper.to_local_path(self.query) + query_text = query_path.read_text(encoding=ENCODING) + logging.debug("query = %s\n%s", query_path, query_text) + return query_text + + def query_base(self) -> str: + assert self.query is not None + return urljoin(self.query, ".") + + +class ResultFileHelper: + extentions = { + "srx": "xml", + "srj": "json", + "csv": "csv", + "tsv": "tsv", + } + + @classmethod + def load_result(cls, uri_mapper: URIMapper, result_uri: str) -> Tuple[Result, str]: + result_path = uri_mapper.to_local_path(result_uri) + ext = result_path.suffix[1:] + format = cls.extentions.get(ext) + result_text = result_path.read_text(encoding=ENCODING) + logging.debug("result = %s (format=%s)\n%s", result_path, format, result_text) + if format is not None: + with StringIO(result_text) as tio: + result: Result = Result.parse(tio, format=format) + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "result.bindings = \n%s", + pprint.pformat(result.bindings, indent=2, width=80), + ) + return result, format + graph = Graph() + format = guess_format(f"{result_path}") + assert format is not None + graph.parse(data=result_text, format=format, publicID=result_uri) + result = RDFResultParser().parse(graph) + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "result.bindings = \n%s", + pprint.pformat(result.bindings, indent=2, width=80), + ) + return result, format + + +@contextmanager +def ctx_configure_rdflib() -> Generator[None, None, None]: + # Several tests rely on lexical form of literals being kept! + rdflib.NORMALIZE_LITERALS = False + # We need an explicit default graph so tests with local graph references + # work. + rdflib_sparql_module.SPARQL_DEFAULT_GRAPH_UNION = False + # TODO: Add comment explaining why this is being set. + rdflib.DAWG_LITERAL_COLLATION = True + yield + rdflib.NORMALIZE_LITERALS = True + rdflib_sparql_module.SPARQL_DEFAULT_GRAPH_UNION = True + rdflib.DAWG_LITERAL_COLLATION = False + + +def check_syntax(monkeypatch: MonkeyPatch, entry: SPARQLEntry) -> None: + assert entry.query is not None + assert entry.type_info.query_type is not None + query_text = entry.query_text() + catcher: Optional[pytest.ExceptionInfo[Exception]] = None + with ExitStack() as xstack: + if entry.type_info.negative: + catcher = xstack.enter_context(pytest.raises(Exception)) + if entry.type_info.query_type is QueryType.UPDATE: + tree = parseUpdate(query_text) + translateUpdate(tree) + elif entry.type_info.query_type is QueryType.QUERY: + tree = parseQuery(query_text) + translateQuery(tree) + if catcher is not None: + assert catcher.value is not None + logging.info("catcher.value = %s", catcher.value) + + +def check_update(monkeypatch: MonkeyPatch, entry: SPARQLEntry) -> None: + try: + rdflib_sparql_module.SPARQL_LOAD_GRAPHS = False + assert isinstance(entry.action, BNode) + assert isinstance(entry.result, BNode) + assert entry.query is not None + query_text = entry.query_text() + dataset = entry.action_dataset() + query_base = entry.query_base() + logging.debug("query_base=%s", query_base) + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "dataset before = \n%s", + dataset.serialize(format="trig"), + ) + dataset.update(query_text) + + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "dataset after = \n%s", + dataset.serialize(format="trig"), + ) + + expected_result = entry.result_dataset() + + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "expected_result = \n%s", + expected_result.serialize(format="trig"), + ) + + GraphHelper.assert_cgraph_isomorphic( + expected_result, dataset, exclude_bnodes=True + ) + GraphHelper.assert_sets_equals(expected_result, dataset, BNodeHandling.COLLAPSE) + finally: + rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True + + +def patched_query_context_load(uri_mapper: URIMapper) -> Callable[..., Any]: + def _patched_load( + self: QueryContext, source: URIRef, default: bool = False, **kwargs + ) -> None: + public_id = None + use_source: Union[URIRef, Path] = source + format = guess_format(use_source) + if f"{source}".startswith(("https://", "http://")): + use_source = uri_mapper.to_local_path(source) + public_id = source + if default: + assert self.graph is not None + self.graph.parse(use_source, format=format, publicID=public_id) + else: + self.dataset.parse(use_source, format=format, publicID=public_id) + + return _patched_load + + +def check_query(monkeypatch: MonkeyPatch, entry: SPARQLEntry) -> None: + assert entry.query is not None + assert isinstance(entry.result, URIRef) + + monkeypatch.setattr( + QueryContext, "load", patched_query_context_load(entry.uri_mapper) + ) + + query_text = entry.query_text() + dataset = entry.action_dataset() + query_base = entry.query_base() + + logging.debug("query_base=%s", query_base) + result = dataset.query(query_text, base=query_base) + + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "dataset = \n%s", + dataset.serialize(format="trig"), + ) + + logging.debug("result.type = %s", result.type) + expected_result, expected_result_format = ResultFileHelper.load_result( + entry.uri_mapper, entry.result + ) + + assert expected_result.type == result.type + + if result.type == ResultType.SELECT: + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "result.bindings = \n%s", + pprint.pformat(result.bindings, indent=2, width=80), + ) + if expected_result_format == "csv": + with BytesIO() as bio: + result.serialize(bio, format="csv") + bio.seek(0) + logging.debug( + "result.bindings csv = \n%s", + bio.getvalue().decode("utf-8"), + ) + result = Result.parse(bio, format="csv") + assert_bindings_sequences_equal(expected_result.bindings, result.bindings) + elif result.type == ResultType.ASK: + assert expected_result.askAnswer == result.askAnswer + else: + logging.debug( + "expected_result.graph = %s, result.graph = %s\n%s", + expected_result.graph, + result.graph, + result.graph.serialize(format=expected_result_format), + ) + GraphHelper.assert_isomorphic(expected_result.graph, result.graph) + + +SKIP_TYPES = { + MF.ServiceDescriptionTest, + MF.ProtocolTest, +} + + +def check_entry(monkeypatch: MonkeyPatch, entry: SPARQLEntry) -> None: + if logger.isEnabledFor(logging.DEBUG): + logging.debug( + "entry = \n%s", + pprint.pformat(entry, indent=0, width=80), + ) + if entry.type_info.syntax is True: + return check_syntax(monkeypatch, entry) + if entry.type_info.query_type is QueryType.UPDATE: + return check_update(monkeypatch, entry) + elif entry.type_info.query_type is QueryType.QUERY: + return check_query(monkeypatch, entry) + raise ValueError(f"unsupported test {entry.type}") diff --git a/test/utils/test/test_result.py b/test/utils/test/test_result.py new file mode 100644 index 0000000000..6d97a7c6dd --- /dev/null +++ b/test/utils/test/test_result.py @@ -0,0 +1,241 @@ +from contextlib import ExitStack +from test.utils.result import BindingsSequenceType, assert_bindings_sequences_equal +from typing import Type, Union + +import pytest +from pyparsing import Optional + +from rdflib.namespace import XSD +from rdflib.term import BNode, Literal, URIRef, Variable + + +@pytest.mark.parametrize( + ["lhs", "rhs", "expected_result"], + [ + ([], [], True), + ( + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + [], + False, + ), + ( + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + { + Variable("a"): Literal("r2c0"), + Variable("b"): Literal("2", datatype=XSD.decimal), + }, + ], + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + { + Variable("a"): Literal("r2c0"), + Variable("b"): Literal("2.0", datatype=XSD.decimal), + }, + ], + True, + ), + ( + [], + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + False, + ), + ( + [ + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + ], + [ + { + Variable("a"): Literal("r0c0x"), + Variable("b"): URIRef("example:r0c1x"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + False, + ), + ( + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + ], + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + False, + ), + ( + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + [ + { + Variable("a"): Literal("r1c0"), + Variable("b"): URIRef("example:r1c1"), + }, + ], + False, + ), + ( + [ + { + Variable("avg"): Literal( + "1.6", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#decimal"), + ), + Variable("s"): URIRef("http://www.example.org/mixed1"), + }, + { + Variable("avg"): Literal( + "0.2", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#double"), + ), + Variable("s"): URIRef("http://www.example.org/mixed2"), + }, + { + Variable("avg"): Literal( + "2.0", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#decimal"), + ), + Variable("s"): URIRef("http://www.example.org/ints"), + }, + ], + [ + { + Variable("s"): URIRef("http://www.example.org/ints"), + Variable("avg"): Literal( + "2", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#decimal"), + ), + }, + { + Variable("s"): URIRef("http://www.example.org/mixed2"), + Variable("avg"): Literal( + "0.2", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#double"), + ), + }, + { + Variable("s"): URIRef("http://www.example.org/mixed1"), + Variable("avg"): Literal( + "1.6", + datatype=URIRef("http://www.w3.org/2001/XMLSchema#decimal"), + ), + }, + ], + True, + ), + ( + [ + { + Variable("a"): BNode("1"), + }, + ], + [ + { + Variable("a"): BNode("2"), + }, + ], + True, + ), + ( + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): URIRef("example:r0c1"), + }, + ], + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): None, + }, + ], + False, + ), + ( + [ + { + Variable("a"): Literal("r0c0"), + }, + ], + [ + { + Variable("a"): Literal("r0c0"), + Variable("b"): None, + }, + ], + True, + ), + ], +) +def test_bindings_equal( + lhs: BindingsSequenceType, + rhs: BindingsSequenceType, + expected_result: Union[bool, Type[Exception]], +) -> None: + catcher: Optional[pytest.ExceptionInfo[Exception]] = None + + with ExitStack() as xstack: + if isinstance(expected_result, type) and issubclass(expected_result, Exception): + catcher = xstack.enter_context(pytest.raises(expected_result)) + assert_bindings_sequences_equal(lhs, rhs, not expected_result) + if catcher is not None: + assert isinstance(catcher.value, Exception) diff --git a/test_reports/rdflib_sparql-HEAD.ttl b/test_reports/rdflib_sparql-HEAD.ttl new file mode 100644 index 0000000000..f030a1001d --- /dev/null +++ b/test_reports/rdflib_sparql-HEAD.ttl @@ -0,0 +1,241 @@ +@prefix doap: . +@prefix earl: . + + a doap:Project ; + doap:description "RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information."@en ; + doap:homepage ; + doap:name "RDFLib" ; + doap:programming-language "Python" . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + diff --git a/test_reports/rdflib_w3c_sparql10-HEAD.ttl b/test_reports/rdflib_w3c_sparql10-HEAD.ttl new file mode 100644 index 0000000000..0852d69ec3 --- /dev/null +++ b/test_reports/rdflib_w3c_sparql10-HEAD.ttl @@ -0,0 +1,3593 @@ +@prefix doap: . +@prefix earl: . + + a doap:Project ; + doap:description "RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information."@en ; + doap:homepage ; + doap:name "RDFLib" ; + doap:programming-language "Python" . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + diff --git a/test_reports/rdflib_w3c_sparql11-HEAD.ttl b/test_reports/rdflib_w3c_sparql11-HEAD.ttl new file mode 100644 index 0000000000..ad66885f41 --- /dev/null +++ b/test_reports/rdflib_w3c_sparql11-HEAD.ttl @@ -0,0 +1,4385 @@ +@prefix doap: . +@prefix earl: . + + a doap:Project ; + doap:description "RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information."@en ; + doap:homepage ; + doap:name "RDFLib" ; + doap:programming-language "Python" . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:untested ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:failed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . + +[] a earl:Assertion ; + earl:assertedBy ; + earl:mode earl:automatic ; + earl:result [ a earl:TestResult ; + earl:outcome earl:passed ] ; + earl:subject ; + earl:test . +