See also Å''', datatype=RDF.XMLLiteral)))
+ # when:
+ xmlrepr = g.serialize(format='pretty-xml')
+ # then:
+ assert u'''See also Å
'''.encode('utf-8') in xmlrepr
+
+ def test_pretty_broken_xmlliteral(self):
+ # given:
+ g = ConjunctiveGraph()
+ g.add((BNode(), RDF.value, Literal(u'''<p '''.encode('utf-8') in xmlrepr
+
+
+def _assert_expected_object_types_for_predicates(graph, predicates, types):
+ for s, p, o in graph:
+ if p in predicates:
+ someTrue = [isinstance(o, t) for t in types]
+ assert True in someTrue, \
+ "Bad type %s for object when predicate is <%s>." % (type(o), p)
diff --git a/testbed/RDFLib__rdflib/test/test_rdfxml.py b/testbed/RDFLib__rdflib/test/test_rdfxml.py
new file mode 100644
index 0000000000000000000000000000000000000000..94275e72a8027c2253744610727e9d9da9cbf507
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_rdfxml.py
@@ -0,0 +1,266 @@
+from __future__ import print_function
+
+import sys
+from encodings.utf_8 import StreamWriter
+
+import unittest
+
+import os
+import os.path
+
+from six.moves.urllib.request import url2pathname, urlopen
+
+from rdflib import RDF, RDFS, URIRef, BNode, Literal, Namespace, Graph
+from rdflib.exceptions import ParserError
+from rdflib.util import first
+
+
+import logging
+
+_logger = logging.getLogger("parser_rdfcore")
+
+verbose = 0
+
+
+sw = StreamWriter(sys.stdout)
+
+
+def write(msg):
+ _logger.info(msg + "\n")
+ # sw.write(msg+"\n")
+
+
+class TestStore(Graph):
+ __test__ = False
+
+ def __init__(self, expected):
+ super(TestStore, self).__init__()
+ self.expected = expected
+
+ def add(self, spo):
+ (s, p, o) = spo
+ if not isinstance(s, BNode) and not isinstance(o, BNode):
+ if not (s, p, o) in self.expected:
+ m = "Triple not in expected result: %s, %s, %s" % (
+ s.n3(), p.n3(), o.n3())
+ if verbose:
+ write(m)
+ # raise Exception(m)
+ super(TestStore, self).add((s, p, o))
+
+
+TEST = Namespace("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#")
+
+CACHE_DIR = os.path.join(os.path.dirname(__file__), "rdf")
+
+skipped = (
+ # "datatypes/Manifest.rdf#test002",
+ # "rdf-containers-syntax-vs-schema/Manifest.rdf#test004",
+ # "rdfms-xml-literal-namespaces/Manifest.rdf#test001",
+ # "rdfms-xml-literal-namespaces/Manifest.rdf#test002",
+ # "rdfms-xmllang/Manifest.rdf#test001",
+ # "rdfms-xmllang/Manifest.rdf#test002",
+ # "xml-canon/Manifest.rdf#test001"
+)
+
+
+def cached_file(url):
+ fname = url2pathname(relative(url))
+
+ fpath = os.path.join(CACHE_DIR, fname)
+ if not os.path.exists(fpath):
+ print("%s does not exist, fetching from %s" % (fpath, url))
+ folder = os.path.dirname(fpath)
+ if not os.path.exists(folder):
+ os.makedirs(folder)
+ f = open(fpath, 'w')
+ try:
+ f.write(urlopen(url).read())
+ finally:
+ f.close()
+ return fpath
+
+
+RDFCOREBASE = "http://www.w3.org/2000/10/rdf-tests/rdfcore/"
+
+
+def relative(url):
+ return url[len(RDFCOREBASE):]
+
+
+def resolve(rel):
+ return RDFCOREBASE + rel
+
+
+def _testPositive(uri, manifest):
+ if verbose:
+ write(u"TESTING: %s" % uri)
+ result = 0 # 1=failed, 0=passed
+ inDoc = first(manifest.objects(uri, TEST["inputDocument"]))
+ outDoc = first(manifest.objects(uri, TEST["outputDocument"]))
+ expected = Graph()
+ if outDoc[-3:] == ".nt":
+ format = "nt"
+ else:
+ format = "xml"
+ expected.parse(cached_file(outDoc), publicID=outDoc, format=format)
+ store = TestStore(expected)
+ if inDoc[-3:] == ".nt":
+ format = "nt"
+ else:
+ format = "xml"
+
+ try:
+ store.parse(cached_file(inDoc), publicID=inDoc, format=format)
+ except ParserError as pe:
+ write("Failed '")
+ write(inDoc)
+ write("' failed with")
+ raise pe
+ try:
+ write(type(pe))
+ except:
+ write("sorry could not dump out error.")
+ result = 1
+ else:
+ if not store.isomorphic(expected):
+ write(u"""Failed: '%s'""" % uri)
+ if verbose:
+ write(""" In:\n""")
+ for s, p, o in store:
+ write("%s %s %s." % (repr(s), repr(p), repr(o)))
+ write(""" Out:\n""")
+ for s, p, o in expected:
+ write("%s %s %s." % (repr(s), repr(p), repr(o)))
+ result += 1
+ return result
+
+
+def _testNegative(uri, manifest):
+ if verbose:
+ write(u"TESTING: %s" % uri)
+ result = 0 # 1=failed, 0=passed
+ inDoc = first(manifest.objects(uri, TEST["inputDocument"]))
+ store = Graph()
+
+ test = BNode()
+ results.add((test, RESULT["test"], uri))
+ results.add((test, RESULT["system"], system))
+
+ try:
+ if inDoc[-3:] == ".nt":
+ format = "nt"
+ else:
+ format = "xml"
+ store.parse(cached_file(inDoc), publicID=inDoc, format=format)
+ except ParserError:
+ results.add((test, RDF.type, RESULT["PassingRun"]))
+ # pass
+ else:
+ write(u"""Failed: '%s'""" % uri)
+ results.add((test, RDF.type, RESULT["FailingRun"]))
+ result = 1
+ return result
+
+
+class ParserTestCase(unittest.TestCase):
+ store = 'default'
+ path = 'store'
+ slow = True
+
+ def setUp(self):
+ self.manifest = manifest = Graph(store=self.store)
+ manifest.open(self.path)
+ manifest.load(cached_file(
+ "http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf"))
+
+ def tearDown(self):
+ self.manifest.close()
+
+ def testNegative(self):
+ manifest = self.manifest
+ num_failed = total = 0
+ negs = list(manifest.subjects(RDF.type, TEST["NegativeParserTest"]))
+ negs.sort()
+ for neg in negs:
+ status = first(manifest.objects(neg, TEST["status"]))
+ if status == Literal("APPROVED"):
+ result = _testNegative(neg, manifest)
+ total += 1
+ num_failed += result
+ self.assertEqual(
+ num_failed, 0, "Failed: %s of %s." % (num_failed, total))
+
+ def testPositive(self):
+ manifest = self.manifest
+ uris = list(manifest.subjects(RDF.type, TEST["PositiveParserTest"]))
+ uris.sort()
+ num_failed = total = 0
+ for uri in uris:
+ status = first(manifest.objects(uri, TEST["status"]))
+ # Failing tests, skipped
+ if uri[44:] in skipped:
+ status = Literal("Locally DISAPPROVED")
+ write("Skipping %s" % uri)
+ if status == Literal("APPROVED"):
+ result = _testPositive(uri, manifest)
+ test = BNode()
+ results.add((test, RESULT["test"], uri))
+ results.add((test, RESULT["system"], system))
+ if not result:
+ results.add((test, RDF.type, RESULT["PassingRun"]))
+ else:
+ results.add((test, RDF.type, RESULT["FailingRun"]))
+ total += 1
+ num_failed += result
+ self.assertEqual(
+ num_failed, 0, "Failed: %s of %s." % (num_failed, total))
+
+
+RESULT = Namespace("http://www.w3.org/2002/03owlt/resultsOntology#")
+FOAF = Namespace("http://xmlns.com/foaf/0.1/")
+
+
+results = Graph()
+
+system = BNode("system")
+results.add((system, FOAF["homepage"], URIRef("http://rdflib.net/")))
+results.add((system, RDFS.label, Literal("RDFLib")))
+results.add((system, RDFS.comment, Literal("")))
+
+
+if __name__ == "__main__":
+ manifest = Graph()
+ manifest.load(cached_file(
+ "http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf"))
+ import sys
+ import getopt
+ try:
+ optlist, args = getopt.getopt(sys.argv[1:], 'h:', ["help"])
+ except getopt.GetoptError as msg:
+ write(msg)
+ # usage()
+
+ try:
+ argv = sys.argv
+ if len(argv) > 1:
+ _logger.setLevel(logging.INFO)
+ _logger.addHandler(logging.StreamHandler())
+
+ for arg in argv[1:]:
+ verbose = 1
+ case = URIRef(arg)
+ write(u"Testing: %s" % case)
+ if (case, RDF.type, TEST["PositiveParserTest"]) in manifest:
+ result = _testPositive(case, manifest)
+ write(u"Positive test %s" % ["PASSED", "FAILED"][result])
+ elif (case, RDF.type, TEST["NegativeParserTest"]) in manifest:
+ result = _testNegative(case, manifest)
+ write(u"Negative test %s" % ["PASSED", "FAILED"][result])
+ else:
+ write(u"%s not ??" % case)
+
+ if len(argv) <= 1:
+ unittest.main()
+ finally:
+ results.serialize("results.rdf")
diff --git a/testbed/RDFLib__rdflib/test/test_roundtrip.py b/testbed/RDFLib__rdflib/test/test_roundtrip.py
new file mode 100644
index 0000000000000000000000000000000000000000..819c944a9d50828fbdbb3073300da3589f808ef8
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_roundtrip.py
@@ -0,0 +1,101 @@
+import sys
+import rdflib
+import rdflib.compare
+
+try:
+ from .test_nt_suite import all_nt_files
+ assert all_nt_files
+except:
+ from test.test_nt_suite import all_nt_files
+
+"""
+Test round-tripping by all serializers/parser that are registerd.
+This means, you may test more than just core rdflib!
+
+run with no arguments to test all formats + all files
+run with a single argument, to test only that format, i.e. "n3"
+run with three arguments to test round-tripping in a given format
+and reading a single file in the given format, i.e.:
+
+python test/test_roundtrip.py xml nt test/nt/literals-02.nt
+
+tests roundtripping through rdf/xml with only the literals-02 file
+
+"""
+
+
+SKIP = [
+ ('xml', 'test/nt/qname-02.nt'), # uses a property that cannot be qname'd
+ # uses a property that cannot be qname'd
+ ('application/rdf+xml', 'test/nt/qname-02.nt'),
+]
+
+
+def roundtrip(e, verbose=False):
+ infmt, testfmt, source = e
+
+ g1 = rdflib.ConjunctiveGraph()
+
+ g1.parse(source, format=infmt)
+
+ s = g1.serialize(format=testfmt)
+
+ if verbose:
+ print("S:")
+ print(s)
+
+ g2 = rdflib.ConjunctiveGraph()
+ g2.parse(data=s, format=testfmt)
+
+ if verbose:
+ both, first, second = rdflib.compare.graph_diff(g1, g2)
+ print("Diff:")
+ print("%d triples in both" % len(both))
+ print("G1 Only:")
+ for t in first:
+ print(t)
+
+ print("--------------------")
+ print("G2 Only")
+ for t in second:
+ print(t)
+
+ assert rdflib.compare.isomorphic(g1, g2)
+
+ if verbose:
+ print("Ok!")
+
+
+formats = None
+
+
+def test_cases():
+ global formats
+ if not formats:
+ serializers = set(
+ x.name for x in rdflib.plugin.plugins(
+ None, rdflib.plugin.Serializer))
+ parsers = set(
+ x.name for x in rdflib.plugin.plugins(
+ None, rdflib.plugin.Parser))
+ formats = parsers.intersection(serializers)
+
+ for testfmt in formats:
+ if "/" in testfmt:
+ continue # skip double testing
+ for f, infmt in all_nt_files():
+ if (testfmt, f) not in SKIP:
+ yield roundtrip, (infmt, testfmt, f)
+
+
+if __name__ == "__main__":
+ import nose
+ if len(sys.argv) == 1:
+ nose.main(defaultTest=sys.argv[0])
+ elif len(sys.argv) == 2:
+ import test.test_roundtrip
+ test.test_roundtrip.formats = [sys.argv[1]]
+ nose.main(defaultTest=sys.argv[0], argv=sys.argv[:1])
+ else:
+ roundtrip(
+ (sys.argv[2], sys.argv[1], sys.argv[3]), verbose=True)
diff --git a/testbed/RDFLib__rdflib/test/test_serializexml.py b/testbed/RDFLib__rdflib/test/test_serializexml.py
new file mode 100644
index 0000000000000000000000000000000000000000..0dfa5e69d1f6f181997784f0b9287c2668ca2eaf
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_serializexml.py
@@ -0,0 +1,158 @@
+from rdflib.term import URIRef, BNode
+from rdflib.namespace import RDFS
+from six import b, BytesIO
+
+from rdflib.plugins.serializers.rdfxml import XMLSerializer
+
+from rdflib.graph import ConjunctiveGraph
+
+
+class SerializerTestBase(object):
+
+ repeats = 8
+
+ def setup(self):
+ graph = ConjunctiveGraph()
+ graph.parse(data=self.testContent, format=self.testContentFormat)
+ self.sourceGraph = graph
+
+ def test_serialize_and_reparse(self):
+ reparsedGraph = serialize_and_load(self.sourceGraph, self.serializer)
+ _assert_equal_graphs(self.sourceGraph, reparsedGraph)
+
+ def test_multiple(self):
+ """Repeats ``test_serialize`` ``self.repeats`` times, to reduce sucess based on in-memory ordering."""
+ for i in range(self.repeats):
+ self.test_serialize_and_reparse()
+
+ # test_multiple.slowtest=True # not really slow?
+
+
+def _assert_equal_graphs(g1, g2):
+ assert len(g1) == len(g2), "Serialized graph not same size as source graph."
+ g1copy = _mangled_copy(g1)
+ g2copy = _mangled_copy(g2)
+ g1copy -= _mangled_copy(g2)
+ g2copy -= _mangled_copy(g1)
+ assert len(g1copy) == 0, "Source graph larger than serialized graph."
+ assert len(g2copy) == 0, "Serialized graph larger than source graph."
+
+
+_blank = BNode()
+
+
+def _mangled_copy(g):
+ "Makes a copy of the graph, replacing all bnodes with the bnode ``_blank``."
+ gcopy = ConjunctiveGraph()
+
+ def isbnode(v): return isinstance(v, BNode)
+ for s, p, o in g:
+ if isbnode(s):
+ s = _blank
+ if isbnode(p):
+ p = _blank
+ if isbnode(o):
+ o = _blank
+ gcopy.add((s, p, o))
+ return gcopy
+
+
+def serialize(sourceGraph, makeSerializer, getValue=True, extra_args={}):
+ serializer = makeSerializer(sourceGraph)
+ stream = BytesIO()
+ serializer.serialize(stream, **extra_args)
+ return getValue and stream.getvalue() or stream
+
+
+def serialize_and_load(sourceGraph, makeSerializer):
+ stream = serialize(sourceGraph, makeSerializer, False)
+ stream.seek(0)
+ reparsedGraph = ConjunctiveGraph()
+ reparsedGraph.load(stream)
+ return reparsedGraph
+
+
+class TestXMLSerializer(SerializerTestBase):
+
+ serializer = XMLSerializer
+
+ testContent = """
+ @prefix rdfs: .
+ @prefix owl: .
+ @prefix : .
+
+ :value rdfs:domain :Test .
+
+ :Test rdfs:subClassOf
+ [ a owl:Restriction;
+ owl:onProperty :value ],
+ [ a owl:Restriction;
+ owl:onProperty :name ] .
+
+ a :Test;
+ rdfs:seeAlso ;
+ :value "A" .
+
+
+ :name "Bee"@en, "Be"@sv;
+ :value "B" .
+
+ a rdfs:Resource;
+ rdfs:seeAlso ;
+ :value 3 .
+
+ a rdfs:Resource;
+ rdfs:seeAlso ;
+ rdfs:seeAlso ;
+ rdfs:seeAlso .
+
+ _:bnode1 a :BNode;
+ rdfs:seeAlso _:bnode2 .
+
+ _:bnode2 a :BNode ;
+ rdfs:seeAlso _:bnode3 .
+
+ _:bnode3 a :BNode ;
+ rdfs:seeAlso _:bnode2 .
+
+ """
+ testContentFormat = 'n3'
+
+ def test_result_fragments(self):
+ rdfXml = serialize(self.sourceGraph, self.serializer)
+ # print "--------"
+ # print rdfXml
+ # print "--------"
+ assert b('') in rdfXml
+ assert b('') in rdfXml
+ assert b('') in rdfXml
+ assert b('Bee') in rdfXml
+ assert b('3') in rdfXml
+ assert b('') in rdfXml
+ assert b('') in rdfXml
+ assert b('') in rdfXml
+ assert b('3') in rdfXml
+ assert b('." % (type(o), p)
diff --git a/testbed/RDFLib__rdflib/test/test_slice.py b/testbed/RDFLib__rdflib/test/test_slice.py
new file mode 100644
index 0000000000000000000000000000000000000000..27e6e49a3789910391310d699839ce32b239d166
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_slice.py
@@ -0,0 +1,81 @@
+
+from rdflib import Graph, URIRef
+import unittest
+
+
+class GraphSlice(unittest.TestCase):
+
+ def testSlice(self):
+ """
+ We pervert the slice object,
+ and use start, stop, step as subject, predicate, object
+
+ all operations return generators over full triples
+ """
+
+ def sl(x, y): return self.assertEqual(len(list(x)), y)
+
+ def soe(x, y): return self.assertEqual(
+ set([a[2] for a in x]), set(y)) # equals objects
+ g = self.graph
+
+ # Single terms are all trivial:
+
+ # single index slices by subject, i.e. return triples((x,None,None))
+ # tell me everything about "tarek"
+ sl(g[self.tarek], 2)
+
+ # single slice slices by s,p,o, with : used to split
+ # tell me everything about "tarek" (same as above)
+ sl(g[self.tarek::], 2)
+
+ # give me every "likes" relationship
+ sl(g[:self.likes:], 5)
+
+ # give me every relationship to pizza
+ sl(g[::self.pizza], 3)
+
+ # give me everyone who likes pizza
+ sl(g[:self.likes:self.pizza], 2)
+
+ # does tarek like pizza?
+ self.assertTrue(g[self.tarek:self.likes:self.pizza])
+
+ # More intesting is using paths
+
+ # everything hated or liked
+ sl(g[:self.hates | self.likes], 7)
+
+ def setUp(self):
+ self.graph = Graph()
+
+ self.michel = URIRef(u'michel')
+ self.tarek = URIRef(u'tarek')
+ self.bob = URIRef(u'bob')
+ self.likes = URIRef(u'likes')
+ self.hates = URIRef(u'hates')
+ self.pizza = URIRef(u'pizza')
+ self.cheese = URIRef(u'cheese')
+
+ self.addStuff()
+
+ def addStuff(self):
+ tarek = self.tarek
+ michel = self.michel
+ bob = self.bob
+ likes = self.likes
+ hates = self.hates
+ pizza = self.pizza
+ cheese = self.cheese
+
+ self.graph.add((tarek, likes, pizza))
+ self.graph.add((tarek, likes, cheese))
+ self.graph.add((michel, likes, pizza))
+ self.graph.add((michel, likes, cheese))
+ self.graph.add((bob, likes, cheese))
+ self.graph.add((bob, hates, pizza))
+ self.graph.add((bob, hates, michel)) # gasp!
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_sparql.py b/testbed/RDFLib__rdflib/test/test_sparql.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3f289fc010f73d2c7d2961e013ac7ccc1274918
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_sparql.py
@@ -0,0 +1,113 @@
+from rdflib import Graph, URIRef, Literal, BNode
+from rdflib.plugins.sparql import prepareQuery
+from rdflib.compare import isomorphic
+
+from nose.tools import eq_
+
+
+def test_graph_prefix():
+ """
+ This is issue https://github.com/RDFLib/rdflib/issues/313
+ """
+
+ g1 = Graph()
+ g1.parse(data="""
+ @prefix : .
+ :foo 42.
+ """, format="n3")
+
+ g2 = Graph()
+ g2.parse(data="""
+ @prefix : .
+ 42.
+ """, format="n3")
+
+ assert isomorphic(g1, g2)
+
+ q_str = ("""
+ PREFIX :
+ SELECT ?val
+ WHERE { :foo ?p ?val }
+ """)
+ q_prepared = prepareQuery(q_str)
+
+ expected = [(Literal(42),)]
+
+ eq_(list(g1.query(q_prepared)), expected)
+ eq_(list(g2.query(q_prepared)), expected)
+
+ eq_(list(g1.query(q_str)), expected)
+ eq_(list(g2.query(q_str)), expected)
+
+
+def test_variable_order():
+
+ g = Graph()
+ g.add((URIRef("http://foo"), URIRef("http://bar"), URIRef("http://baz")))
+ res = g.query("SELECT (42 AS ?a) ?b { ?b ?c ?d }")
+
+ row = list(res)[0]
+ print(row)
+ assert len(row) == 2
+ assert row[0] == Literal(42)
+ assert row[1] == URIRef("http://foo")
+
+
+def test_sparql_bnodelist():
+ """
+
+ syntax tests for a few corner-cases not touched by the
+ official tests.
+
+ """
+
+ prepareQuery('select * where { ?s ?p ( [] ) . }')
+ prepareQuery('select * where { ?s ?p ( [ ?p2 ?o2 ] ) . }')
+ prepareQuery('select * where { ?s ?p ( [ ?p2 ?o2 ] [] ) . }')
+ prepareQuery('select * where { ?s ?p ( [] [ ?p2 ?o2 ] [] ) . }')
+
+
+def test_complex_sparql_construct():
+
+ g = Graph()
+ q = '''select ?subject ?study ?id where {
+ ?s a ;
+ ?c;
+ ?mother, ?father;
+ [ a ; ?id].
+ }'''
+ g.query(q)
+
+
+def test_sparql_update_with_bnode():
+ """
+ Test if the blank node is inserted correctly.
+ """
+ graph = Graph()
+ graph.update(
+ "INSERT DATA { _:blankA }")
+ for t in graph.triples((None, None, None)):
+ assert isinstance(t[0], BNode)
+ eq_(t[1].n3(), "")
+ eq_(t[2].n3(), "")
+
+
+def test_sparql_update_with_bnode_serialize_parse():
+ """
+ Test if the blank node is inserted correctly, can be serialized and parsed.
+ """
+ graph = Graph()
+ graph.update(
+ "INSERT DATA { _:blankA }")
+ string = graph.serialize(format='ntriples').decode('utf-8')
+ raised = False
+ try:
+ Graph().parse(data=string, format="ntriples")
+ except Exception as e:
+ raised = True
+ assert not raised
+
+
+if __name__ == '__main__':
+ import nose
+ nose.main(defaultTest=__name__)
diff --git a/testbed/RDFLib__rdflib/test/test_sparql_agg_distinct.py b/testbed/RDFLib__rdflib/test/test_sparql_agg_distinct.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ab0f58af01abe2f69023ad04a4e01444353924f
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_sparql_agg_distinct.py
@@ -0,0 +1,108 @@
+from rdflib import Graph
+
+query_tpl = '''
+SELECT ?x (MIN(?y_) as ?y) (%s(DISTINCT ?z_) as ?z) {
+ VALUES (?x ?y_ ?z_) {
+ ("x1" 10 1)
+ ("x1" 11 1)
+ ("x2" 20 2)
+ }
+} GROUP BY ?x ORDER BY ?x
+'''
+
+
+def test_group_concat_distinct():
+ g = Graph()
+ results = g.query(query_tpl % 'GROUP_CONCAT')
+ results = [[lit.toPython() for lit in line] for line in results]
+
+ # this is the tricky part
+ assert results[0][2] == "1", results[0][2]
+
+ # still check the whole result, to be on the safe side
+ assert results == [
+ ["x1", 10, "1"],
+ ["x2", 20, "2"],
+ ], results
+
+
+def test_sum_distinct():
+ g = Graph()
+ results = g.query(query_tpl % 'SUM')
+ results = [[lit.toPython() for lit in line] for line in results]
+
+ # this is the tricky part
+ assert results[0][2] == 1, results[0][2]
+
+ # still check the whole result, to be on the safe side
+ assert results == [
+ ["x1", 10, 1],
+ ["x2", 20, 2],
+ ], results
+
+
+def test_avg_distinct():
+ g = Graph()
+ results = g.query("""
+ SELECT ?x (MIN(?y_) as ?y) (AVG(DISTINCT ?z_) as ?z) {
+ VALUES (?x ?y_ ?z_) {
+ ("x1" 10 1)
+ ("x1" 11 1)
+ ("x1" 12 3)
+ ("x2" 20 2)
+ }
+ } GROUP BY ?x ORDER BY ?x
+ """)
+ results = [[lit.toPython() for lit in line] for line in results]
+
+ # this is the tricky part
+ assert results[0][2] == 2, results[0][2]
+
+ # still check the whole result, to be on the safe side
+ assert results == [
+ ["x1", 10, 2],
+ ["x2", 20, 2],
+ ], results
+
+
+def test_count_distinct():
+ g = Graph()
+
+ g.parse(format="turtle", publicID="http://example.org/", data="""
+ @prefix : <> .
+
+ <#a>
+ :knows <#b>, <#c> ;
+ :age 42 .
+
+ <#b>
+ :knows <#a>, <#c> ;
+ :age 36 .
+
+ <#c>
+ :knows <#b>, <#c> ;
+ :age 20 .
+
+ """)
+
+ # Query 1: people knowing someone younger
+ results = g.query("""
+ PREFIX :
+
+ SELECT DISTINCT ?x {
+ ?x :age ?ax ; :knows [ :age ?ay ].
+ FILTER( ?ax > ?ay )
+ }
+ """)
+ assert len(results) == 2
+
+ # nQuery 2: count people knowing someone younger
+ results = g.query("""
+ PREFIX :
+
+ SELECT (COUNT(DISTINCT ?x) as ?cx) {
+ ?x :age ?ax ; :knows [ :age ?ay ].
+ FILTER( ?ax > ?ay )
+ }
+ """)
+ assert list(results)[0][0].toPython() == 2
diff --git a/testbed/RDFLib__rdflib/test/test_sparqlstore.py b/testbed/RDFLib__rdflib/test/test_sparqlstore.py
new file mode 100644
index 0000000000000000000000000000000000000000..26a694603b5ea419a13aa29fd26b2d74dca1245d
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_sparqlstore.py
@@ -0,0 +1,71 @@
+from rdflib import Graph, URIRef, Literal
+from six.moves.urllib.request import urlopen
+import os
+import unittest
+from nose import SkipTest
+from requests import HTTPError
+
+
+try:
+ assert len(urlopen("http://dbpedia.org/sparql").read()) > 0
+except:
+ raise SkipTest("No HTTP connection.")
+
+
+class SPARQLStoreDBPediaTestCase(unittest.TestCase):
+ store_name = 'SPARQLStore'
+ path = "http://dbpedia.org/sparql"
+ storetest = True
+ create = False
+
+ def setUp(self):
+ self.graph = Graph(store="SPARQLStore")
+ self.graph.open(self.path, create=self.create)
+ ns = list(self.graph.namespaces())
+ assert len(ns) > 0, ns
+
+ def tearDown(self):
+ self.graph.close()
+
+ def test_Query(self):
+ query = "select distinct ?Concept where {[] a ?Concept} LIMIT 1"
+ res = self.graph.query(query, initNs={})
+ for i in res:
+ assert type(i[0]) == URIRef, i[0].n3()
+
+ def test_initNs(self):
+ query = """\
+ SELECT ?label WHERE
+ { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
+ """
+ res = self.graph.query(
+ query,
+ initNs={"xyzzy": "http://www.w3.org/2004/02/skos/core#"})
+ for i in res:
+ assert type(i[0]) == Literal, i[0].n3()
+
+ def test_noinitNs(self):
+ query = """\
+ SELECT ?label WHERE
+ { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
+ """
+ self.assertRaises(
+ HTTPError,
+ self.graph.query,
+ query)
+
+ def test_query_with_added_prolog(self):
+ prologue = """\
+ PREFIX xyzzy:
+ """
+ query = """\
+ SELECT ?label WHERE
+ { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
+ """
+ res = self.graph.query(prologue + query)
+ for i in res:
+ assert type(i[0]) == Literal, i[0].n3()
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_sparqlupdatestore.py b/testbed/RDFLib__rdflib/test/test_sparqlupdatestore.py
new file mode 100644
index 0000000000000000000000000000000000000000..161ed6a079ea38844546196333957b81fc80b980
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_sparqlupdatestore.py
@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from nose import SkipTest
+
+import unittest
+import re
+
+from rdflib import ConjunctiveGraph, URIRef, Literal, BNode, Graph
+from six import text_type
+from six.moves.urllib.request import urlopen
+
+HOST = 'http://localhost:3031'
+DB = '/db/'
+
+# this assumes SPARQL1.1 query/update endpoints running locally at
+# http://localhost:3031/db/
+#
+# The ConjunctiveGraph tests below require that the SPARQL endpoint renders its
+# default graph as the union of all known graphs! This is incompatible with the
+# endpoint behavior required by our Dataset tests in test_dataset.py, so you
+# need to run a second SPARQL endpoint on a non standard port,
+# e.g. fuseki started with:
+# ./fuseki-server --port 3031 --memTDB --update --set tdb:unionDefaultGraph=true /db
+
+# THIS WILL DELETE ALL DATA IN THE /db dataset
+
+michel = URIRef(u'urn:michel')
+tarek = URIRef(u'urn:tarek')
+bob = URIRef(u'urn:bob')
+likes = URIRef(u'urn:likes')
+hates = URIRef(u'urn:hates')
+pizza = URIRef(u'urn:pizza')
+cheese = URIRef(u'urn:cheese')
+
+graphuri = URIRef('urn:graph')
+othergraphuri = URIRef('urn:othergraph')
+
+
+class TestSparql11(unittest.TestCase):
+
+ def setUp(self):
+ self.longMessage = True
+ self.graph = ConjunctiveGraph('SPARQLUpdateStore')
+
+ root = HOST + DB
+ self.graph.open((root + "sparql", root + "update"))
+
+ # clean out the store
+ for c in self.graph.contexts():
+ c.remove((None, None, None))
+ assert len(c) == 0
+
+ def tearDown(self):
+ self.graph.close()
+
+ def testSimpleGraph(self):
+ g = self.graph.get_context(graphuri)
+ g.add((tarek, likes, pizza))
+ g.add((bob, likes, pizza))
+ g.add((bob, likes, cheese))
+
+ g2 = self.graph.get_context(othergraphuri)
+ g2.add((michel, likes, pizza))
+
+ self.assertEqual(3, len(g), 'graph contains 3 triples')
+ self.assertEqual(1, len(g2), 'other graph contains 1 triple')
+
+ r = g.query("SELECT * WHERE { ?s . }")
+ self.assertEqual(2, len(list(r)), "two people like pizza")
+
+ r = g.triples((None, likes, pizza))
+ self.assertEqual(2, len(list(r)), "two people like pizza")
+
+ # Test initBindings
+ r = g.query("SELECT * WHERE { ?s . }",
+ initBindings={'s': tarek})
+ self.assertEqual(1, len(list(r)), "i was asking only about tarek")
+
+ r = g.triples((tarek, likes, pizza))
+ self.assertEqual(1, len(list(r)), "i was asking only about tarek")
+
+ r = g.triples((tarek, likes, cheese))
+ self.assertEqual(0, len(list(r)), "tarek doesn't like cheese")
+
+ g2.add((tarek, likes, pizza))
+ g.remove((tarek, likes, pizza))
+ r = g.query("SELECT * WHERE { ?s . }")
+ self.assertEqual(1, len(list(r)), "only bob likes pizza")
+
+ def testConjunctiveDefault(self):
+ g = self.graph.get_context(graphuri)
+ g.add((tarek, likes, pizza))
+ g2 = self.graph.get_context(othergraphuri)
+ g2.add((bob, likes, pizza))
+ g.add((tarek, hates, cheese))
+
+ self.assertEqual(2, len(g), 'graph contains 2 triples')
+
+ # the following are actually bad tests as they depend on your endpoint,
+ # as pointed out in the sparqlstore.py code:
+ #
+ # For ConjunctiveGraphs, reading is done from the "default graph" Exactly
+ # what this means depends on your endpoint, because SPARQL does not offer a
+ # simple way to query the union of all graphs as it would be expected for a
+ # ConjuntiveGraph.
+ ##
+ # Fuseki/TDB has a flag for specifying that the default graph
+ # is the union of all graphs (tdb:unionDefaultGraph in the Fuseki config).
+ self.assertEqual(3, len(self.graph),
+ 'default union graph should contain three triples but contains:\n'
+ '%s' % list(self.graph))
+
+ r = self.graph.query("SELECT * WHERE { ?s . }")
+ self.assertEqual(2, len(list(r)), "two people like pizza")
+
+ r = self.graph.query("SELECT * WHERE { ?s . }",
+ initBindings={'s': tarek})
+ self.assertEqual(1, len(list(r)), "i was asking only about tarek")
+
+ r = self.graph.triples((tarek, likes, pizza))
+ self.assertEqual(1, len(list(r)), "i was asking only about tarek")
+
+ r = self.graph.triples((tarek, likes, cheese))
+ self.assertEqual(0, len(list(r)), "tarek doesn't like cheese")
+
+ g2.remove((bob, likes, pizza))
+
+ r = self.graph.query("SELECT * WHERE { ?s . }")
+ self.assertEqual(1, len(list(r)), "only tarek likes pizza")
+
+ def testUpdate(self):
+ self.graph.update("INSERT DATA { GRAPH { . } }")
+
+ g = self.graph.get_context(graphuri)
+ self.assertEqual(1, len(g), 'graph contains 1 triples')
+
+ def testUpdateWithInitNs(self):
+ self.graph.update(
+ "INSERT DATA { GRAPH ns:graph { ns:michel ns:likes ns:pizza . } }",
+ initNs={'ns': URIRef('urn:')}
+ )
+
+ g = self.graph.get_context(graphuri)
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(michel, likes, pizza)]),
+ 'only michel likes pizza'
+ )
+
+ def testUpdateWithInitBindings(self):
+ self.graph.update(
+ "INSERT { GRAPH { ?a ?b ?c . } } WherE { }",
+ initBindings={
+ 'a': URIRef('urn:michel'),
+ 'b': URIRef('urn:likes'),
+ 'c': URIRef('urn:pizza'),
+ }
+ )
+
+ g = self.graph.get_context(graphuri)
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(michel, likes, pizza)]),
+ 'only michel likes pizza'
+ )
+
+ def testUpdateWithBlankNode(self):
+ self.graph.update(
+ "INSERT DATA { GRAPH { _:blankA } }")
+ g = self.graph.get_context(graphuri)
+ for t in g.triples((None, None, None)):
+ self.assertTrue(isinstance(t[0], BNode))
+ self.assertEqual(t[1].n3(), "")
+ self.assertEqual(t[2].n3(), "")
+
+ def testUpdateWithBlankNodeSerializeAndParse(self):
+ self.graph.update(
+ "INSERT DATA { GRAPH { _:blankA } }")
+ g = self.graph.get_context(graphuri)
+ string = g.serialize(format='ntriples').decode('utf-8')
+ raised = False
+ try:
+ Graph().parse(data=string, format="ntriples")
+ except Exception as e:
+ raised = True
+ self.assertFalse(raised, 'Exception raised when parsing: ' + string)
+
+ def testMultipleUpdateWithInitBindings(self):
+ self.graph.update(
+ "INSERT { GRAPH { ?a ?b ?c . } } WHERE { };"
+ "INSERT { GRAPH { ?d ?b ?c . } } WHERE { }",
+ initBindings={
+ 'a': URIRef('urn:michel'),
+ 'b': URIRef('urn:likes'),
+ 'c': URIRef('urn:pizza'),
+ 'd': URIRef('urn:bob'),
+ }
+ )
+
+ g = self.graph.get_context(graphuri)
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(michel, likes, pizza), (bob, likes, pizza)]),
+ 'michel and bob like pizza'
+ )
+
+ def testNamedGraphUpdate(self):
+ g = self.graph.get_context(graphuri)
+ r1 = "INSERT DATA { }"
+ g.update(r1)
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(michel, likes, pizza)]),
+ 'only michel likes pizza'
+ )
+
+ r2 = "DELETE { } " + \
+ "INSERT { } WHERE {}"
+ g.update(r2)
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(bob, likes, pizza)]),
+ 'only bob likes pizza'
+ )
+ says = URIRef("urn:says")
+
+ # Strings with unbalanced curly braces
+ tricky_strs = ["With an unbalanced curly brace %s " % brace
+ for brace in ["{", "}"]]
+ for tricky_str in tricky_strs:
+ r3 = """INSERT { ?b "%s" }
+ WHERE { ?b } """ % tricky_str
+ g.update(r3)
+
+ values = set()
+ for v in g.objects(bob, says):
+ values.add(str(v))
+ self.assertEqual(values, set(tricky_strs))
+
+ # Complicated Strings
+ r4strings = []
+ r4strings.append(r'''"1: adfk { ' \\\" \" { "''')
+ r4strings.append(r'''"2: adfk } #éï \\"''')
+
+ r4strings.append(r"""'3: adfk { " \\\' \' { '""")
+ r4strings.append(r"""'4: adfk } #éï \\'""")
+
+ r4strings.append(r'''"""5: adfk { ' \\\" \" { """''')
+ r4strings.append(r'''"""6: adfk } #éï \\"""''')
+ r4strings.append('"""7: ad adsfj \n { \n sadfj"""')
+
+ r4strings.append(r"""'''8: adfk { " \\\' \' { '''""")
+ r4strings.append(r"""'''9: adfk } #éï \\'''""")
+ r4strings.append("'''10: ad adsfj \n { \n sadfj'''")
+
+ r4 = "\n".join([
+ u'INSERT DATA { %s } ;' % s
+ for s in r4strings
+ ])
+ g.update(r4)
+ values = set()
+ for v in g.objects(michel, says):
+ values.add(text_type(v))
+ self.assertEqual(values, set([re.sub(r"\\(.)", r"\1", re.sub(
+ r"^'''|'''$|^'|'$|" + r'^"""|"""$|^"|"$', r"", s)) for s in r4strings]))
+
+ # IRI Containing ' or #
+ # The fragment identifier must not be misinterpreted as a comment
+ # (commenting out the end of the block).
+ # The ' must not be interpreted as the start of a string, causing the }
+ # in the literal to be identified as the end of the block.
+ r5 = """INSERT DATA { , "'}" }"""
+
+ g.update(r5)
+ values = set()
+ for v in g.objects(michel, hates):
+ values.add(text_type(v))
+ self.assertEqual(values, set([u"urn:foo'bar?baz;a=1&b=2#fragment", u"'}"]))
+
+ # Comments
+ r6 = u"""
+ INSERT DATA {
+ . # No closing brace: }
+ .
+ }
+ #Final { } comment"""
+
+ g.update(r6)
+ values = set()
+ for v in g.objects(bob, hates):
+ values.add(v)
+ self.assertEqual(values, set([bob, michel]))
+
+ def testNamedGraphUpdateWithInitBindings(self):
+ g = self.graph.get_context(graphuri)
+ r = "INSERT { ?a ?b ?c } WHERE {}"
+ g.update(r, initBindings={
+ 'a': michel,
+ 'b': likes,
+ 'c': pizza
+ })
+ self.assertEqual(
+ set(g.triples((None, None, None))),
+ set([(michel, likes, pizza)]),
+ 'only michel likes pizza'
+ )
+
+ def testEmptyNamedGraph(self):
+ empty_graph_iri = "urn:empty-graph-1"
+ self.graph.update("CREATE GRAPH <%s>" % empty_graph_iri)
+ named_graphs = [text_type(r[0]) for r in self.graph.query(
+ "SELECT ?name WHERE { GRAPH ?name {} }")]
+ # Some SPARQL endpoint backends (like TDB) are not able to find empty named graphs
+ # (at least with this query)
+ if empty_graph_iri in named_graphs:
+ self.assertTrue(empty_graph_iri in [text_type(g.identifier)
+ for g in self.graph.contexts()])
+
+ def testEmptyLiteral(self):
+ # test for https://github.com/RDFLib/rdflib/issues/457
+ # also see test_issue457.py which is sparql store independent!
+ g = self.graph.get_context(graphuri)
+ g.add((
+ URIRef('http://example.com/s'),
+ URIRef('http://example.com/p'),
+ Literal('')))
+
+ o = tuple(g)[0][2]
+ self.assertEqual(o, Literal(''), repr(o))
+
+
+try:
+ assert len(urlopen(HOST).read()) > 0
+except:
+ raise SkipTest(HOST + " is unavailable.")
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_swap_n3.py b/testbed/RDFLib__rdflib/test/test_swap_n3.py
new file mode 100644
index 0000000000000000000000000000000000000000..c81378e144d089aabd36506c84976fdc3f16204f
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_swap_n3.py
@@ -0,0 +1,154 @@
+from nose.exc import SkipTest
+import os
+import sys
+import unittest
+try:
+ maketrans = str.maketrans
+except AttributeError:
+ from string import maketrans
+import rdflib
+
+"""
+SWAP N3 parser test suite
+"""
+
+rdf = rdflib.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+rdfs = rdflib.Namespace("http://www.w3.org/2000/01/rdf-schema#")
+xsd = rdflib.Namespace("http://www.w3.org/2001/XMLSchema#")
+owl = rdflib.Namespace("http://www.w3.org/2002/07/owl#")
+test = rdflib.Namespace("http://www.w3.org/2000/10/swap/test.n3#")
+n3test = rdflib.Namespace("http://www.w3.org/2004/11/n3test#")
+rdft = rdflib.Namespace("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#")
+triage = rdflib.Namespace("http://www.w3.org/2000/10/swap/test/triage#")
+mf = rdflib.Namespace("http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#")
+qt = rdflib.Namespace("http://www.w3.org/2001/sw/DataAccess/tests/test-query#")
+
+
+# class TestSWAPN3(unittest.TestCase):
+# """SWAP 2000/10/n3 tests"""
+
+# def setUp(self):
+
+# def test_foo(self):
+# """footest"""
+# self.graph.parse(os.getcwd()+'/test/swap-n3/n3-rdf.tests', format="n3")
+# tfiles = []
+# for tst in self.graph.subjects():
+# files = [str(tfile).replace('http://www.w3.org/2000/10/', 'file://'+os.getcwd()+'/test/swap-n3/')
+# for tfile in self.graph.objects(tst, rdflib.URIRef("http://www.w3.org/2004/11/n3test#inputDocument")) if tfile.endswith('n3')]
+# tfiles += files
+# for tfile in tfiles:
+# self.graph.parse(tfile, format="n3")
+
+
+skiptests = [
+ 'syntax_neg_single_quote',
+ 'syntax_neg_literal_predicate',
+ 'syntax_this_quantifiers',
+ 'syntax_trailing_semicolon',
+ 'syntax_neg_thisadoc',
+ 'syntax_equals1',
+ 'syntax_equals2',
+ 'syntax_this_rules',
+ 'syntax_neg_keywords3',
+ 'syntax_zero_objects',
+ 'syntax_neg_formula_predicate',
+ 'syntax_zero_predicates',
+ # 'syntax_qvars1',
+ # 'syntax_qvars2',
+ # 'contexts',
+ 'syntax_too_nested'
+]
+
+
+class Envelope(object):
+ def __init__(self, n, f):
+ self.name = n
+ self.file = f
+
+ def __repr__(self):
+ return self.name
+
+
+def generictest(e):
+ """Documentation"""
+ if e.skip:
+ raise SkipTest("%s skipped, known issue" % e.name)
+ g = rdflib.Graph()
+ for i in [rdf, rdfs, xsd, owl, test, n3test, rdft, triage, mf, qt]:
+ g.bind(str(i), i)
+ g.parse(e.file, format="n3")
+
+
+def dir_to_uri(directory, sep=os.path.sep):
+ '''
+ Convert a local path to a File URI.
+
+ >>> dir_to_uri('c:\\\\temp\\\\foo\\\\file.txt', sep='\\\\')
+ 'file:///c:/temp/foo/file.txt'
+
+ >>> dir_to_uri('/tmp/foo/file.txt', sep='/')
+ 'file:///tmp/foo/file.txt'
+ '''
+ items = directory.split(sep)
+ path = '/'.join(items)
+ if path.startswith('/'):
+ path = path[1:]
+ return 'file:///%s' % (path,)
+
+
+def test_cases():
+ from copy import deepcopy
+ g = rdflib.Graph()
+ swap_dir = os.path.join(os.getcwd(), 'test', 'swap-n3')
+ g.parse(os.path.join(swap_dir, 'n3-rdf.tests'), format="n3")
+ g.parse(os.path.join(swap_dir, 'n3-full.tests'), format="n3")
+ tfiles = []
+ swap_dir_uri = dir_to_uri(swap_dir) + '/'
+ for tst in g.subjects():
+ files = [str(tfile).replace('http://www.w3.org/2000/10/', swap_dir_uri)
+ for tfile in g.objects(tst, rdflib.URIRef("http://www.w3.org/2004/11/n3test#inputDocument")) if tfile.endswith('n3')]
+ tfiles += files
+ for tfile in set(tfiles):
+ gname = tfile.split('/swap-n3/swap/test/')[1][:-3].translate(maketrans('-/','__'))
+ e = Envelope(gname, tfile)
+ if gname in skiptests:
+ e.skip = True
+ else:
+ e.skip = False
+ # e.skip = True
+ if sys.version_info[:2] == (2, 4):
+ import pickle
+ gjt = pickle.dumps(generictest)
+ gt = pickle.loads(gjt)
+ else:
+ gt = deepcopy(generictest)
+ gt.__doc__ = tfile
+ yield gt, e
+
+
+if __name__ == "__main__":
+ test_cases()
+ # unittest.main()
+
+
+"""
+Interesting failure in Python 2.4 ...
+
+======================================================================
+ERROR: Failure: TypeError (function() takes at least 2 arguments (0 given))
+----------------------------------------------------------------------
+Traceback (most recent call last):
+ File ".../python2.4/site-packages/nose/loader.py", line 231, in generate
+ for test in g():
+ File ".../rdflib/test/test_swap_n3.py", line 95, in test_cases
+ gt = deepcopy(generictest)
+ File "/usr/local/python2.4/lib/python2.4/copy.py", line 204, in deepcopy
+ y = _reconstruct(x, rv, 1, memo)
+ File "/usr/local/python2.4/lib/python2.4/copy.py", line 336, in _reconstruct
+ y = callable(*args)
+ File "...py24/lib/python2.4/copy_reg.py", line 92, in __newobj__
+ return cls.__new__(cls, *args)
+TypeError: function() takes at least 2 arguments (0 given)
+
+"""
diff --git a/testbed/RDFLib__rdflib/test/test_term.py b/testbed/RDFLib__rdflib/test/test_term.py
new file mode 100644
index 0000000000000000000000000000000000000000..c222a8d29d070c01184f13c074c632c4b42478d6
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_term.py
@@ -0,0 +1,140 @@
+"""
+some more specific Literal tests are in test_literal.py
+"""
+
+import base64
+import unittest
+import random
+
+from rdflib.term import URIRef, BNode, Literal, _is_valid_unicode
+from rdflib.graph import QuotedGraph, Graph
+from rdflib.namespace import XSD
+
+from six import PY3
+
+
+def uformat(s):
+ if PY3:
+ return s.replace("u'", "'")
+ return s
+
+
+class TestURIRefRepr(unittest.TestCase):
+ """
+ see also test_literal.TestRepr
+ """
+
+ def testSubclassNameAppearsInRepr(self):
+ class MyURIRef(URIRef):
+ pass
+ x = MyURIRef('http://example.com/')
+ self.assertEqual(repr(x), uformat("MyURIRef(u'http://example.com/')"))
+
+ def testGracefulOrdering(self):
+ u = URIRef('cake')
+ g = Graph()
+ a = u > u
+ a = u > BNode()
+ a = u > QuotedGraph(g.store, u)
+ a = u > g
+
+
+class TestBNodeRepr(unittest.TestCase):
+
+ def testSubclassNameAppearsInRepr(self):
+ class MyBNode(BNode):
+ pass
+ x = MyBNode()
+ self.assertTrue(repr(x).startswith("MyBNode("))
+
+
+class TestLiteral(unittest.TestCase):
+
+ def test_base64_values(self):
+ b64msg = 'cmRmbGliIGlzIGNvb2whIGFsc28gaGVyZSdzIHNvbWUgYmluYXJ5IAAR83UC'
+ decoded_b64msg = base64.b64decode(b64msg)
+ lit = Literal(b64msg, datatype=XSD.base64Binary)
+ self.assertEqual(lit.value, decoded_b64msg)
+ self.assertEqual(str(lit), b64msg)
+
+ def test_total_order(self):
+ types = {
+ XSD.dateTime: (
+ '2001-01-01T00:00:00',
+ '2001-01-01T00:00:00Z',
+ '2001-01-01T00:00:00-00:00'
+ ),
+ XSD.date: (
+ '2001-01-01',
+ '2001-01-01Z',
+ '2001-01-01-00:00'
+ ),
+ XSD.time: (
+ '00:00:00',
+ '00:00:00Z',
+ '00:00:00-00:00'
+ ),
+ XSD.gYear: (
+ '2001',
+ '2001Z',
+ '2001-00:00'
+ ), # interval
+ XSD.gYearMonth: (
+ '2001-01',
+ '2001-01Z',
+ '2001-01-00:00'
+ ),
+ }
+ literals = [
+ Literal(literal, datatype=t)
+ for t, literals in types.items()
+ for literal in literals
+ ]
+ try:
+ sorted(literals)
+ orderable = True
+ except TypeError as e:
+ for l in literals:
+ print(repr(l), repr(l.value))
+ print(e)
+ orderable = False
+ self.assertTrue(orderable)
+
+ # also make sure that within a datetime things are still ordered:
+ l1 = [
+ Literal(l, datatype=XSD.dateTime)
+ for l in [
+ '2001-01-01T00:00:00',
+ '2001-01-01T01:00:00',
+ '2001-01-01T01:00:01',
+ '2001-01-02T01:00:01',
+ '2001-01-01T00:00:00Z',
+ '2001-01-01T00:00:00-00:00',
+ '2001-01-01T01:00:00Z',
+ '2001-01-01T01:00:00-00:00',
+ '2001-01-01T00:00:00-01:30',
+ '2001-01-01T01:00:00-01:30',
+ '2001-01-02T01:00:01Z',
+ '2001-01-02T01:00:01-00:00',
+ '2001-01-02T01:00:01-01:30'
+ ]
+ ]
+ l2 = list(l1)
+ random.shuffle(l2)
+ self.assertListEqual(l1, sorted(l2))
+
+
+class TestValidityFunctions(unittest.TestCase):
+
+ def test_is_valid_unicode(self):
+ testcase_list = (
+ (None, True),
+ (1, True),
+ (['foo'], True),
+ ({'foo': b'bar'}, True),
+ ('foo', True),
+ (b'foo\x00', True),
+ (b'foo\xf3\x02', False)
+ )
+ for val, expected in testcase_list:
+ self.assertEqual(_is_valid_unicode(val), expected)
diff --git a/testbed/RDFLib__rdflib/test/test_trig_w3c.py b/testbed/RDFLib__rdflib/test/test_trig_w3c.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb8588e070df2f88003e6f89e40e9b37190b3966
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_trig_w3c.py
@@ -0,0 +1,85 @@
+"""Runs the tests for the W3C RDF Working Group's TriG test suite.
+
+"""
+
+from rdflib import ConjunctiveGraph
+from rdflib.namespace import split_uri
+from rdflib.compare import graph_diff, isomorphic
+
+from .manifest import nose_tests, RDFT
+from .testutils import nose_tst_earl_report
+
+verbose = False
+
+
+def trig(test):
+ g = ConjunctiveGraph()
+
+ try:
+ base = 'http://www.w3.org/2013/TriGTests/' + split_uri(test.action)[1]
+
+ g.parse(test.action, publicID=base, format='trig')
+ if not test.syntax:
+ raise AssertionError("Input shouldn't have parsed!")
+
+ if test.result: # eval test
+ res = ConjunctiveGraph()
+ res.parse(test.result, format='nquads')
+
+ if verbose:
+
+ both, first, second = graph_diff(g, res)
+ if not first and not second:
+ return
+
+ print('===============================')
+ print('TriG')
+ print(g.serialize(format='nquads'))
+ print('===============================')
+ print('NQuads')
+ print(res.serialize(format='nquads'))
+ print('===============================')
+
+ print("Diff:")
+ # print "%d triples in both"%len(both)
+ print("TriG Only:")
+ for t in first:
+ print(t)
+
+ print("--------------------")
+ print("NQuads Only")
+ for t in second:
+ print(t)
+ raise Exception('Graphs do not match!')
+
+ assert isomorphic(g, res), 'graphs must be the same'
+
+ except:
+ if test.syntax:
+ raise
+
+
+testers = {
+ RDFT.TestTrigPositiveSyntax: trig,
+ RDFT.TestTrigNegativeSyntax: trig,
+ RDFT.TestTrigEval: trig,
+ RDFT.TestTrigNegativeEval: trig
+}
+
+
+def test_trig(tests=None):
+ for t in nose_tests(testers, 'test/w3c/trig/manifest.ttl'):
+ if tests:
+ for test in tests:
+ if test in t[1].uri:
+ break
+ else:
+ continue
+
+ yield t
+
+
+if __name__ == '__main__':
+ verbose = True
+
+ nose_tst_earl_report(test_trig, 'rdflib_trig')
diff --git a/testbed/RDFLib__rdflib/test/test_trix_parse.py b/testbed/RDFLib__rdflib/test/test_trix_parse.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b0f9fb9ab612a2277122db6c5433a411d00edb2
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_trix_parse.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+
+from rdflib.graph import ConjunctiveGraph
+import unittest
+
+
+class TestTrixParse(unittest.TestCase):
+
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ pass
+
+ def testAperture(self):
+
+ g = ConjunctiveGraph()
+
+ g.parse("test/trix/aperture.trix", format="trix")
+ c = list(g.contexts())
+
+ # print list(g.contexts())
+ t = sum(map(len, g.contexts()))
+
+ self.assertEqual(t, 24)
+ self.assertEqual(len(c), 4)
+
+ # print "Parsed %d triples"%t
+
+ def testSpec(self):
+
+ g = ConjunctiveGraph()
+
+ g.parse("test/trix/nokia_example.trix", format="trix")
+
+ # print "Parsed %d triples"%len(g)
+
+ def testNG4j(self):
+
+ g = ConjunctiveGraph()
+
+ g.parse("test/trix/ng4jtest.trix", format="trix")
+
+ # print "Parsed %d triples"%len(g)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_trix_serialize.py b/testbed/RDFLib__rdflib/test/test_trix_serialize.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1b68de4623ae98334fc964dde02f6eb1cd5d260
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_trix_serialize.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+import unittest
+
+from rdflib.graph import ConjunctiveGraph
+from rdflib.term import URIRef, Literal
+from rdflib.graph import Graph
+from six import BytesIO
+
+
+class TestTrixSerialize(unittest.TestCase):
+
+ def setUp(self):
+ pass
+
+ def tearDown(self):
+ pass
+
+ def testSerialize(self):
+
+ s1 = URIRef('store:1')
+ r1 = URIRef('resource:1')
+ r2 = URIRef('resource:2')
+
+ label = URIRef('predicate:label')
+
+ g1 = Graph(identifier=s1)
+ g1.add((r1, label, Literal("label 1", lang="en")))
+ g1.add((r1, label, Literal("label 2")))
+
+ s2 = URIRef('store:2')
+ g2 = Graph(identifier=s2)
+ g2.add((r2, label, Literal("label 3")))
+
+ g = ConjunctiveGraph()
+ for s, p, o in g1.triples((None, None, None)):
+ g.addN([(s, p, o, g1)])
+ for s, p, o in g2.triples((None, None, None)):
+ g.addN([(s, p, o, g2)])
+ r3 = URIRef('resource:3')
+ g.add((r3, label, Literal(4)))
+
+ r = g.serialize(format='trix')
+ g3 = ConjunctiveGraph()
+
+ g3.parse(BytesIO(r), format='trix')
+
+ for q in g3.quads((None, None, None)):
+ # TODO: Fix once getGraph/getContext is in conjunctive graph
+ if isinstance(q[3].identifier, URIRef):
+ tg = Graph(store=g.store, identifier=q[3].identifier)
+ else:
+ # BNode, this is a bit ugly
+ # we cannot match the bnode to the right graph automagically
+ # here I know there is only one anonymous graph,
+ # and that is the default one, but this is not always the case
+ tg = g.default_context
+ self.assertTrue(q[0:3] in tg)
+
+ def test_issue_250(self):
+ """
+
+ https://github.com/RDFLib/rdflib/issues/250
+
+ When I have a ConjunctiveGraph with the default namespace set,
+ for example
+
+ import rdflib
+ g = rdflib.ConjunctiveGraph()
+ g.bind(None, "http://defaultnamespace")
+
+ then the Trix serializer binds the default namespace twice in its XML
+ output, once for the Trix namespace and once for the namespace I used:
+
+ print(g.serialize(format='trix').decode('UTF-8'))
+
+
+
+
+ """
+
+ graph = ConjunctiveGraph()
+ graph.bind(None, "http://defaultnamespace")
+ sg = graph.serialize(format='trix').decode('UTF-8')
+ self.assertTrue(
+ 'xmlns="http://defaultnamespace"' not in sg, sg)
+ self.assertTrue(
+ 'xmlns="http://www.w3.org/2004/03/trix/trix-1/' in sg, sg)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_tsvresults.py b/testbed/RDFLib__rdflib/test/test_tsvresults.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5222a34eae472fe41d14546aec1a76e8564b1b8
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_tsvresults.py
@@ -0,0 +1,20 @@
+import unittest
+from six import StringIO
+from rdflib.plugins.sparql.results.tsvresults import TSVResultParser
+
+
+class TestTSVResults(unittest.TestCase):
+
+ def test_empty_tsvresults_bindings(self):
+ # check that optional bindings are ordered properly
+ source = """?s\t?p\t?o
+ \t\t
+ \t\t
+ \t\t"""
+
+ parser = TSVResultParser()
+ source = StringIO(source)
+ result = parser.parse(source)
+
+ for idx, row in enumerate(result):
+ self.assertTrue(row[idx] is None)
diff --git a/testbed/RDFLib__rdflib/test/test_turtle_serialize.py b/testbed/RDFLib__rdflib/test/test_turtle_serialize.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b602b347f1d5f78de795e9c1d82e2d45216c003
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_turtle_serialize.py
@@ -0,0 +1,76 @@
+from rdflib import Graph, URIRef, BNode, RDF, Literal, Namespace
+from rdflib.collection import Collection
+from rdflib.plugins.serializers.turtle import TurtleSerializer
+from six import b
+
+
+def testTurtleFinalDot():
+ """
+ https://github.com/RDFLib/rdflib/issues/282
+ """
+
+ g = Graph()
+ u = URIRef("http://ex.org/bob.")
+ g.bind("ns", "http://ex.org/")
+ g.add((u, u, u))
+ s = g.serialize(format='turtle')
+ assert b("ns:bob.") not in s
+
+
+def testTurtleBoolList():
+ subject = URIRef("http://localhost/user")
+ predicate = URIRef("http://localhost/vocab#hasList")
+ g1 = Graph()
+ list_item1 = BNode()
+ list_item2 = BNode()
+ list_item3 = BNode()
+ g1.add((subject, predicate, list_item1))
+ g1.add((list_item1, RDF.first, Literal(True)))
+ g1.add((list_item1, RDF.rest, list_item2))
+ g1.add((list_item2, RDF.first, Literal(False)))
+ g1.add((list_item2, RDF.rest, list_item3))
+ g1.add((list_item3, RDF.first, Literal(True)))
+ g1.add((list_item3, RDF.rest, RDF.nil))
+
+ ttl_dump = g1.serialize(format="turtle")
+ g2 = Graph()
+ g2.parse(data=ttl_dump, format="turtle")
+
+ list_id = g2.value(subject, predicate)
+ bool_list = [i.toPython() for i in Collection(g2, list_id)]
+ assert bool_list == [True, False, True]
+
+
+def testUnicodeEscaping():
+ turtle_string = " . . ."
+ g = Graph()
+
+ # shouldn't get an exception
+ g.parse(data=turtle_string, format="turtle")
+ triples = sorted(list(g))
+ assert len(triples) == 3
+ print(triples)
+ # Now check that was decoded into python values properly
+ assert triples[0][2] == URIRef(u'http://example.com/aaa\xf3bbbb')
+ assert triples[1][2] == URIRef(u'http://example.com/zzz\U00100000zzz')
+ assert triples[2][2] == URIRef(u'http://example.com/aaa\xf3bbb')
+
+
+def test_turtle_valid_list():
+ NS = Namespace('http://example.org/ns/')
+ g = Graph()
+ g.parse(data="""
+ @prefix : <{0}> .
+ :s :p (""), (0), (false) .
+ """.format(NS), format='turtle')
+
+ turtle_serializer = TurtleSerializer(g)
+
+ for o in g.objects(NS.s, NS.p):
+ assert turtle_serializer.isValidList(o)
+
+
+if __name__ == "__main__":
+ import nose
+ import sys
+ nose.main(defaultTest=sys.argv[0])
diff --git a/testbed/RDFLib__rdflib/test/test_turtle_sort_issue613.py b/testbed/RDFLib__rdflib/test/test_turtle_sort_issue613.py
new file mode 100644
index 0000000000000000000000000000000000000000..f81cba335cab02b3a80b3a2a35d4b61a6b75b797
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_turtle_sort_issue613.py
@@ -0,0 +1,40 @@
+import rdflib
+
+"""
+In py3, some objects are not comparable. When the turtle serializer tries to sort them everything breaks.
+
+* Timezone aware datetime objects and "naive" datetime objects are not comparable
+
+https://github.com/RDFLib/rdflib/issues/648
+https://github.com/RDFLib/rdflib/issues/613
+
+* DocumentFragment
+https://github.com/RDFLib/rdflib/issues/676
+
+"""
+
+
+def test_sort_dates():
+
+ g = rdflib.Graph()
+ y = '''@prefix ex: .
+ex:X ex:p "2016-01-01T00:00:00"^^, "2016-01-01T00:00:00Z"^^ . '''
+
+ p = g.parse(data=y, format="turtle")
+ p.serialize(format="turtle")
+
+
+def test_sort_docfrag():
+
+ g = rdflib.Graph()
+ y = '''@prefix ex: .
+@prefix rdf: .
+ex:X ex:p "hi
"^^rdf:HTML, "ho
"^^rdf:HTML . '''
+
+ p = g.parse(data=y, format="turtle")
+ p.serialize(format="turtle")
+
+
+if __name__ == '__main__':
+
+ test_sort_docfrag()
diff --git a/testbed/RDFLib__rdflib/test/test_turtle_w3c.py b/testbed/RDFLib__rdflib/test/test_turtle_w3c.py
new file mode 100644
index 0000000000000000000000000000000000000000..469ed02383733bc44fc80bbc277daa482e36e228
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_turtle_w3c.py
@@ -0,0 +1,76 @@
+"""This runs the turtle tests for the W3C RDF Working Group's N-Quads
+test suite."""
+
+from rdflib import Graph
+from rdflib.namespace import split_uri
+from rdflib.compare import graph_diff, isomorphic
+
+from .manifest import nose_tests, RDFT
+from .testutils import nose_tst_earl_report
+
+verbose = False
+
+
+def turtle(test):
+ g = Graph()
+
+ try:
+ base = 'http://www.w3.org/2013/TurtleTests/' + split_uri(test.action)[1]
+
+ g.parse(test.action, publicID=base, format='turtle')
+ if not test.syntax:
+ raise AssertionError("Input shouldn't have parsed!")
+
+ if test.result: # eval test
+ res = Graph()
+ res.parse(test.result, format='nt')
+
+ if verbose:
+ both, first, second = graph_diff(g, res)
+ if not first and not second:
+ return
+ print("Diff:")
+ # print "%d triples in both"%len(both)
+ print("Turtle Only:")
+ for t in first:
+ print(t)
+
+ print("--------------------")
+ print("NT Only")
+ for t in second:
+ print(t)
+ raise Exception('Graphs do not match!')
+
+ assert isomorphic(g, res), 'graphs must be the same'
+
+ except:
+ if test.syntax:
+ raise
+
+
+testers = {
+ RDFT.TestTurtlePositiveSyntax: turtle,
+ RDFT.TestTurtleNegativeSyntax: turtle,
+ RDFT.TestTurtleEval: turtle,
+ RDFT.TestTurtleNegativeEval: turtle
+}
+
+
+def test_turtle(tests=None):
+ for t in nose_tests(testers,
+ 'test/w3c/turtle/manifest.ttl'):
+ if tests:
+ for test in tests:
+ if test in t[1].uri:
+ break
+ else:
+ continue
+
+ yield t
+
+
+if __name__ == '__main__':
+
+ verbose = True
+
+ nose_tst_earl_report(test_turtle, 'rdflib_turtle')
diff --git a/testbed/RDFLib__rdflib/test/test_util.py b/testbed/RDFLib__rdflib/test/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..61e5b33c2ccef0c654a3f7cc91b651a713afc93b
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_util.py
@@ -0,0 +1,350 @@
+import unittest
+import time
+from rdflib.graph import Graph
+from rdflib.graph import QuotedGraph
+from rdflib.graph import ConjunctiveGraph
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import URIRef
+from rdflib import util
+from rdflib import XSD
+from rdflib.exceptions import SubjectTypeError
+from rdflib.exceptions import PredicateTypeError
+from rdflib.exceptions import ObjectTypeError
+from rdflib.exceptions import ContextTypeError
+
+n3source = """\
+@prefix : .
+@prefix rdf: .
+@prefix rdfs: .
+@prefix owl: .
+@prefix dc: .
+@prefix foo: .
+@prefix swap: .
+
+<> dc:title
+ "Primer - Getting into the Semantic Web and RDF using N3".
+
+<#pat> <#knows> <#jo> .
+<#pat> <#age> 24 .
+<#al> is <#child> of <#pat> .
+
+<#pat> <#child> <#al>, <#chaz>, <#mo> ;
+ <#age> 24 ;
+ <#eyecolor> "blue" .
+
+:Person a rdfs:Class.
+
+:Pat a :Person.
+
+:Woman a rdfs:Class; rdfs:subClassOf :Person .
+
+:sister a rdf:Property.
+
+:sister rdfs:domain :Person;
+ rdfs:range :Woman.
+
+:Woman = foo:FemaleAdult .
+:Title a rdf:Property; = dc:title .
+
+""" # --- End of primer code
+
+
+class TestUtilMisc(unittest.TestCase):
+ def setUp(self):
+ self.x = Literal("2008-12-01T18:02:00Z",
+ datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime'))
+
+ def test_util_list2set(self):
+ base = [Literal('foo'), self.x]
+ r = util.list2set(base + base)
+ self.assertTrue(r == base)
+
+ def test_util_uniq(self):
+ base = ["michel", "hates", "pizza"]
+ r = util.uniq(base + base)
+ self.assertEqual(sorted(r), sorted(base))
+ base = ["michel", "hates", "pizza"]
+ r = util.uniq(base + base, strip=True)
+ self.assertEqual(sorted(r), sorted(base))
+
+ def test_coverage_dodge(self):
+ util.test()
+
+
+class TestUtilDateTime(unittest.TestCase):
+
+ def setUp(self):
+ self.x = Literal("2008-12-01T18:02:00Z",
+ datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime'))
+
+ def test_util_date_time_tisnoneandnotz(self):
+ t = None
+ res = util.date_time(t, local_time_zone=False)
+ self.assertTrue(res[4:5] == "-")
+
+ def test_util_date_time_tisnonebuttz(self):
+ t = None
+ res = util.date_time(t, local_time_zone=True)
+ self.assertTrue(res[4:5] == "-")
+
+ def test_util_date_time_tistime(self):
+ t = time.time()
+ res = util.date_time(t, local_time_zone=False)
+ self.assertTrue(res[4:5] == "-")
+
+ def test_util_date_time_tistimewithtz(self):
+ t = time.time()
+ res = util.date_time(t, local_time_zone=True)
+ self.assertTrue(res[4:5] == "-")
+
+ def test_util_parse_date_time(self):
+ t = time.time()
+ res = util.parse_date_time("1970-01-01")
+ self.assertTrue(res is not t)
+
+ def test_util_parse_date_timewithtz(self):
+ t = time.time()
+ res = util.parse_date_time("1970-01-01")
+ self.assertTrue(res is not t)
+
+ def test_util_date_timewithtoutz(self):
+ t = time.time()
+
+ def ablocaltime(t):
+ from time import gmtime
+ res = gmtime(t)
+ return res
+ util.localtime = ablocaltime
+ res = util.date_time(t, local_time_zone=True)
+ self.assertTrue(res is not t)
+
+
+class TestUtilTermConvert(unittest.TestCase):
+ def setUp(self):
+ self.x = Literal("2008-12-01T18:02:00Z",
+ datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime'))
+
+ def test_util_to_term_sisNone(self):
+ s = None
+ self.assertEqual(util.to_term(s), s)
+ self.assertEqual(util.to_term(s, default=""), "")
+
+ def test_util_to_term_sisstr(self):
+ s = '"http://example.com"'
+ res = util.to_term(s)
+ self.assertTrue(isinstance(res, Literal))
+ self.assertEqual(str(res), s[1:-1])
+
+ def test_util_to_term_sisurl(self):
+ s = ""
+ res = util.to_term(s)
+ self.assertTrue(isinstance(res, URIRef))
+ self.assertEqual(str(res), s[1:-1])
+
+ def test_util_to_term_sisbnode(self):
+ s = '_http%23%4F%4Fexample%33com'
+ res = util.to_term(s)
+ self.assertTrue(isinstance(res, BNode))
+
+ def test_util_to_term_sisunknown(self):
+ s = 'http://example.com'
+ self.assertRaises(Exception, util.to_term, s)
+
+ def test_util_to_term_sisnotstr(self):
+ s = self.x
+ self.assertRaises(Exception, util.to_term, s)
+
+ def test_util_from_n3_sisnonenodefault(self):
+ s = None
+ default = None
+ res = util.from_n3(s, default=default, backend=None)
+ self.assertTrue(res == default)
+
+ def test_util_from_n3_sisnonewithdefault(self):
+ s = None
+ default = "TestofDefault"
+ res = util.from_n3(s, default=default, backend=None)
+ self.assertTrue(res == default)
+
+ def test_util_from_n3_expectdefaultbnode(self):
+ s = "michel"
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, BNode))
+
+ def test_util_from_n3_expectbnode(self):
+ s = "_:michel"
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, BNode))
+
+ def test_util_from_n3_expectliteral(self):
+ s = '"michel"'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, Literal))
+
+ def test_util_from_n3_expecturiref(self):
+ s = ''
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, URIRef))
+
+ def test_util_from_n3_expectliteralandlang(self):
+ s = '"michel"@fr'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, Literal))
+
+ def test_util_from_n3_expectliteralandlangdtype(self):
+ s = '"michel"@fr^^xsd:fr'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(isinstance(res, Literal))
+ self.assertEqual(res, Literal('michel',
+ datatype=XSD['fr']))
+
+ def test_util_from_n3_expectliteralanddtype(self):
+ s = '"true"^^xsd:boolean'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(res.eq(Literal('true', datatype=XSD['boolean'])))
+
+ def test_util_from_n3_expectliteralwithdatatypefromint(self):
+ s = '42'
+ res = util.from_n3(s)
+ self.assertEqual(res, Literal(42))
+
+ def test_util_from_n3_expectliteralwithdatatypefrombool(self):
+ s = 'true'
+ res = util.from_n3(s)
+ self.assertEqual(res, Literal(True))
+ s = 'false'
+ res = util.from_n3(s)
+ self.assertEqual(res, Literal(False))
+
+ def test_util_from_n3_expectliteralmultiline(self):
+ s = '"""multi\nline\nstring"""@en'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(res, Literal('multi\nline\nstring', lang='en'))
+
+ def test_util_from_n3_expectliteralwithescapedquote(self):
+ s = '"\\""'
+ res = util.from_n3(s, default=None, backend=None)
+ self.assertTrue(res, Literal('\\"', lang='en'))
+
+ def test_util_from_n3_expectliteralwithtrailingbackslash(self):
+ s = '"trailing\\\\"^^'
+ res = util.from_n3(s)
+ self.assertTrue(res, Literal('trailing\\', datatype=XSD['string']))
+ self.assertTrue(res.n3(), s)
+
+ def test_util_from_n3_expectpartialidempotencewithn3(self):
+ for n3 in ('',
+ '"foo"@de',
+ # '"\\""', # exception as '\\"' --> '"' by orig parser as well
+ '"""multi\n"line"\nstring"""@en'):
+ self.assertEqual(util.from_n3(n3).n3(), n3,
+ 'from_n3(%(n3e)r).n3() != %(n3e)r' % {'n3e': n3})
+
+ def test_util_from_n3_expectsameasn3parser(self):
+ def parse_n3(term_n3):
+ ''' Disclaimer: Quick and dirty hack using the n3 parser. '''
+ prepstr = ("@prefix xsd: .\n"
+ " %s.\n" % term_n3)
+ g = ConjunctiveGraph()
+ g.parse(data=prepstr, format='n3')
+ return [t for t in g.triples((None, None, None))][0][2]
+
+ for n3 in ( # "michel", # won't parse in original parser
+ # "_:michel", # BNodes won't be the same
+ '"michel"',
+ '',
+ '"michel"@fr',
+ # '"michel"@fr^^xsd:fr', # FIXME: invalid n3, orig parser will prefer datatype
+ # '"true"^^xsd:boolean', # FIXME: orig parser will expand xsd prefix
+ '42',
+ 'true',
+ 'false',
+ '"""multi\nline\nstring"""@en',
+ '',
+ '"foo"@de',
+ '"\\""@en',
+ '"""multi\n"line"\nstring"""@en'):
+ res, exp = util.from_n3(n3), parse_n3(n3)
+ self.assertEqual(res, exp,
+ 'from_n3(%(n3e)r): %(res)r != parser.notation3: %(exp)r' % {
+ 'res': res, 'exp': exp, 'n3e': n3})
+
+ def test_util_from_n3_expectquotedgraph(self):
+ s = '{}'
+ res = util.from_n3(s, default=None, backend="IOMemory")
+ self.assertTrue(isinstance(res, QuotedGraph))
+
+ def test_util_from_n3_expectgraph(self):
+ s = '[]'
+ res = util.from_n3(s, default=None, backend="IOMemory")
+ self.assertTrue(isinstance(res, Graph))
+
+
+class TestUtilCheckers(unittest.TestCase):
+ def setUp(self):
+ self.c = URIRef("http://example.com")
+ self.s = BNode("http://example.com")
+ self.p = URIRef("http://example.com/predicates/isa")
+ self.o = Literal("Objectification")
+
+ def test_util_checker_exceptions(self):
+ c = "http://example.com"
+ self.assertRaises(ContextTypeError, util.check_context, c)
+ self.assertRaises(SubjectTypeError, util.check_subject, c)
+ self.assertRaises(PredicateTypeError, util.check_predicate, c)
+ self.assertRaises(ObjectTypeError, util.check_object, c)
+
+ def test_util_check_context(self):
+ res = util.check_context(self.c)
+ self.assertTrue(res == None)
+
+ def test_util_check_subject(self):
+ res = util.check_subject(self.s)
+ self.assertTrue(res == None)
+
+ def test_util_check_predicate(self):
+ res = util.check_predicate(self.p)
+ self.assertTrue(res == None)
+
+ def test_util_check_object(self):
+ res = util.check_object(self.o)
+ self.assertTrue(res == None)
+
+ def test_util_check_statement(self):
+ c = "http://example.com"
+ self.assertRaises(
+ SubjectTypeError,
+ util.check_statement,
+ (c, self.p, self.o))
+ self.assertRaises(
+ PredicateTypeError,
+ util.check_statement,
+ (self.s, c, self.o))
+ self.assertRaises(
+ ObjectTypeError,
+ util.check_statement,
+ (self.s, self.p, c))
+ res = util.check_statement((self.s, self.p, self.o))
+ self.assertTrue(res == None)
+
+ def test_util_check_pattern(self):
+ c = "http://example.com"
+ self.assertRaises(
+ SubjectTypeError,
+ util.check_pattern,
+ (c, self.p, self.o))
+ self.assertRaises(
+ PredicateTypeError,
+ util.check_pattern,
+ (self.s, c, self.o))
+ self.assertRaises(
+ ObjectTypeError,
+ util.check_pattern,
+ (self.s, self.p, c))
+ res = util.check_pattern((self.s, self.p, self.o))
+ self.assertTrue(res == None)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/test_wide_python.py b/testbed/RDFLib__rdflib/test/test_wide_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..feef4519ba8a12001c662d698eeea02eaccbbf8d
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_wide_python.py
@@ -0,0 +1,14 @@
+
+def test_wide_python_build():
+ """This test is meant to fail on narrow python builds (common on Mac OS X).
+
+ See https://github.com/RDFLib/rdflib/issues/456 for more information.
+ """
+ assert len(u'\U0010FFFF') == 1, (
+ 'You are using a narrow Python build!\n'
+ 'This means that your Python does not properly support chars > 16bit.\n'
+ 'On your system chars like c=u"\\U0010FFFF" will have a len(c)==2.\n'
+ 'As this can cause hard to debug problems with string processing\n'
+ '(slicing, regexp, ...) later on, we strongly advise to use a wide\n'
+ 'Python build in production systems.'
+ )
diff --git a/testbed/RDFLib__rdflib/test/test_xmlliterals.py b/testbed/RDFLib__rdflib/test/test_xmlliterals.py
new file mode 100644
index 0000000000000000000000000000000000000000..b467e82a3758891dbe28369f7f0b2dc19d541165
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/test_xmlliterals.py
@@ -0,0 +1,84 @@
+import rdflib
+from rdflib import RDF, Graph, Literal
+
+
+def testPythonRoundtrip():
+ l1 = Literal('hello', datatype=RDF.XMLLiteral)
+ assert l1.value is not None, 'xml must have been parsed'
+ assert l1.datatype == RDF.XMLLiteral, 'literal must have right datatype'
+
+ l2 = Literal('good morning', datatype=RDF.XMLLiteral)
+ assert l2.value is not None, 'xml must have been parsed'
+ assert not l1.eq(l2), 'literals must NOT be equal'
+
+ l3 = Literal(l1.value)
+ assert l1.eq(l3), 'roundtripped literals must be equal'
+ assert l3.datatype == RDF.XMLLiteral, 'literal must have right datatype'
+
+ l4 = Literal('hello', datatype=RDF.XMLLiteral)
+ assert l1 == l4
+ assert l1.eq(l4)
+
+ rdflib.NORMALIZE_LITERALS = False
+ l4 = Literal('hello', datatype=RDF.XMLLiteral)
+ assert l1 != l4
+ assert l1.eq(l4)
+ rdflib.NORMALIZE_LITERALS = True
+
+
+def testRDFXMLParse():
+ rdfxml = """\
+
+
+
+
+
+
+
+
+"""
+
+ g = rdflib.Graph()
+ g.parse(data=rdfxml)
+ l1 = list(g)[0][2]
+ assert l1.datatype == RDF.XMLLiteral
+
+
+def graph():
+ g = rdflib.Graph()
+ g.add((rdflib.URIRef('http://example.org/a'),
+ rdflib.URIRef('http://example.org/p'),
+ rdflib.Literal('hei', datatype=RDF.XMLLiteral)))
+ return g
+
+
+def roundtrip(fmt):
+ g1 = graph()
+ l1 = list(g1)[0][2]
+ g2 = rdflib.Graph()
+ g2.parse(data=g1.serialize(format=fmt), format=fmt)
+ l2 = list(g2)[0][2]
+ assert l1.eq(l2)
+
+
+def testRoundtrip():
+ roundtrip('xml')
+ roundtrip('n3')
+ roundtrip('nt')
+
+
+def testHTML():
+
+ l1 = Literal('hello', datatype=RDF.XMLLiteral)
+ assert l1.value is not None, 'xml must have been parsed'
+ assert l1.datatype == RDF.XMLLiteral, 'literal must have right datatype'
+
+ l2 = Literal('hello', datatype=RDF.HTML)
+ assert l2.value is not None, 'xml must have been parsed'
+ assert l2.datatype == RDF.HTML, 'literal must have right datatype'
+
+ assert l1 != l2
+ assert not l1.eq(l2)
diff --git a/testbed/RDFLib__rdflib/test/testutils.py b/testbed/RDFLib__rdflib/test/testutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..02bc4b231af0d82af3db04f27c0298475a13b6eb
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/testutils.py
@@ -0,0 +1,103 @@
+from __future__ import print_function
+
+import sys
+import isodate
+import datetime
+
+from traceback import print_exc
+from nose import SkipTest
+from .earl import add_test, report
+
+from rdflib import BNode, Graph, ConjunctiveGraph
+
+
+# TODO: make an introspective version (like this one) of
+# rdflib.graphutils.isomorphic and use instead.
+def crapCompare(g1, g2):
+ """A really crappy way to 'check' if two graphs are equal. It ignores blank
+ nodes completely and ignores subgraphs."""
+ if len(g1) != len(g2):
+ raise Exception("Graphs dont have same length")
+ for t in g1:
+ s = _no_blank(t[0])
+ o = _no_blank(t[2])
+ if not (s, t[1], o) in g2:
+ e = "(%s, %s, %s) is not in both graphs!" % (s, t[1], o)
+ raise Exception(e)
+
+
+def _no_blank(node):
+ if isinstance(node, BNode):
+ return None
+ if isinstance(node, Graph):
+ return None # node._Graph__identifier = _SQUASHED_NODE
+ return node
+
+
+def check_serialize_parse(fpath, infmt, testfmt, verbose=False):
+ g = ConjunctiveGraph()
+ _parse_or_report(verbose, g, fpath, format=infmt)
+ if verbose:
+ for t in g:
+ print(t)
+ print("========================================")
+ print("Parsed OK!")
+ s = g.serialize(format=testfmt)
+ if verbose:
+ print(s)
+ g2 = ConjunctiveGraph()
+ _parse_or_report(verbose, g2, data=s, format=testfmt)
+ if verbose:
+ print(g2.serialize())
+ crapCompare(g, g2)
+
+
+def _parse_or_report(verbose, graph, *args, **kwargs):
+ try:
+ graph.parse(*args, **kwargs)
+ except:
+ if verbose:
+ print("========================================")
+ print("Error in parsing serialization:")
+ print(args, kwargs)
+ raise
+
+
+def nose_tst_earl_report(generator, earl_report_name=None):
+ from optparse import OptionParser
+ p = OptionParser()
+ (options, args) = p.parse_args()
+
+ skip = 0
+ tests = 0
+ success = 0
+
+ for t in generator(args):
+ tests += 1
+ print('Running ', t[1].uri)
+ try:
+ t[0](t[1])
+ add_test(t[1].uri, "passed")
+ success += 1
+ except SkipTest as e:
+ add_test(t[1].uri, "untested", e.message)
+ print("skipping %s - %s" % (t[1].uri, e.message))
+ skip += 1
+
+ except KeyboardInterrupt:
+ raise
+ except AssertionError:
+ add_test(t[1].uri, "failed")
+ except:
+ add_test(t[1].uri, "failed", "error")
+ print_exc()
+ sys.stderr.write("%s\n" % t[1].uri)
+
+ print("Ran %d tests, %d skipped, %d failed. "%(tests, skip, tests-skip-success))
+ if earl_report_name:
+ now = isodate.datetime_isoformat(datetime.datetime.utcnow())
+ earl_report = 'test_reports/%s-%s.ttl' % (earl_report_name, now)
+
+ report.serialize(earl_report, format='n3')
+ report.serialize('test_reports/%s-latest.ttl'%earl_report_name, format='n3')
+ print("Wrote EARL-report to '%s'" % earl_report)
diff --git a/testbed/RDFLib__rdflib/test/triple_store.py b/testbed/RDFLib__rdflib/test/triple_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9c5221ab0bd0ce70d59101279afe8ae9810792a
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/triple_store.py
@@ -0,0 +1,35 @@
+import unittest
+
+from rdflib.term import BNode, Literal
+from rdflib.namespace import RDFS
+from rdflib.graph import Graph
+
+
+class GraphTest(unittest.TestCase):
+ backend = 'default'
+ path = 'store'
+
+ def setUp(self):
+ self.store = Graph(store=self.backend)
+ self.store.open(self.path)
+ self.remove_me = (BNode(), RDFS.label, Literal("remove_me"))
+ self.store.add(self.remove_me)
+
+ def tearDown(self):
+ self.store.close()
+
+ def testAdd(self):
+ subject = BNode()
+ self.store.add((subject, RDFS.label, Literal("foo")))
+
+ def testRemove(self):
+ self.store.remove(self.remove_me)
+ self.store.remove((None, None, None))
+
+ def testTriples(self):
+ for s, p, o in self.store:
+ pass
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/testbed/RDFLib__rdflib/test/type_check.py b/testbed/RDFLib__rdflib/test/type_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..605f09161778229343e5e2a59858e71c826eab68
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test/type_check.py
@@ -0,0 +1,34 @@
+import unittest
+
+from rdflib.graph import Graph
+from rdflib.exceptions import SubjectTypeError
+from rdflib.exceptions import PredicateTypeError
+from rdflib.exceptions import ObjectTypeError
+from rdflib.term import URIRef
+
+foo = URIRef("foo")
+
+
+class TypeCheckCase(unittest.TestCase):
+ unstable = True # TODO: until we decide if we want to add type checking back to rdflib
+ backend = 'default'
+ path = 'store'
+
+ def setUp(self):
+ self.store = Graph(backend=self.backend)
+ self.store.open(self.path)
+
+ def tearDown(self):
+ self.store.close()
+
+ def testSubjectTypeCheck(self):
+ self.assertRaises(SubjectTypeError,
+ self.store.add, (None, foo, foo))
+
+ def testPredicateTypeCheck(self):
+ self.assertRaises(PredicateTypeError,
+ self.store.add, (foo, None, foo))
+
+ def testObjectTypeCheck(self):
+ self.assertRaises(ObjectTypeError,
+ self.store.add, (foo, foo, None))
diff --git a/testbed/RDFLib__rdflib/test_reports/rdflib_nquads-2013-12-22T19:22:34.ttl b/testbed/RDFLib__rdflib/test_reports/rdflib_nquads-2013-12-22T19:22:34.ttl
new file mode 100644
index 0000000000000000000000000000000000000000..344e186111dde9af8c0a4812bb6c71d51854c0ed
--- /dev/null
+++ b/testbed/RDFLib__rdflib/test_reports/rdflib_nquads-2013-12-22T19:22:34.ttl
@@ -0,0 +1,697 @@
+@prefix dc: .
+@prefix doap: .
+@prefix earl: .
+@prefix foaf: .
+@prefix rdf: .
+@prefix rdfs: .
+@prefix xml: .
+@prefix xsd: .
+
+ a foaf:Person ;
+ foaf:homepage ;
+ foaf:name "Gunnar Aastrand Grimnes" .
+
+ a doap:Project ;
+ doap:homepage ;
+ doap:name "rdflib" .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject ;
+ earl:test .
+
+[] a earl:Assertion ;
+ dc:date "2013-12-22T20:22:33.975728"^^xsd:dateTime ;
+ earl:assertedBy ;
+ earl:result [ a earl:TestResult ;
+ earl:outcome earl:passed ] ;
+ earl:subject