def func():
# !! step2: change function name
s = Solution()
myFuncLis = [
s.middleNode,
]
onlyDisplayError = True
enableInput1 = True
enableInput2 = True
enableInput3 = True
enableInput4 = True
enableInput5 = True
enableInput6 = True
# !! step3: change input para, input para can be found in "run code" - "test case"
# ! para1
input1 = (
# binaryTree.buildTree(None)
# TODO
singleLinkedList.buildSingleList([1, 2, 3, 4, 5])
# nTree.buildTree(None)
)
expectedRlt1 = None
# ! para2
input2 = (
# binaryTree.buildTree(None)
None
# singleLinkedList.buildSingleList(None)
# nTree.buildTree(None)
)
expectedRlt2 = None
# ! para3
input3 = (
None
# singleLinkedList.buildSingleList(None)
# binaryTree.buildTree(None)
# nTree.buildTree(None)
)
expectedRlt3 = None
# ! para4
input4 = (
None
# singleLinkedList.buildSingleList(None)
# binaryTree.buildTree(None)
# nTree.buildTree(None)
)
expectedRlt4 = None
# ! para5
input5 = (
None
# singleLinkedList.buildSingleList(None)
# binaryTree.buildTree(None)
# nTree.buildTree(None)
)
expectedRlt5 = None
# ! para6
input6 = (
None
# singleLinkedList.buildSingleList(None)
# binaryTree.buildTree(None)
# nTree.buildTree(None)
)
expectedRlt6 = None
# !! ====================================
# instances that need an extra empty line
specialTypeLis = [TreeNode, Node]
# function and parameters count
allInput = [
(input1, enableInput1, expectedRlt1),
(input2, enableInput2, expectedRlt2),
(input3, enableInput3, expectedRlt3),
(input4, enableInput4, expectedRlt4),
(input5, enableInput5, expectedRlt5),
(input6, enableInput6, expectedRlt6),
]
if not input1 and not input2:
print("ERROR: please assign at least one input for input1 or input2!")
exit()
funcParaCnt = 1 if not isinstance(input1, tuple) else len(input1)
funcCnt = len(myFuncLis)
# for each input set
for inputPara, enableInput, expectedRlt in allInput:
if not enableInput or not inputPara: continue
inputPara1 = inputPara if not isinstance(inputPara,
tuple) else inputPara[0]
para1Splitter = '\n' if isOneInstance(inputPara1,
specialTypeLis) else '\t'
inputPara2 = None
para2Splitter = None
inputPara3 = None
para3Splitter = None
inputPara4 = None
para4Splitter = None
# start a new line if the parameter is a tree
if funcParaCnt >= 2:
inputPara2 = inputPara[1]
para2Splitter = '\n' if isOneInstance(inputPara2,
specialTypeLis) else '\t'
if funcParaCnt >= 3:
inputPara3 = inputPara[2]
para3Splitter = '\n' if isOneInstance(inputPara3,
specialTypeLis) else '\t'
if funcParaCnt >= 4:
inputPara4 = inputPara[3]
para4Splitter = '\n' if isOneInstance(inputPara4,
specialTypeLis) else '\t'
# for each function
for j in range(funcCnt):
print('==' * 20)
myFunc = myFuncLis[j]
# print('func: \t%s' % myFunc.__name__)
# output parameters
rlt = None
if funcParaCnt == 1:
rlt = myFunc(inputPara1)
if onlyDisplayError and expectedRlt is not None and expectedRlt == rlt:
continue
print('input1:%s%s' % (para1Splitter, inputPara1))
if funcParaCnt == 2:
rlt = myFunc(inputPara1, inputPara2)
if onlyDisplayError and expectedRlt is not None and expectedRlt == rlt:
continue
print('input1:%s%s' % (para1Splitter, inputPara1))
print('input2:%s%s' % (para2Splitter, inputPara2))
if funcParaCnt == 3:
rlt = myFunc(inputPara1, inputPara2, inputPara3)
if onlyDisplayError and expectedRlt is not None and expectedRlt == rlt:
continue
print('input1:%s%s' % (para1Splitter, inputPara1))
print('input2:%s%s' % (para2Splitter, inputPara2))
print('input3:%s%s' % (para3Splitter, inputPara3))
if funcParaCnt == 4:
rlt = myFunc(inputPara1, inputPara2, inputPara3, inputPara4)
if onlyDisplayError and expectedRlt is not None and expectedRlt == rlt:
continue
print('input1:%s%s' % (para1Splitter, inputPara1))
print('input2:%s%s' % (para2Splitter, inputPara2))
print('input3:%s%s' % (para3Splitter, inputPara3))
print('input4:%s%s' % (para4Splitter, inputPara4))
# output result
rltSplitter = '\n' if isOneInstance(rlt, specialTypeLis) else '\t'
print('rlt:%s%s' % (rltSplitter, rlt))
if expectedRlt is not None:
print('expRlt:%s%s' % (rltSplitter, expectedRlt))
# print('==' * 20)
print('==' * 20)
def func():
s = Solution()
# !! step2: change function name and para here
# !! input para can be found in "run code" - "test case"
myFuncLis = [
s.detectCycle,
]
inputParaLis1 = [
singleLinkedList.buildCycleList([3, 2, 0, -4], 1),
singleLinkedList.buildSingleList([1])
# binaryTree.buildTree([])
# nTree.buildTree([])
]
inputParaLis2 = [
None,
]
inputParaLis3 = [
None,
]
# !! ====================================
# ! instances that need an extra empty line
specialTypeLis = [TreeNode, Node]
# ! function and parameters count
inputSetCnt = len(inputParaLis1)
funcCnt = len(myFuncLis)
funcParaCnt = 1
if not inputParaLis3[0] is None:
funcParaCnt = 3
elif not inputParaLis2[0] is None:
funcParaCnt = 2
# ! for each input set
for i in range(inputSetCnt):
inputPara1 = inputParaLis1[i]
para1Splitter = '\n' if isOneInstance(inputPara1,
specialTypeLis) else '\t'
inputPara2 = None
para2Splitter = None
inputPara3 = None
para3Splitter = None
# ! start a new line if the parameter is a tree
if funcParaCnt >= 2:
inputPara2 = inputParaLis2[i]
para2Splitter = '\n' if isOneInstance(inputPara2,
specialTypeLis) else '\t'
if funcParaCnt >= 3:
inputPara3 = inputParaLis3[i]
para3Splitter = '\n' if isOneInstance(para3Splitter,
specialTypeLis) else '\t'
# ! for each function
for j in range(funcCnt):
myFunc = myFuncLis[j]
print('func: \t%s' % myFunc.__name__)
# ! output parameters
if funcParaCnt == 1:
print('input1:%s%s' % (para1Splitter, inputPara1))
rlt = myFunc(inputPara1)
if funcParaCnt == 2:
print('input1:%s%s' % (para1Splitter, inputPara1))
print('input2:%s%s' % (para2Splitter, inputPara2))
rlt = myFunc(inputPara1, inputPara2)
if funcParaCnt == 3:
print('input1:%s%s' % (para1Splitter, inputPara1))
print('input2:%s%s' % (para2Splitter, inputPara2))
print('input3:%s%s' % (para3Splitter, inputPara3))
rlt = myFunc(inputPara1, inputPara2, inputPara3)
# ! output result
rltSplitter = '\n' if isOneInstance(para3Splitter,
specialTypeLis) else '\t'
print('rlt:%s%s' % (rltSplitter, rlt))
print('==' * 20)
def func():
# !! step2: change function name
s = Solution()
myFuncLis = [
s.getIntersectionNode,
# optional: add another function for comparison
]
onlyDisplayError = True
enableInput = [True] * testCaseCnt
input = [None] * testCaseCnt
expectedRlt = [None] * testCaseCnt
# enableInput[0] = False
# enableInput[1] = False
# enableInput[2] = False
# enableInput[3] = False
# enableInput[4] = False
# enableInput[5] = False
# !! step3: change input para, input para can be found in "run code" - "test case"
# ! para1
input[0] = (
singleLinkedList.buildSingleList([4, 1, 8, 4, 5]),
singleLinkedList.buildSingleList([5, 6, 1, 8, 4, 5]),
)
expectedRlt[0] = None
# ! para2
input[1] = (singleLinkedList.buildSingleList(None), )
expectedRlt[1] = None
# ! para3
input[2] = (singleLinkedList.buildSingleList(None), )
expectedRlt[2] = None
# ! para4
input[3] = (singleLinkedList.buildSingleList(None), )
expectedRlt[3] = None
# ! para5
input[4] = (singleLinkedList.buildSingleList(None), )
expectedRlt[4] = None
# ! para6
input[5] = (singleLinkedList.buildSingleList(None), )
expectedRlt[5] = None
# !! ====================================
# function and parameters count
allInput = [(input[i], enableInput[i], expectedRlt[i])
for i in range(testCaseCnt)]
if not input[0]:
print("ERROR: please assign at least one input for input[0]!")
exit()
funcParaCnt = 1 if not isinstance(input[0], tuple) else len(input[0])
funcCnt = len(myFuncLis)
# for each test case
for inputPara, enableInput, expectedRlt in allInput:
if not enableInput or not inputPara or (isinstance(inputPara, tuple)
and not inputPara[0]):
continue
inputParaList = [None] * funcParaCnt
if not isinstance(inputPara, tuple):
inputPara = [inputPara]
for j in range(funcParaCnt):
inputParaList[j] = inputPara[j]
# for each function
for j in range(funcCnt):
print('==' * 20)
myFunc = myFuncLis[j]
# ! manually call function, max para count: 8
rlt = None
if funcParaCnt == 1:
rlt = myFunc(inputPara[0])
if funcParaCnt == 2:
rlt = myFunc(inputPara[0], inputPara[1])
if funcParaCnt == 3:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2])
if funcParaCnt == 4:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2],
inputPara[3])
if funcParaCnt == 5:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2],
inputPara[3], inputPara[4])
if funcParaCnt == 6:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2],
inputPara[3], inputPara[4], inputPara[5])
if funcParaCnt == 7:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2],
inputPara[3], inputPara[4], inputPara[5],
inputPara[6])
if funcParaCnt == 8:
rlt = myFunc(inputPara[0], inputPara[1], inputPara[2],
inputPara[3], inputPara[4], inputPara[5],
inputPara[6], inputPara[7])
# only output when the result is not expected
if onlyDisplayError and expectedRlt is not None and expectedRlt == rlt:
continue
# output function name
if funcCnt > 1:
print('func: \t%s' % myFunc.__name__)
# output para
for k in range(funcParaCnt):
para = inputParaList[k]
if para:
formatPrint('input %s:' % (k + 1), para)
else:
print(para)
# output result
print()
if not rlt:
print('rlt:\t', rlt)
else:
formatPrint('rlt:', rlt)
if expectedRlt is not None:
if not expectedRlt:
print('expRlt:\t', expectedRlt)
else:
formatPrint('expRlt:', expectedRlt)
print('==' * 20)