如何解决我的Python单元测试中AssertEqual和AssertNotEqual均失败
我在二叉树上有以下测试代码：
def test_deleteMin_root(self):
btree = BinaryTree()
min_value = self.person('AAKVIK','ANNE-MARIT','RISØYVEGEN 17','1705','SARPSBORG')
node = BinaryTreeNode(min_value)
btree.insert(value = min_value)
btree.insert(value = self.person('Zero','Zero','Zero street','1234','ZeroCity'))
btree.deleteMin()
self.assertEqual(node,btree.findMin())
我得到这个失败结果：
======================================================================
FAIL: test_deleteMin_root (__main__.BinaryTreeTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\Users\abdka\Documents\Programs\Python\PythonExercises\aicourse\test_binarytree.py",line 47,in test_deleteMin_root
self.assertEqual(node,btree.findMin())
AssertionError: <BinaryTreeNode.BinaryTreeNode object at 0x000001C7E33EFA00> != <BinaryTreeNode.BinaryTreeNode object at 0x000001C7EAB5A6D0>
当我在测试代码的最后一行中将AssertEqual更改为AssertNotEqual时（这是我唯一更改的内容）：
def test_deleteMin_root(self):
btree = BinaryTree()
min_value = self.person('AAKVIK','ZeroCity'))
btree.deleteMin()
self.assertNotEqual(node,btree.findMin())
我失败了：
======================================================================
FAIL: test_deleteMin_root (__main__.BinaryTreeTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\Users\abdka\Documents\Programs\Python\PythonExercises\aicourse\test_binarytree.py",in test_deleteMin_root
self.assertNotEqual(node,btree.findMin())
AssertionError: <BinaryTreeNode.BinaryTreeNode object at 0x000001C7EE3D4F10> == <BinaryTreeNode.BinaryTreeNode object at 0x000001C7E5DCAA00>
当我断言相等时，它表示它们不相等；当我断言不相等时，它表示它们是相等的。我不明白这是什么错误？我该如何解决？
这是完整的测试代码，BinaryTree代码和BinaryTreeNode代码：
二叉树代码：
from BinaryTreeNode import BinaryTreeNode
class BinaryTree:
def __init__(self,data = None):
self._root = None
if isinstance(data,BinaryTreeNode):
self._root = data
def findLeftMost(self,treenode):
left = treenode.left
if left == None:
return treenode
return self.findLeftMost(left)
def findMin(self):
return self.findLeftMost(self._root)
def findRightMost(self,treenode):
right = treenode.right
if right == None:
return treenode
return self.findRightMost(right)
def findMax(self):
return self.findRightMost(self._root)
def find(self,key,treenode = None):
if treenode == None:
treenode = self._root
if treenode == None:
return None
elif treenode.value > key:
if treenode.left:
return self.find(key,treenode.left)
elif treenode.value < key:
if treenode.right:
return self.find(key,treenode.right)
elif treenode.value == key:
return treenode
else:
raise KeyError("Key not found")
def _getnodes(self,current = None,treenode = None,value = None):
if current != None and treenode != None:
return current,treenode
if value == None:
if treenode == None:
raise Exception("Attempt to insert an empty space into Binary Tree")
else:
if treenode.value == None:
raise Exception("Attempt to insert an Node into Binary Tree with no key value")
else:
if treenode != None:
if treenode.value != None:
raise Exception("Key inconsistency detected")
else:
treenode = BinaryTreeNode(value)
if current == None:
current = self._root
return current,treenode
def insert(self,value = None):
if current == None:
current = self._root
# Checking consistency ...
current,treenode = self._getnodes(current,treenode,value)
if current != None:
if treenode.value < current.value:
treenode.level += 1
if current.left is None:
current.left = treenode
else:
self.insert(current.left,treenode)
elif treenode.value > current.value:
treenode.level += 1
if current.right is None:
current.right = treenode
else:
self.insert(current.right,treenode)
else:
if self._root == None:
treenode.level = 0
self._root = treenode
else:
raise Exception("Duplicate key: " + treenode.value)
else: # If empty tree,the first node entered is the root
self._root = treenode
return treenode
def deleteMin(self):
parent = self._root
while True:
# If a left branch exists - find the smallest item
current = parent.left
if current:
if current.left == None:
if current.right != None:
parent.left = current.right
return current
else:
parent.left = None
return current
else:
parent = current
# If no left branch exists,the root item is the smallest in the tree
else:
self._root = parent.right
return self._root
def deleteMax(self):
parent = self._root
while True:
current = parent.right
if current.right == None:
if current.left != None:
parent.right = current.left
return current
else:
parent.right = None
return current
else:
parent = current
def delete(self,key):
node = self.find(key)
delnode = node
if not node.left and not node.right:
node = None
elif node.right:
temptree = BinaryTree(node.right)
mintempnode = temptree.deleteMin()
node.value = mintempnode.value
elif node.left:
node = node.left
return delnode
二叉树节点代码：
class BinaryTreeNode:
def __init__(self,value,lefttree = None,righttree = None):
self.value = value
self.left = lefttree
self.right = righttree
self.level = 0
# Bruker setter/getters
@property
def value(self):
return self.__value
@value.setter
def value(self,value):
self.__value = value
@property
def left(self):
return self.__left
@left.setter
def left(self,lefttree):
self.__left = lefttree
@property
def right(self):
return self.__right
@right.setter
def right(self,righttree):
self.__right = righttree
@property
def level(self):
return self.__level
@level.setter
def level(self,level):
self.__level = level
def __str__(self):
return self.value
def hasRight(self):
if self.right == None:
return False
return True
#return self.right != None
def hasLeft(self):
if self.left == None:
return False
return True
#return self.left != None
def prefixOrder(self):
print(str(self.value),' ')
if self.hasLeft():
self.left.prefixOrder()
if self.hasRight():
self.right.prefixOrder()
def infixOrder(self):
if self.hasLeft():
self.left.infixOrder()
print(str(self.value),' ')
if self.hasRight():
self.right.infixOrder()
def postfixOrder(self):
if self.hasLeft():
self.left.postfixOrder()
if self.hasRight():
self.right.postfixOrder()
print(str(self.value),' ')
def levelOrder(self):
from queue import SimpleQueue
FIFOQueue = SimpleQueue()
FIFOQueue.put(self)
self.levelOrderEntry(FIFOQueue)
while not FIFOQueue.empty():
node = FIFOQueue.get()
print(str(node.value),' ')
def levelOrderEntry(self,queue):
if queue.empty():
return
node = queue.get()
print(str(node.value),' ')
if node.hasLeft():
queue.put(node.left)
if node.hasRight():
queue.put(node.right)
if node.hasLeft() or node.hasRight:
self.levelOrderEntry(queue)
def __eq__(self,other):
if other != None:
return self.value == other.value
elif other == None and self.value == None:
return True
return False
def __ne__(self,other):
if other != None:
if self.value == None:
return False
else:
return not self.value != other.value
return True
def __lt__(self,other):
if other != None:
return self.value < other.value
elif other == None and self.value == None:
return False
return False
def __le__(self,other):
if other != None:
return self.value <= other.value
elif other == None and self.value == None:
return False
return False
def __gt__(self,other):
if other != None:
return self.value > other.value
elif other == None and self.value == None:
return False
return False
def __ge__(self,other):
if other != None:
return self.value >= other.value
elif other == None and self.value == None:
return False
return False
完整的测试代码：
import unittest
from BinaryTree import BinaryTree
from BinaryTreeNode import BinaryTreeNode
from collections import namedtuple
class BinaryTreeTest(unittest.TestCase):
def setUp(self):
self.person = namedtuple('person',['lastname','firstname','address','postalcode','city'])
persons_file = open("Personer-kort.dta",'r')
content = persons_file.read()
content = content.splitlines()
self.binarytree = BinaryTree()
for p in content:
self.binarytree.insert(value = self.person(*p.split(';')))
persons_file.close()
def test_findMin(self):
min_value = self.person('AAKVIK','ANETTE','BAKLIEN 11','1360','NESBRU')
node = BinaryTreeNode(min_value)
self.assertEqual(node,self.binarytree.findMin())
def test_findMax(self):
max_value = self.person('ØYFOSS','ØISTEIN','ORHEIM 76','0367','OSLO')
node = BinaryTreeNode(max_value)
self.assertEqual(node,self.binarytree.findMax())
def test_deleteMin(self):
self.binarytree.deleteMin()
min_value = self.person('AAKVIK','SARPSBORG')
node = BinaryTreeNode(min_value)
self.assertEqual(node,self.binarytree.findMin())
def test_deleteMin_root(self):
btree = BinaryTree()
min_value = self.person('AAKVIK','SARPSBORG')
node = BinaryTreeNode(min_value)
btree.insert(value = min_value)
btree.insert(value = self.person('Zero','ZeroCity'))
btree.deleteMin()
self.assertNotEqual(node,btree.findMin())
def test_deleteMax(self):
self.binarytree.deleteMax()
max_value = self.person('ØYFOSS','WERNER STENVOLD','KIRKVOLL 28','5935','LAVIK')
node = BinaryTreeNode(max_value)
self.assertEqual(node,self.binarytree.findMax())
def test_find(self):
value = self.person('SKARSHAUG','ASBJØRN HARALD','ALAPMO 72','7290','STØREN')
node = BinaryTreeNode(value)
self.assertEqual(node,self.binarytree.find(value))
def test_find_key_not_found(self):
value = self.person('BORIS','JOHNSON','SOME STREET 72','LONDON')
self.assertEqual(None,self.binarytree.find(value))
self.assertRaises(KeyError,self.binarytree.find,value)
def test_delete(self):
value = self.person('SKARSHAUG',self.binarytree.find(value))
self.binarytree.delete(value)
self.assertEqual(None,self.binarytree.find(value))
def test_insert_value(self):
value1 = self.person('WIKILUND','JOHAN','SVETUN 11','8510','NARVIK')
node1 = BinaryTreeNode(value1)
value2 = self.person('ALFRED','POLLEN','gate 11','KONGSBERG')
node2 = BinaryTreeNode(value2)
self.binarytree.insert(value=value1)
self.binarytree.insert(value=value2)
self.assertEqual(node1,self.binarytree.find(value1))
self.assertEqual(node2,self.binarytree.find(value2))
def test_insert_node(self):
value1 = self.person('WIKILUND','KONGSBERG')
node2 = BinaryTreeNode(value2)
self.binarytree.insert(treenode=node1)
self.binarytree.insert(treenode=node2)
self.assertEqual(node1,self.binarytree.find(value2))
def test_insert_duplicate(self):
value = self.person('SKARSHAUG','STØREN')
self.assertRaisesRegex(Exception,"Duplicate key",self.binarytree.insert,[None,None,value])
def test_insert_empty_space(self):
self.assertRaisesRegex(Exception,"Attempt to insert an empty space into Binary Tree",None])
def test_insert_empty_node(self):
node = BinaryTreeNode(None)
self.assertRaisesRegex(Exception,"Attempt to insert an Node into Binary Tree with no key value",node,None])
def test_find_in_empty_tree(self):
tree = BinaryTree()
value = self.person('SKARSHAUG','STØREN')
self.assertEqual(None,tree.find(value))
if __name__ == '__main__':
import sys;sys.argv = ['','BinaryTreeTest']
unittest.main()
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。