changeset 1676:e6d28e6d47b2

update stmt_chunk_test for new bnode subtypes
author drewp@bigasterisk.com
date Wed, 22 Sep 2021 01:07:37 -0700
parents 3cf7f313b285
children aa35ae7a1acc
files service/mqtt_to_rdf/stmt_chunk_test.py
diffstat 1 files changed, 19 insertions(+), 19 deletions(-) [+]
line wrap: on
line diff
--- a/service/mqtt_to_rdf/stmt_chunk_test.py	Wed Sep 22 01:03:25 2021 -0700
+++ b/service/mqtt_to_rdf/stmt_chunk_test.py	Wed Sep 22 01:07:37 2021 -0700
@@ -1,3 +1,4 @@
+from inference_types import WorkingSetBnode
 import unittest
 
 from rdflib import Namespace, Variable
@@ -13,27 +14,27 @@
 class TestChunkedGraph(unittest.TestCase):
 
     def testMakesSimpleChunks(self):
-        cg = ChunkedGraph(N3(':a :b :c .'), functionsFor)
+        cg = ChunkedGraph(N3(':a :b :c .'), WorkingSetBnode, functionsFor)
 
         self.assertSetEqual(cg.chunksUsedByFuncs, set())
         self.assertSetEqual(cg.patternChunks, set())
         self.assertSetEqual(cg.staticChunks, set([Chunk((ROOM.a, ROOM.b, ROOM.c), subjList=None, objList=None)]))
 
     def testSeparatesPatternChunks(self):
-        cg = ChunkedGraph(N3('?x :b :c . :a ?y :c . :a :b ?z .'), functionsFor)
+        cg = ChunkedGraph(N3('?x :b :c . :a ?y :c . :a :b ?z .'), WorkingSetBnode, functionsFor)
         self.assertEqual(len(cg.patternChunks), 3)
 
     def testBoolMeansEmpty(self):
-        self.assertTrue(ChunkedGraph(N3(":a :b :c ."), functionsFor))
-        self.assertFalse(ChunkedGraph(N3(""), functionsFor))
+        self.assertTrue(ChunkedGraph(N3(":a :b :c ."), WorkingSetBnode, functionsFor))
+        self.assertFalse(ChunkedGraph(N3(""), WorkingSetBnode, functionsFor))
 
     def testContains(self):
         # If I write with assertIn, there's a seemingly bogus pytype error.
-        self.assert_(Chunk((ROOM.a, ROOM.b, ROOM.c)) in ChunkedGraph(N3(":a :b :c ."), functionsFor))
-        self.assert_(Chunk((ROOM.a, ROOM.b, ROOM.zzz)) not in ChunkedGraph(N3(":a :b :c ."), functionsFor))
+        self.assert_(Chunk((ROOM.a, ROOM.b, ROOM.c)) in ChunkedGraph(N3(":a :b :c ."), WorkingSetBnode, functionsFor))
+        self.assert_(Chunk((ROOM.a, ROOM.b, ROOM.zzz)) not in ChunkedGraph(N3(":a :b :c ."), WorkingSetBnode, functionsFor))
 
     def testNoPredicatesAppear(self):
-        cg = ChunkedGraph(N3(":a :b :c ."), functionsFor)
+        cg = ChunkedGraph(N3(":a :b :c ."), WorkingSetBnode, functionsFor)
         self.assertTrue(cg.noPredicatesAppear([ROOM.d, ROOM.e]))
         self.assertFalse(cg.noPredicatesAppear([ROOM.b, ROOM.d]))
 
@@ -41,22 +42,22 @@
 class TestListCollection(unittest.TestCase):
 
     def testSubjList(self):
-        cg = ChunkedGraph(N3('(:u :v) :b :c .'), functionsFor)
+        cg = ChunkedGraph(N3('(:u :v) :b :c .'), WorkingSetBnode, functionsFor)
         expected = Chunk((None, ROOM.b, ROOM.c), subjList=[ROOM.u, ROOM.v])
         self.assertEqual(cg.staticChunks, set([expected]))
 
     def testObjList(self):
-        cg = ChunkedGraph(N3(':a :b (:u :v) .'), functionsFor)
+        cg = ChunkedGraph(N3(':a :b (:u :v) .'), WorkingSetBnode, functionsFor)
         expected = Chunk((ROOM.a, ROOM.b, None), objList=[ROOM.u, ROOM.v])
         self.assertSetEqual(cg.staticChunks, set([expected]))
 
     def testVariableInListMakesAPatternChunk(self):
-        cg = ChunkedGraph(N3(':a :b (?x :v) .'), functionsFor)
+        cg = ChunkedGraph(N3(':a :b (?x :v) .'), WorkingSetBnode, functionsFor)
         expected = Chunk((ROOM.a, ROOM.b, None), objList=[Variable('x'), ROOM.v])
         self.assertSetEqual(cg.patternChunks, set([expected]))
 
     def testListUsedTwice(self):
-        cg = ChunkedGraph(N3('(:u :v) :b :c, :d .'), functionsFor)
+        cg = ChunkedGraph(N3('(:u :v) :b :c, :d .'), WorkingSetBnode, functionsFor)
 
         self.assertSetEqual(
             cg.staticChunks,
@@ -66,7 +67,7 @@
             ]))
 
     def testUnusedListFragment(self):
-        cg = ChunkedGraph(N3(':a rdf:first :b .'), functionsFor)
+        cg = ChunkedGraph(N3(':a rdf:first :b .'), WorkingSetBnode, functionsFor)
         self.assertFalse(cg)
 
 
@@ -79,11 +80,10 @@
         ret = list(
             applyChunky(self.binding,
                         g=[
-                           AlignedRuleChunk(ruleChunk=rule0, workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.xval))),
-                           AlignedRuleChunk(ruleChunk=rule1, workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.yval))),
+                            AlignedRuleChunk(ruleChunk=rule0, workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.xval))),
+                            AlignedRuleChunk(ruleChunk=rule1, workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.yval))),
                         ]))
-        self.assertCountEqual(
-            ret,
-            [
-                AlignedRuleChunk(ruleChunk=Chunk((ROOM.a, Variable('pred'), ROOM.xval)), workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.xval)))
-            ])
+        self.assertCountEqual(ret, [
+            AlignedRuleChunk(ruleChunk=Chunk((ROOM.a, Variable('pred'), ROOM.xval)),
+                             workingSetChunk=Chunk((ROOM.a, ROOM.b, ROOM.xval)))
+        ])