def test_5(self, get_sln):
my_tree = _list_to_tree([1, 2, 2, None, 3, 3])
assert get_sln.isSymmetric(my_tree) == True
def test_3(self, get_sln):
my_tree = _list_to_tree([1, 2, 2, 2, None, 2])
assert get_sln.isSymmetric(my_tree) == False
def test_4(self, get_sln):
my_tree = _list_to_tree([])
assert get_sln.isSymmetric(my_tree) == True
def test_2(self, my_sln):
tree = _list_to_tree([0])
assert my_sln.maxDepth(tree) == 1
def test_1(self, get_sln):
input_list = []
assert get_sln.hasPathSum(_list_to_tree(input_list), 1) == False
def test_8(self, get_sln):
my_tree = _list_to_tree([3, 4, 4, 5, None, None, 5, 6, None, None, 6])
assert get_sln.isSymmetric(my_tree) == True
def test_5(self, get_sln) -> None:
input_list = [3, 9, 20, None, None, 15, 7]
assert get_sln.isBalanced(_list_to_tree(input_list)) == True
def test_2(self, get_sln):
input_list = [2]
assert get_sln.minDepth(_list_to_tree(input_list)) == 1
def test_3(self, get_sln):
input_list = [3, 9, 20, None, None, 15, 7]
assert get_sln.minDepth(_list_to_tree(input_list)) == 2
def test_3(self, my_sln):
test_input = [1, 1, 1]
ans = _list_to_tree([1, 1, 1])
assert my_sln.sortedArrayToBST(test_input) == ans
def test_4(self, my_sln):
test_input = [1, 2, 2, 2, 3]
print(ans := _list_to_tree([2, 2, 3, 1, None, 2, None]))
print(my_res := my_sln.sortedArrayToBST(test_input))
assert my_res == ans
def test_2(self, my_sln):
ans = _list_to_tree([2, 1, 3])
test_input = [1, 2, 3]
assert my_sln.sortedArrayToBST(test_input) == ans
def test_4(self, my_sln):
tree = _list_to_tree([1, None, 2])
assert my_sln.maxDepth(tree) == 2
def test_3(self, my_sln):
tree = _list_to_tree([3, 9, 20, None, None, 15, 7])
assert my_sln.maxDepth(tree) == 3
def test_6(self, get_sln):
my_tree = _list_to_tree([5, 4, 1, None, 1, None, 4, 2, None, 2, None])
assert get_sln.isSymmetric(my_tree) == False
def test_4(self, get_sln):
input_list = [2, None, 3, None, 4, None, 5, None, 6]
assert get_sln.minDepth(_list_to_tree(input_list)) == 5
def test_7(self, get_sln):
my_tree = _list_to_tree([2, 3, 3, 4, 5, 5, 4, None, None, 8, 9, 9, 8])
assert get_sln.isSymmetric(my_tree) == True
def test_3(self, get_sln):
input_list = [5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1]
assert get_sln.hasPathSum(_list_to_tree(input_list), 22) == True
def test_3(self, get_sln) -> None:
input_list = [1, 1, None]
assert get_sln.isBalanced(_list_to_tree(input_list)) == True
def test_4(self, get_sln):
input_list = [1, 2]
assert get_sln.hasPathSum(_list_to_tree(input_list), 0) == False
def test_4(self, get_sln) -> None:
input_list = [1, 2, 2, 3, 3, None, None, 4, 4]
assert get_sln.isBalanced(_list_to_tree(input_list)) == False
def test_1(self, get_sln):
my_tree = _list_to_tree([3, 9, 20, None, None, 15, 7])
assert get_sln.levelOrderBottom(my_tree) == [[15, 7], [9, 20], [3]]
