mirror of
https://github.com/monero-project/research-lab.git
synced 2024-12-22 11:39:32 +00:00
Unit test written (but failed) for vote()
This commit is contained in:
Brandon Goodell
parent
de324cfcf7
commit
4b13345207
1 changed files with 307 additions and 155 deletions
|
|
@ -27,79 +27,9 @@ class BlockHandler(object):
|
|||
self.antichainCutoff = 600 # stop re-orging after this many layers
|
||||
self.pendingVotes = {}
|
||||
self.votes = {}
|
||||
self.oldVotes = {}
|
||||
self.totalVotes = {}
|
||||
|
||||
def vote(self):
|
||||
U, V = self.leafBackAntichain()
|
||||
self.antichains = U
|
||||
touched = {}
|
||||
for i in range(len(U)):
|
||||
for vid in U[i]: # ID of voting block
|
||||
touched = self.sumPendingVote(vid, touched)
|
||||
for j in range(i+1):
|
||||
for xid in U[j]: # Voting block compares self to xid
|
||||
# Note if j=i, xid and vid are incomparable.
|
||||
# If j < i, then xid may have vid as an ancestor.
|
||||
# vid can never have xid as an ancestor.
|
||||
# In all cases, vid votes that vid precedes xid
|
||||
if xid==vid:
|
||||
continue
|
||||
else:
|
||||
touched = self.voteFor((vid,vid,xid),touched)
|
||||
# For each ancestor of xid that is not an ancestor of vid,
|
||||
# we can apply the same!
|
||||
q = deque()
|
||||
for pid in self.blocks[xid].parents:
|
||||
if pid in self.vids and not self._hasAncestor(vid,pid):
|
||||
q.append(pid)
|
||||
while(len(q)>0):
|
||||
wid = q.popleft()
|
||||
for pid in self.blocks[wid].parents:
|
||||
if pid in self.vids and not self._hasAncestor(vid, pid):
|
||||
q.append(pid)
|
||||
touched = self.voteFor((vid,vid,wid),touched)
|
||||
return touched
|
||||
|
||||
def sumPendingVote(self, vid, touched):
|
||||
for (xid,yid) in zip(self.vids,self.vids):
|
||||
if (vid, xid, yid) in self.pendingVotes:
|
||||
if self.pendingVotes[(vid,xid,yid)] > 0:
|
||||
touched = self.voteFor((vid,xid,yid), touched)
|
||||
elif self.pendingVotes[(vid,xid,yid)] <0:
|
||||
touched = self.voteFor((vid,yid,xid), touched)
|
||||
else:
|
||||
self.votes.update({(vid,xid,yid): 0, (vid,yid,xid): 0})
|
||||
touched.update({(vid,xid,yid): True, (vid,yid,xid): True})
|
||||
return touched
|
||||
|
||||
def voteFor(self, votingIdents, touched):
|
||||
(vid, xid, yid) = votingIdents
|
||||
self.votes.update({(vid,xid,yid):1, (vid,yid,xid):-1})
|
||||
touched.update({(vid,xid,yid):True, (vid,yid,xid):True})
|
||||
self.transmitVote((vid,xid,yid))
|
||||
return touched
|
||||
|
||||
def transmitVote(self, votingIdents):
|
||||
(vid, xid, yid) = votingIdents
|
||||
q = deque()
|
||||
for wid in self.blocks[vid].parents:
|
||||
if wid in self.vids:
|
||||
q.append(wid)
|
||||
while(len(q)>0):
|
||||
wid = q.popleft()
|
||||
if (wid,xid,yid) not in self.pendingVotes:
|
||||
self.pendingVotes.update({(wid,xid,yid):0})
|
||||
if (wid,yid,xid) not in self.pendingVotes:
|
||||
self.pendingVotes.update({(wid,yid,xid):0})
|
||||
self.pendingVotes[(wid,xid,yid)]+=1
|
||||
self.pendingVotes[(wid,yid,xid)]-=1
|
||||
#print(self.blocks[wid].parents)
|
||||
for pid in self.blocks[wid].parents:
|
||||
if pid in self.vids:
|
||||
q.append(pid)
|
||||
|
||||
|
||||
def _addBlock(self, b):
|
||||
def addBlock(self, b):
|
||||
#print("Adding block")
|
||||
# Take a single block b and add to self.blocks, record family
|
||||
# relations, update leaf monitor, update root monitor if nec-
|
||||
|
|
@ -173,8 +103,9 @@ class BlockHandler(object):
|
|||
self.leaves.append(b.ident)
|
||||
if b.ident not in self.family:
|
||||
self.family.update({b.ident:{"parents":{}, "children":{}}})
|
||||
|
||||
def _hasAncestor(self, xid, yid):
|
||||
pass
|
||||
|
||||
def hasAncestor(self, xid, yid):
|
||||
# Return true if y is an ancestor of x
|
||||
assert xid in self.blocks
|
||||
assert yid in self.blocks
|
||||
|
|
@ -195,7 +126,7 @@ class BlockHandler(object):
|
|||
found = True
|
||||
q.append(pid)
|
||||
return found
|
||||
|
||||
|
||||
def pruneLeaves(self):
|
||||
#print("Pruning leaves")
|
||||
out = BlockHandler()
|
||||
|
|
@ -205,7 +136,7 @@ class BlockHandler(object):
|
|||
while(len(q)>0):
|
||||
thisIdent = q.popleft()
|
||||
if thisIdent not in self.leaves:
|
||||
out._addBlock(self.blocks[thisIdent])
|
||||
out.addBlock(self.blocks[thisIdent])
|
||||
for chIdent in self.family[thisIdent]["children"]:
|
||||
q.append(chIdent)
|
||||
return out
|
||||
|
|
@ -231,6 +162,146 @@ class BlockHandler(object):
|
|||
temp = temp.pruneLeaves()
|
||||
return decomposition, vulnIdents
|
||||
|
||||
|
||||
def transmitVote(self, votingIdents):
|
||||
(vid, xid, yid) = votingIdents
|
||||
q = deque()
|
||||
for wid in self.blocks[vid].parents:
|
||||
if wid in self.vids:
|
||||
q.append(wid)
|
||||
while(len(q)>0):
|
||||
wid = q.popleft()
|
||||
if (wid,xid,yid) not in self.pendingVotes:
|
||||
self.pendingVotes.update({(wid,xid,yid):0})
|
||||
if (wid,yid,xid) not in self.pendingVotes:
|
||||
self.pendingVotes.update({(wid,yid,xid):0})
|
||||
self.pendingVotes[(wid,xid,yid)]+=1
|
||||
self.pendingVotes[(wid,yid,xid)]-=1
|
||||
#print(self.blocks[wid].parents)
|
||||
for pid in self.blocks[wid].parents:
|
||||
if pid in self.vids:
|
||||
q.append(pid)
|
||||
|
||||
def voteFor(self, votingIdents, touched):
|
||||
(vid, xid, yid) = votingIdents
|
||||
self.votes.update({(vid,xid,yid):1, (vid,yid,xid):-1})
|
||||
touched.update({(vid,xid,yid):True, (vid,yid,xid):True})
|
||||
self.transmitVote((vid,xid,yid))
|
||||
return touched
|
||||
|
||||
def sumPendingVote(self, vid, touched):
|
||||
pastR = self.pastOf(vid)
|
||||
for xid in self.vids:
|
||||
for yid in self.vids:
|
||||
if (vid, xid, yid) in self.pendingVotes:
|
||||
if self.pendingVotes[(vid,xid,yid)] > 0:
|
||||
touched = self.voteFor((vid,xid,yid), touched)
|
||||
elif self.pendingVotes[(vid,xid,yid)] <0:
|
||||
touched = self.voteFor((vid,yid,xid), touched)
|
||||
else:
|
||||
self.votes.update({(vid,xid,yid): 0, (vid,yid,xid): 0})
|
||||
touched.update({(vid,xid,yid): True, (vid,yid,xid): True})
|
||||
#R = self.pastOf(vid)
|
||||
#touched = R.vote(touched)
|
||||
|
||||
return touched
|
||||
|
||||
def vote(self,touchedIn={}):
|
||||
U, V = self.leafBackAntichain()
|
||||
self.antichains = U
|
||||
self.vids = V
|
||||
touched = touchedIn
|
||||
for i in range(len(U)):
|
||||
for vid in U[i]: # ID of voting block
|
||||
touched = self.sumPendingVote(vid, touched)
|
||||
for j in range(i+1):
|
||||
for xid in U[j]: # Voting block compares self to xid
|
||||
# Note if j=i, xid and vid are incomparable.
|
||||
# If j < i, then xid may have vid as an ancestor.
|
||||
# vid can never have xid as an ancestor.
|
||||
# In all cases, vid votes that vid precedes xid
|
||||
if xid==vid:
|
||||
continue
|
||||
else:
|
||||
touched = self.voteFor((vid,vid,xid),touched)
|
||||
# For each ancestor of xid that is not an ancestor of vid,
|
||||
# we can apply the same!
|
||||
q = deque()
|
||||
for pid in self.blocks[xid].parents:
|
||||
if pid in self.vids and not self.hasAncestor(vid,pid):
|
||||
q.append(pid)
|
||||
while(len(q)>0):
|
||||
wid = q.popleft()
|
||||
for pid in self.blocks[wid].parents:
|
||||
if pid in self.vids and not self.hasAncestor(vid, pid):
|
||||
q.append(pid)
|
||||
touched = self.voteFor((vid,vid,wid),touched)
|
||||
R = self.pastOf(vid)
|
||||
R.vote()
|
||||
for xid in R.blocks:
|
||||
touched = self.voteFor((vid,xid,vid), touched)
|
||||
for yid in R.blocks:
|
||||
if (xid, yid) in R.totalVotes:
|
||||
if R.totalVotes[(xid,yid)]:
|
||||
touched = self.voteFor((vid,xid,yid), touched)
|
||||
elif (yid, xid) in R.totalVotes:
|
||||
if R.totalVotes[(yid,xid)]:
|
||||
touched = self.voteFor((vid, yid, xid), touched)
|
||||
self.computeTotalVotes()
|
||||
|
||||
return touched
|
||||
|
||||
def computeTotalVotes(self):
|
||||
for xid in self.vids:
|
||||
for yid in self.vids:
|
||||
s = 0
|
||||
found = False
|
||||
for vid in self.vids:
|
||||
if (vid, xid, yid) in self.votes or (vid, yid, xid) in self.votes:
|
||||
found = True
|
||||
if self.votes[(vid, xid, yid)]==1:
|
||||
s+= 1
|
||||
elif self.votes[(vid,yid,xid)]==-1:
|
||||
s-= 1
|
||||
if found:
|
||||
if s > 0:
|
||||
self.totalVotes.update({(xid, yid):True, (yid,xid):False})
|
||||
elif s < 0:
|
||||
self.totalVotes.update({(xid,yid):False, (yid,xid):True})
|
||||
elif s==0:
|
||||
self.totalVotes.update({(xid,yid):False, (yid,xid):False})
|
||||
else:
|
||||
if (xid,yid) in self.totalVotes:
|
||||
del self.totalVotes[(xid,yid)]
|
||||
if (yid,xid) in self.totalVotes:
|
||||
del self.totalVotes[(yid,xid)]
|
||||
|
||||
def pastOf(self, xid):
|
||||
R = BlockHandler()
|
||||
identsToAdd = {}
|
||||
q = deque()
|
||||
for pid in self.blocks[xid].parents:
|
||||
q.append(pid)
|
||||
while(len(q)>0):
|
||||
yid = q.popleft()
|
||||
if yid not in identsToAdd:
|
||||
identsToAdd.update({yid:True})
|
||||
for pid in self.blocks[yid].parents:
|
||||
q.append(pid)
|
||||
for rid in self.roots:
|
||||
if rid in identsToAdd:
|
||||
q.append(rid)
|
||||
while(len(q)>0):
|
||||
yid = q.popleft()
|
||||
if yid not in R.blocks:
|
||||
R.addBlock(self.blocks[yid])
|
||||
for pid in self.family[yid]["children"]:
|
||||
if pid in identsToAdd:
|
||||
q.append(pid)
|
||||
return R
|
||||
|
||||
|
||||
|
||||
class Test_BlockHandler(unittest.TestCase):
|
||||
def test_betterTest(self):
|
||||
R = BlockHandler()
|
||||
|
|
@ -264,24 +335,24 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
block4 = Block(parentsIn=[block2.ident, block3.ident], dataIn={"timestamp":time.time(), "txns":"come here fido"})
|
||||
block5 = Block(parentsIn=[block3.ident], dataIn={"timestamp":time.time(), "txns":"applied rotation on her sugar plum"})
|
||||
block6 = Block(parentsIn=[block5.ident], dataIn={"timestamp":time.time(), "txns":"listen to frank zappa for the love of all that is good"})
|
||||
R._addBlock(block0)
|
||||
R.addBlock(block0)
|
||||
self.assertTrue(block0.ident in R.leaves)
|
||||
self.assertTrue(block0.ident in R.roots)
|
||||
|
||||
R._addBlock(block1)
|
||||
R.addBlock(block1)
|
||||
self.assertTrue(block1.ident in R.leaves and block0.ident not in R.leaves)
|
||||
R._addBlock(block2)
|
||||
R.addBlock(block2)
|
||||
self.assertTrue(block2.ident in R.leaves and block1.ident not in R.leaves)
|
||||
R._addBlock(block3)
|
||||
R.addBlock(block3)
|
||||
self.assertTrue(block3.ident in R.leaves and block2.ident in R.leaves and block1.ident not in R.leaves)
|
||||
|
||||
R._addBlock(block4)
|
||||
R.addBlock(block4)
|
||||
self.assertTrue(block4.ident in R.leaves and block3.ident not in R.leaves and block2.ident not in R.leaves)
|
||||
|
||||
R._addBlock(block5)
|
||||
R.addBlock(block5)
|
||||
self.assertTrue(block4.ident in R.leaves and block5.ident in R.leaves and block3.ident not in R.leaves)
|
||||
|
||||
R._addBlock(block6)
|
||||
R.addBlock(block6)
|
||||
self.assertTrue(block4.ident in R.leaves and block6.ident in R.leaves and block5.ident not in R.leaves)
|
||||
|
||||
self.assertEqual(len(R.blocks), 7)
|
||||
|
|
@ -293,54 +364,54 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
self.assertEqual(len(R.pendingVotes),0)
|
||||
self.assertEqual(len(R.votes),0)
|
||||
|
||||
self.assertTrue( R._hasAncestor(block6.ident, block0.ident) and not R._hasAncestor(block0.ident, block6.ident))
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block0.ident) and not R._hasAncestor(block0.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block4.ident, block0.ident) and not R._hasAncestor(block0.ident, block4.ident))
|
||||
self.assertTrue( R._hasAncestor(block3.ident, block0.ident) and not R._hasAncestor(block0.ident, block3.ident))
|
||||
self.assertTrue( R._hasAncestor(block2.ident, block0.ident) and not R._hasAncestor(block0.ident, block2.ident))
|
||||
self.assertTrue( R._hasAncestor(block1.ident, block0.ident) and not R._hasAncestor(block0.ident, block1.ident))
|
||||
self.assertTrue( R.hasAncestor(block6.ident, block0.ident) and not R.hasAncestor(block0.ident, block6.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block0.ident) and not R.hasAncestor(block0.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block4.ident, block0.ident) and not R.hasAncestor(block0.ident, block4.ident))
|
||||
self.assertTrue( R.hasAncestor(block3.ident, block0.ident) and not R.hasAncestor(block0.ident, block3.ident))
|
||||
self.assertTrue( R.hasAncestor(block2.ident, block0.ident) and not R.hasAncestor(block0.ident, block2.ident))
|
||||
self.assertTrue( R.hasAncestor(block1.ident, block0.ident) and not R.hasAncestor(block0.ident, block1.ident))
|
||||
|
||||
self.assertTrue( R._hasAncestor(block6.ident, block1.ident) and not R._hasAncestor(block1.ident, block6.ident))
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block1.ident) and not R._hasAncestor(block1.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block4.ident, block1.ident) and not R._hasAncestor(block1.ident, block4.ident))
|
||||
self.assertTrue( R._hasAncestor(block3.ident, block1.ident) and not R._hasAncestor(block1.ident, block3.ident))
|
||||
self.assertTrue( R._hasAncestor(block2.ident, block1.ident) and not R._hasAncestor(block1.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block1.ident) and R._hasAncestor(block1.ident, block0.ident))
|
||||
self.assertTrue( R.hasAncestor(block6.ident, block1.ident) and not R.hasAncestor(block1.ident, block6.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block1.ident) and not R.hasAncestor(block1.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block4.ident, block1.ident) and not R.hasAncestor(block1.ident, block4.ident))
|
||||
self.assertTrue( R.hasAncestor(block3.ident, block1.ident) and not R.hasAncestor(block1.ident, block3.ident))
|
||||
self.assertTrue( R.hasAncestor(block2.ident, block1.ident) and not R.hasAncestor(block1.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block1.ident) and R.hasAncestor(block1.ident, block0.ident))
|
||||
|
||||
self.assertTrue(not R._hasAncestor(block6.ident, block2.ident) and not R._hasAncestor(block2.ident, block6.ident))
|
||||
self.assertTrue(not R._hasAncestor(block5.ident, block2.ident) and not R._hasAncestor(block2.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block4.ident, block2.ident) and not R._hasAncestor(block2.ident, block4.ident))
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block2.ident) and not R._hasAncestor(block2.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block2.ident) and R._hasAncestor(block2.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block2.ident) and R._hasAncestor(block2.ident, block0.ident))
|
||||
self.assertTrue(not R.hasAncestor(block6.ident, block2.ident) and not R.hasAncestor(block2.ident, block6.ident))
|
||||
self.assertTrue(not R.hasAncestor(block5.ident, block2.ident) and not R.hasAncestor(block2.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block4.ident, block2.ident) and not R.hasAncestor(block2.ident, block4.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block2.ident) and not R.hasAncestor(block2.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block2.ident) and R.hasAncestor(block2.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block2.ident) and R.hasAncestor(block2.ident, block0.ident))
|
||||
|
||||
self.assertTrue( R._hasAncestor(block6.ident, block3.ident) and not R._hasAncestor(block3.ident, block6.ident))
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block3.ident) and not R._hasAncestor(block3.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block4.ident, block3.ident) and not R._hasAncestor(block3.ident, block4.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block3.ident) and not R._hasAncestor(block3.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block3.ident) and R._hasAncestor(block3.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block3.ident) and R._hasAncestor(block3.ident, block0.ident))
|
||||
self.assertTrue( R.hasAncestor(block6.ident, block3.ident) and not R.hasAncestor(block3.ident, block6.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block3.ident) and not R.hasAncestor(block3.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block4.ident, block3.ident) and not R.hasAncestor(block3.ident, block4.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block3.ident) and not R.hasAncestor(block3.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block3.ident) and R.hasAncestor(block3.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block3.ident) and R.hasAncestor(block3.ident, block0.ident))
|
||||
|
||||
self.assertTrue(not R._hasAncestor(block6.ident, block4.ident) and not R._hasAncestor(block4.ident, block6.ident))
|
||||
self.assertTrue(not R._hasAncestor(block5.ident, block4.ident) and not R._hasAncestor(block4.ident, block5.ident))
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block4.ident) and R._hasAncestor(block4.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block4.ident) and R._hasAncestor(block4.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block4.ident) and R._hasAncestor(block4.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block4.ident) and R._hasAncestor(block4.ident, block0.ident))
|
||||
self.assertTrue(not R.hasAncestor(block6.ident, block4.ident) and not R.hasAncestor(block4.ident, block6.ident))
|
||||
self.assertTrue(not R.hasAncestor(block5.ident, block4.ident) and not R.hasAncestor(block4.ident, block5.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block4.ident) and R.hasAncestor(block4.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block4.ident) and R.hasAncestor(block4.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block4.ident) and R.hasAncestor(block4.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block4.ident) and R.hasAncestor(block4.ident, block0.ident))
|
||||
|
||||
self.assertTrue( R._hasAncestor(block6.ident, block5.ident) and not R._hasAncestor(block5.ident, block6.ident))
|
||||
self.assertTrue(not R._hasAncestor(block4.ident, block5.ident) and not R._hasAncestor(block5.ident, block4.ident))
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block5.ident) and R._hasAncestor(block5.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block5.ident) and not R._hasAncestor(block5.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block5.ident) and R._hasAncestor(block5.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block5.ident) and R._hasAncestor(block5.ident, block0.ident))
|
||||
self.assertTrue( R.hasAncestor(block6.ident, block5.ident) and not R.hasAncestor(block5.ident, block6.ident))
|
||||
self.assertTrue(not R.hasAncestor(block4.ident, block5.ident) and not R.hasAncestor(block5.ident, block4.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block5.ident) and R.hasAncestor(block5.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block5.ident) and not R.hasAncestor(block5.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block5.ident) and R.hasAncestor(block5.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block5.ident) and R.hasAncestor(block5.ident, block0.ident))
|
||||
|
||||
self.assertTrue(not R._hasAncestor(block5.ident, block6.ident) and R._hasAncestor(block6.ident, block5.ident))
|
||||
self.assertTrue(not R._hasAncestor(block4.ident, block6.ident) and not R._hasAncestor(block6.ident, block4.ident))
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block6.ident) and R._hasAncestor(block6.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block6.ident) and not R._hasAncestor(block6.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block6.ident) and R._hasAncestor(block6.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block6.ident) and R._hasAncestor(block6.ident, block0.ident))
|
||||
self.assertTrue(not R.hasAncestor(block5.ident, block6.ident) and R.hasAncestor(block6.ident, block5.ident))
|
||||
self.assertTrue(not R.hasAncestor(block4.ident, block6.ident) and not R.hasAncestor(block6.ident, block4.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block6.ident) and R.hasAncestor(block6.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block6.ident) and not R.hasAncestor(block6.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block6.ident) and R.hasAncestor(block6.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block6.ident) and R.hasAncestor(block6.ident, block0.ident))
|
||||
|
||||
R = R.pruneLeaves()
|
||||
|
||||
|
|
@ -353,30 +424,30 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
self.assertEqual(len(R.pendingVotes),0)
|
||||
self.assertEqual(len(R.votes),0)
|
||||
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block0.ident) and not R._hasAncestor(block0.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block3.ident, block0.ident) and not R._hasAncestor(block0.ident, block3.ident))
|
||||
self.assertTrue( R._hasAncestor(block2.ident, block0.ident) and not R._hasAncestor(block0.ident, block2.ident))
|
||||
self.assertTrue( R._hasAncestor(block1.ident, block0.ident) and not R._hasAncestor(block0.ident, block1.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block0.ident) and not R.hasAncestor(block0.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block3.ident, block0.ident) and not R.hasAncestor(block0.ident, block3.ident))
|
||||
self.assertTrue( R.hasAncestor(block2.ident, block0.ident) and not R.hasAncestor(block0.ident, block2.ident))
|
||||
self.assertTrue( R.hasAncestor(block1.ident, block0.ident) and not R.hasAncestor(block0.ident, block1.ident))
|
||||
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block1.ident) and not R._hasAncestor(block1.ident, block5.ident))
|
||||
self.assertTrue( R._hasAncestor(block3.ident, block1.ident) and not R._hasAncestor(block1.ident, block3.ident))
|
||||
self.assertTrue( R._hasAncestor(block2.ident, block1.ident) and not R._hasAncestor(block1.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block1.ident) and R._hasAncestor(block1.ident, block0.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block1.ident) and not R.hasAncestor(block1.ident, block5.ident))
|
||||
self.assertTrue( R.hasAncestor(block3.ident, block1.ident) and not R.hasAncestor(block1.ident, block3.ident))
|
||||
self.assertTrue( R.hasAncestor(block2.ident, block1.ident) and not R.hasAncestor(block1.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block1.ident) and R.hasAncestor(block1.ident, block0.ident))
|
||||
|
||||
self.assertTrue(not R._hasAncestor(block5.ident, block2.ident) and not R._hasAncestor(block2.ident, block5.ident))
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block2.ident) and not R._hasAncestor(block2.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block2.ident) and R._hasAncestor(block2.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block2.ident) and R._hasAncestor(block2.ident, block0.ident))
|
||||
self.assertTrue(not R.hasAncestor(block5.ident, block2.ident) and not R.hasAncestor(block2.ident, block5.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block2.ident) and not R.hasAncestor(block2.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block2.ident) and R.hasAncestor(block2.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block2.ident) and R.hasAncestor(block2.ident, block0.ident))
|
||||
|
||||
self.assertTrue( R._hasAncestor(block5.ident, block3.ident) and not R._hasAncestor(block3.ident, block5.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block3.ident) and not R._hasAncestor(block3.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block3.ident) and R._hasAncestor(block3.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block3.ident) and R._hasAncestor(block3.ident, block0.ident))
|
||||
self.assertTrue( R.hasAncestor(block5.ident, block3.ident) and not R.hasAncestor(block3.ident, block5.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block3.ident) and not R.hasAncestor(block3.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block3.ident) and R.hasAncestor(block3.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block3.ident) and R.hasAncestor(block3.ident, block0.ident))
|
||||
|
||||
self.assertTrue(not R._hasAncestor(block3.ident, block5.ident) and R._hasAncestor(block5.ident, block3.ident))
|
||||
self.assertTrue(not R._hasAncestor(block2.ident, block5.ident) and not R._hasAncestor(block5.ident, block2.ident))
|
||||
self.assertTrue(not R._hasAncestor(block1.ident, block5.ident) and R._hasAncestor(block5.ident, block1.ident))
|
||||
self.assertTrue(not R._hasAncestor(block0.ident, block5.ident) and R._hasAncestor(block5.ident, block0.ident))
|
||||
self.assertTrue(not R.hasAncestor(block3.ident, block5.ident) and R.hasAncestor(block5.ident, block3.ident))
|
||||
self.assertTrue(not R.hasAncestor(block2.ident, block5.ident) and not R.hasAncestor(block5.ident, block2.ident))
|
||||
self.assertTrue(not R.hasAncestor(block1.ident, block5.ident) and R.hasAncestor(block5.ident, block1.ident))
|
||||
self.assertTrue(not R.hasAncestor(block0.ident, block5.ident) and R.hasAncestor(block5.ident, block0.ident))
|
||||
|
||||
|
||||
## Formal unit tests for leafBackAntichain() to follow: visual inspection reveals this does what it says on the tin.
|
||||
|
|
@ -394,13 +465,15 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
block4 = Block(parentsIn=[block2.ident, block3.ident], dataIn={"timestamp":time.time(), "txns":"come here fido"})
|
||||
block5 = Block(parentsIn=[block3.ident], dataIn={"timestamp":time.time(), "txns":"applied rotation on her sugar plum"})
|
||||
block6 = Block(parentsIn=[block5.ident], dataIn={"timestamp":time.time(), "txns":"listen to frank zappa for the love of all that is good"})
|
||||
R._addBlock(block0)
|
||||
R._addBlock(block1)
|
||||
R._addBlock(block2)
|
||||
R._addBlock(block3)
|
||||
R._addBlock(block4)
|
||||
R._addBlock(block5)
|
||||
R._addBlock(block6)
|
||||
R.addBlock(block0)
|
||||
R.addBlock(block1)
|
||||
R.addBlock(block2)
|
||||
R.addBlock(block3)
|
||||
R.addBlock(block4)
|
||||
R.addBlock(block5)
|
||||
R.addBlock(block6)
|
||||
|
||||
names = {0:block0.ident, 1:block1.ident, 2:block2.ident, 3:block3.ident, 4:block4.ident, 5:block5.ident, 6:block6.ident}
|
||||
|
||||
# Testing voteFor
|
||||
# Verify all roots have children
|
||||
|
|
@ -419,7 +492,7 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
|
||||
# Pick a random block with gcid in its past
|
||||
vid = random.choice(list(R.blocks.keys()))
|
||||
while(not R._hasAncestor(vid, gcid)):
|
||||
while(not R.hasAncestor(vid, gcid)):
|
||||
vid = random.choice(list(R.blocks.keys()))
|
||||
|
||||
# Pick a random pair of blocks for gcid and vid to vote on.
|
||||
|
|
@ -506,8 +579,87 @@ class Test_BlockHandler(unittest.TestCase):
|
|||
print("key = ", key, ", vote = ", R.votes[key])
|
||||
|
||||
print("\n ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ====")
|
||||
|
||||
#R.vote()
|
||||
for key in R.totalVotes:
|
||||
print("key = ", key, ", vote = ", R.totalVotes[key])
|
||||
print("\n ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ====")
|
||||
|
||||
self.assertTrue((names[0], names[1]) in R.totalVotes and (names[1], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[1])] and not R.totalVotes[(names[1], names[0])])
|
||||
|
||||
self.assertTrue((names[0], names[2]) in R.totalVotes and (names[2], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[2])] and not R.totalVotes[(names[2], names[0])])
|
||||
|
||||
self.assertTrue((names[0], names[3]) in R.totalVotes and (names[3], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[3])] and not R.totalVotes[(names[3], names[0])])
|
||||
|
||||
self.assertTrue((names[0], names[4]) in R.totalVotes and (names[4], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[4])] and not R.totalVotes[(names[4], names[0])])
|
||||
|
||||
self.assertTrue((names[0], names[5]) in R.totalVotes and (names[5], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[5])] and not R.totalVotes[(names[5], names[0])])
|
||||
|
||||
self.assertTrue((names[0], names[6]) in R.totalVotes and (names[6], names[0]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[0], names[6])] and not R.totalVotes[(names[6], names[0])])
|
||||
|
||||
#### #### #### ####
|
||||
|
||||
self.assertTrue((names[1], names[2]) in R.totalVotes and (names[2], names[1]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[1], names[2])] and not R.totalVotes[(names[2], names[1])])
|
||||
|
||||
self.assertTrue((names[1], names[3]) in R.totalVotes and (names[3], names[1]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[1], names[3])] and not R.totalVotes[(names[3], names[1])])
|
||||
|
||||
self.assertTrue((names[1], names[4]) in R.totalVotes and (names[4], names[1]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[1], names[4])] and not R.totalVotes[(names[4], names[1])])
|
||||
|
||||
self.assertTrue((names[1], names[5]) in R.totalVotes and (names[5], names[1]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[1], names[5])] and not R.totalVotes[(names[5], names[1])])
|
||||
|
||||
self.assertTrue((names[1], names[6]) in R.totalVotes and (names[6], names[1]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[1], names[6])] and not R.totalVotes[(names[6], names[1])])
|
||||
|
||||
#### #### #### ####
|
||||
|
||||
self.assertTrue((names[2], names[3]) in R.totalVotes and (names[3], names[2]) in R.totalVotes)
|
||||
self.assertTrue(not R.totalVotes[(names[2], names[3])] and R.totalVotes[(names[3], names[2])])
|
||||
|
||||
self.assertTrue((names[2], names[4]) in R.totalVotes and (names[4], names[2]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[2], names[4])] and not R.totalVotes[(names[4], names[2])])
|
||||
|
||||
self.assertTrue((names[2], names[5]) in R.totalVotes and (names[5], names[2]) in R.totalVotes)
|
||||
self.assertTrue(not R.totalVotes[(names[2], names[5])] and R.totalVotes[(names[5], names[2])])
|
||||
|
||||
self.assertTrue((names[2], names[6]) in R.totalVotes and (names[6], names[2]) in R.totalVotes)
|
||||
#print("2,6 ", R.totalVotes[(names[2], names[6])])
|
||||
#print("6,2 ", R.totalVotes[(names[6], names[2])])
|
||||
self.assertTrue(not R.totalVotes[(names[2], names[6])] and R.totalVotes[(names[6], names[2])])
|
||||
|
||||
#### #### #### ####
|
||||
|
||||
self.assertTrue((names[3], names[4]) in R.totalVotes and (names[4], names[3]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[3], names[4])] and not R.totalVotes[(names[4], names[3])])
|
||||
|
||||
self.assertTrue((names[3], names[5]) in R.totalVotes and (names[5], names[3]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[3], names[5])] and not R.totalVotes[(names[5], names[3])])
|
||||
|
||||
self.assertTrue((names[3], names[6]) in R.totalVotes and (names[6], names[3]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[3], names[6])] and not R.totalVotes[(names[6], names[3])])
|
||||
|
||||
#### #### #### ####
|
||||
|
||||
self.assertTrue((names[4], names[5]) in R.totalVotes and (names[5], names[4]) in R.totalVotes)
|
||||
self.assertTrue(not R.totalVotes[(names[4], names[5])] and R.totalVotes[(names[5], names[4])])
|
||||
|
||||
self.assertTrue((names[4], names[6]) in R.totalVotes and (names[6], names[4]) in R.totalVotes)
|
||||
self.assertTrue(not R.totalVotes[(names[4], names[6])] and R.totalVotes[(names[6], names[4])])
|
||||
|
||||
#### #### #### ####
|
||||
|
||||
self.assertTrue((names[5], names[6]) in R.totalVotes and (names[6], names[5]) in R.totalVotes)
|
||||
self.assertTrue(R.totalVotes[(names[5], names[6])] and not R.totalVotes[(names[6], names[5])])
|
||||
|
||||
|
||||
|
||||
#print(R.votes)
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue