fix thetest code theresome error 
""
import sys
import io
import contextlib

# The code to be tested (your solution)
code_to_test = '''
import sys

class Node:
    def __init__(self, val):
        self.val = val
        self.uid = None
        self.parent = None  
        self.child = [] 
        self.isLocked = False  
        self.locked_descendants = set()  # Set of locked descendant nodes

class Tree:
    def __init__(self, m, n, name_list):
        self.node_list = []
        self.node_map = {}
        for name in name_list:
            node = Node(name)
            self.node_list.append(node)
            self.node_map[name] = node

        # Build the tree
        for i in range(n):
            for j in range(m):
                child_index = m * i + j + 1
                if child_index < n:
                    self.node_list[i].child.append(self.node_list[child_index])
                    self.node_list[child_index].parent = self.node_list[i]

        self.root = self.node_list[0]

    def lock(self, node, uid):
        if node.isLocked:
            return False

        # Check if any ancestor is locked
        current = node.parent
        while current:
            if current.isLocked:
                return False
            current = current.parent

        # Check if any descendant is locked
        if node.locked_descendants:
            return False

        # Lock the node
        node.isLocked = True
        node.uid = uid

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.add(node)
            current = current.parent

        return True

    def unlock(self, node, uid):
        if not node.isLocked or node.uid != uid:
            return False

        # Unlock the node
        node.isLocked = False
        node.uid = None

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.remove(node)
            current = current.parent

        return True

    def upgrade(self, node, uid):
        if node.isLocked:
            return False

        # Check if any ancestor is locked
        current = node.parent
        while current:
            if current.isLocked:
                return False
            current = current.parent

        # Check if there is at least one locked descendant
        if not node.locked_descendants:
            return False

        # Collect all locked descendants
        locked_descendants = list(node.locked_descendants)

        # Check if all locked descendants have the same uid
        for ld in locked_descendants:
            if ld.uid != uid:
                return False

        # Unlock all locked descendants
        for ld in locked_descendants:
            ld.isLocked = False
            ld.uid = None
            node.locked_descendants.remove(ld)

            # Update locked_descendants for all ancestors of ld
            ancestor = ld.parent
            while ancestor:
                ancestor.locked_descendants.remove(ld)
                ancestor = ancestor.parent

        # Lock the current node
        node.isLocked = True
        node.uid = uid

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.add(node)
            current = current.parent

        return True

    def process_queries(self, queries):
        results = []
        for query in queries:
            parts = query.strip().split()
            if len(parts) != 3:
                results.append('false')
                continue
            operation, node_name, uid = parts
            uid = int(uid)
            node = self.node_map.get(node_name, None)
            if not node:
                results.append('false')
                continue
            if operation == "1":
                result = self.lock(node, uid)
            elif operation == "2":
                result = self.unlock(node, uid)
            elif operation == "3":
                result = self.upgrade(node, uid)
            else:
                result = False  # Invalid operation
            results.append('true' if result else 'false')
        return results

def main():
    n = int(sys.stdin.readline())
    m = int(sys.stdin.readline())
    q = int(sys.stdin.readline())
    name_list = [sys.stdin.readline().strip() for _ in range(n)]
    queries = [sys.stdin.readline().strip() for _ in range(q)]
    tree = Tree(m, n, name_list)
    results = tree.process_queries(queries)
    for res in results:
        print(res)

main()




'''

# List of test cases
test_cases = [
    {
        "description": "Test Case 1: Locking a Node When an Ancestor is Locked",
        "input": """7
2
2
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 Asia 1
1 China 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 2: Locking a Node When a Descendant is Locked",
        "input": """7
2
2
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 India 1
1 Asia 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 3: Unlocking a Node Locked by Another User",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
2 Child1 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 4: Unlocking a Node That Is Not Locked",
        "input": """3
2
1
Root
Child1
Child2
2 Child1 1
""",
        "expected_output": """false
"""
    },
    {
        "description": "Test Case 5: Upgrade Lock on an Already Locked Node",
        "input": """3
2
2
Root
Child1
Child2
1 Root 1
3 Root 1
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 6: Upgrade Lock with No Locked Descendants",
        "input": """3
2
1
Root
Child1
Child2
3 Root 1
""",
        "expected_output": """false
"""
    },
    {
        "description": "Test Case 7: Upgrade Lock When Not All Descendants Are Locked by the Same User",
        "input": """7
2
3
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 1
1 India 2
3 Asia 1
""",
        "expected_output": """true
true
false
"""
    },
    {
        "description": "Test Case 8: Successful Lock Operation with No Conflicts",
        "input": """3
2
1
Root
Child1
Child2
1 Child1 1
""",
        "expected_output": """true
"""
    },
    {
        "description": "Test Case 9: Unlocking a Node That Has Been Upgraded",
        "input": """7
2
5
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 9
1 India 9
3 Asia 9
2 India 9
2 Asia 9
""",
        "expected_output": """true
true
true
false
true
"""
    },
    {
        "description": "Test Case 10: Maximum Nodes with Upgrade Lock",
        "input": """15
2
8
Root
A
B
C
D
E
F
G
H
I
J
K
L
M
N
1 H 1
1 I 1
1 J 1
1 K 1
1 L 1
1 M 1
1 N 1
3 Root 1
""",
        "expected_output": """true
true
true
true
true
true
true
true
"""
    },
    {
        "description": "Test Case 11: Unlocking After Upgrade Lock",
        "input": """7
2
5
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 9
1 India 9
3 Asia 9
2 China 9
2 Asia 9
""",
        "expected_output": """true
true
true
false
true
"""
    },
    {
        "description": "Test Case 12: Locking an Already Locked Node",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
1 Child1 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 13: Re-locking an Unlocked Node",
        "input": """3
2
3
Root
Child1
Child2
1 Child1 1
2 Child1 1
1 Child1 2
""",
        "expected_output": """true
true
true
"""
    },
    {
        "description": "Test Case 14: Locking Sibling Nodes",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
1 Child2 2
""",
        "expected_output": """true
true
"""
    },
    {
        "description": "Test Case 15: Complex Upgrade and Lock Scenario",
        "input": """9
3
10
Root
A
B
C
D
E
F
G
H
1 D 1
1 E 1
1 F 2
3 B 1
1 G 1
3 Root 1
2 Root 1
1 H 2
1 A 2
3 Root 2
""",
        "expected_output": """true
true
true
false
true
false
false
true
false
false
"""
    },
    {
        "description": "Test Case 1: Locking a Node When an Ancestor is Locked",
        "input": """7
2
2
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 Asia 1
1 China 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 2: Locking a Node When a Descendant is Locked",
        "input": """7
2
2
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 India 1
1 Asia 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 3: Unlocking a Node Locked by Another User",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
2 Child1 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 4: Unlocking a Node That Is Not Locked",
        "input": """3
2
1
Root
Child1
Child2
2 Child1 1
""",
        "expected_output": """false
"""
    },
    {
        "description": "Test Case 5: Upgrade Lock on an Already Locked Node",
        "input": """3
2
2
Root
Child1
Child2
1 Root 1
3 Root 1
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 6: Upgrade Lock with No Locked Descendants",
        "input": """3
2
1
Root
Child1
Child2
3 Root 1
""",
        "expected_output": """false
"""
    },
    {
        "description": "Test Case 7: Upgrade Lock When Not All Descendants Are Locked by the Same User",
        "input": """7
2
3
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 1
1 India 2
3 Asia 1
""",
        "expected_output": """true
true
false
"""
    },
    {
        "description": "Test Case 8: Successful Lock Operation with No Conflicts",
        "input": """3
2
1
Root
Child1
Child2
1 Child1 1
""",
        "expected_output": """true
"""
    },
    {
        "description": "Test Case 9: Unlocking a Node That Has Been Upgraded",
        "input": """7
2
5
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 9
1 India 9
3 Asia 9
2 India 9
2 Asia 9
""",
        "expected_output": """true
true
true
false
true
"""
    },
    {
        "description": "Test Case 10: Maximum Nodes and Upgrade Lock",
        "input": """31
2
10
Root
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
AA
AB
AC
AD
1 Z 1
1 AA 1
1 AB 1
1 AC 1
1 AD 1
3 Root 1
1 E 2
1 F 2
1 G 2
3 Root 2
""",
        "expected_output": """
true
true
true
true
true
true
false
false
false
false
"""
    },
    {
        "description": "Test Case 11: Unlocking After Upgrade Lock",
        "input": """7
2
5
World
Asia
Africa
China
India
SouthAfrica
Egypt
1 China 9
1 India 9
3 Asia 9
2 China 9
2 Asia 9
""",
        "expected_output": """true
true
true
false
true
"""
    },
    {
        "description": "Test Case 12: Locking an Already Locked Node",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
1 Child1 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 13: Re-locking an Unlocked Node",
        "input": """3
2
3
Root
Child1
Child2
1 Child1 1
2 Child1 1
1 Child1 2
""",
        "expected_output": """true
true
true
"""
    },
    {
        "description": "Test Case 14: Locking Sibling Nodes",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
1 Child2 2
""",
        "expected_output": """true
true
"""
    },
    {
        "description": "Test Case 15: Complex Upgrade and Lock Scenario",
        "input": """9
3
10
Root
A
B
C
D
E
F
G
H
1 D 1
1 E 1
1 F 2
3 B 1
1 G 1
3 Root 1
2 Root 1
1 H 2
1 A 2
3 Root 2
""",
        "expected_output": """true
true
true
false
true
false
false
true
false
false
"""
    },
    {
        "description": "Test Case 16: Lock, Unlock, and Relock Sequence",
        "input": """5
2
6
Root
Child1
Child2
GrandChild1
GrandChild2
1 GrandChild1 1
2 GrandChild1 1
1 GrandChild1 2
1 Root 3
1 Child1 4
3 Root 3
""",
        "expected_output": """
true
true
true
false
false
false
"""
    },
    {
        "description": "Test Case 17: Locking with Maximum m (m=30)",
        "input": """31
30
2
Root
Node1
Node2
Node3
Node4
Node5
Node6
Node7
Node8
Node9
Node10
Node11
Node12
Node13
Node14
Node15
Node16
Node17
Node18
Node19
Node20
Node21
Node22
Node23
Node24
Node25
Node26
Node27
Node28
Node29
Node30
1 Node15 1
3 Root 1
""",
        "expected_output": """true
true
"""
    },
    {
        "description": "Test Case 18: Upgrade Lock with Mixed Users in Descendants",
        "input": """7
2
4
Root
Child1
Child2
GrandChild1
GrandChild2
GrandChild3
GrandChild4
1 GrandChild1 1
1 GrandChild2 2
3 Child1 1
3 Root 1
""",
        "expected_output": """true
true
false
false
"""
    },
    {
        "description": "Test Case 19: Repeated Lock and Unlock on the Same Node",
        "input": """3
2
5
Root
Child1
Child2
1 Child1 1
2 Child1 1
1 Child1 1
2 Child1 1
1 Child1 1
""",
        "expected_output": """true
true
true
true
true
"""
    },
    {
        "description": "Test Case 20: Locking Nodes with the Same User",
        "input": """5
2
3
Root
Child1
Child2
GrandChild1
GrandChild2
1 GrandChild1 1
1 GrandChild2 1
1 Root 1
""",
        "expected_output": """true
true
false
"""
    },
    {
        "description": "Test Case 21: Attempt to Lock Ancestor After Locking Descendant",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
1 Root 1
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 22: Attempt to Lock Descendant After Locking Ancestor",
        "input": """3
2
2
Root
Child1
Child2
1 Root 1
1 Child1 1
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 23: Unlocking Node Locked with Different User ID",
        "input": """3
2
2
Root
Child1
Child2
1 Child1 1
2 Child1 2
""",
        "expected_output": """true
false
"""
    },
    {
        "description": "Test Case 24: Upgrade Lock with No Locked Descendants",
        "input": """3
2
1
Root
Child1
Child2
3 Child1 1
""",
        "expected_output": """false
"""
    },
    {
        "description": "Test Case 25: Locking All Descendants and Then Ancestor",
        "input": """7
2
5
Root
Child1
Child2
GrandChild1
GrandChild2
GrandChild3
GrandChild4
1 GrandChild1 1
1 GrandChild2 1
1 GrandChild3 1
1 GrandChild4 1
3 Root 1
""",
        "expected_output": """true
true
true
true
true
"""
    },
    {
        "description": "Test Case 26: Unlocking After Upgrading Lock",
        "input": """3
2
5
Root
Child1
Child2
1 Child1 1
1 Child2 1
3 Root 1
2 Child1 1
2 Root 1
""",
        "expected_output": """
true
true
true
false
true
"""
    },
    {
        "description": "Test Case 27: Upgrade Lock by Different User",
        "input": """3
2
3
Root
Child1
Child2
1 Child1 1
1 Child2 1
3 Root 2
""",
        "expected_output": """true
true
false
"""
    },
    {
        "description": "Test Case 28: Locking Nodes After Unlocking Ancestor",
        "input": """7
2
5
Root
Child1
Child2
GrandChild1
GrandChild2
GrandChild3
GrandChild4
1 Root 1
2 Root 1
1 GrandChild1 2
1 GrandChild2 2
1 Child1 2
""",
        "expected_output": """true
true
true
true
false
"""
    },
    {
        "description": "Test Case 29: Locking and Unlocking with Multiple Users",
        "input": """5
2
6
Root
Child1
Child2
GrandChild1
GrandChild2
1 GrandChild1 1
1 GrandChild2 2
1 Child1 3
2 GrandChild1 1
1 Child1 3
3 Root 1
""",
        "expected_output": """true
true
false
true
false
false
"""
    },
    {
        "description": "Test Case 30: Edge Case with m=1 (Linked List Tree)",
        "input": """5
1
5
Root
Node1
Node2
Node3
Node4
1 Node4 1
1 Node2 2
2 Node4 1
1 Node2 2
1 Root 3
""",
        "expected_output": """true
false
true
true
false
"""
    },

]

# Function to run the test case
def run_test_case(code, test_input):
    # Redirect stdin and stdout
    old_stdin = sys.stdin
    old_stdout = sys.stdout
    sys.stdin = io.StringIO(test_input)
    sys.stdout = io.StringIO()
    namespace = {}
    
    try:
        exec(code, namespace)
        output = sys.stdout.getvalue()
    except Exception as e:
        output = f"Error: {e}"
    finally:
        # Restore stdin and stdout
        sys.stdin = old_stdin
        sys.stdout = old_stdout
    
    return output.strip()

# Main testing function
def test_code_on_test_cases():
    all_passed = True
    for idx, test in enumerate(test_cases, 1):
        print(f"Running {test['description']}")
        output = run_test_case(code_to_test, test['input'])
        expected_output = test['expected_output'].strip()
        if output == expected_output:
            print(f"Test Case {idx} Passed\n")
        else:
            print(f"Test Case {idx} Failed")
            print("Expected Output:")
            print(expected_output)
            print("Actual Output:")
            print(output)
            print()
            all_passed = False
    if all_passed:
        print("All test cases passed!")
    else:
        print("Some test cases failed. Please review your code.")

# Run the tests
test_code_on_test_cases()

"""
(base) asvinir@Asvinis-MacBook-Air learnDsa % /opt/homebrew/bin/python3 "/Users/asvinir/Library/Mobile Documents/com~apple~CloudDocs/Downloads/lea
rnDsa/PartA/test.py"
Running Test Case 1: Locking a Node When an Ancestor is Locked
Test Case 1 Passed

Running Test Case 2: Locking a Node When a Descendant is Locked
Test Case 2 Passed

Running Test Case 3: Unlocking a Node Locked by Another User
Test Case 3 Passed

Running Test Case 4: Unlocking a Node That Is Not Locked
Test Case 4 Passed

Running Test Case 5: Upgrade Lock on an Already Locked Node
Test Case 5 Passed

Running Test Case 6: Upgrade Lock with No Locked Descendants
Test Case 6 Passed

Running Test Case 7: Upgrade Lock When Not All Descendants Are Locked by the Same User
Test Case 7 Passed

Running Test Case 8: Successful Lock Operation with No Conflicts
Test Case 8 Passed

Running Test Case 9: Unlocking a Node That Has Been Upgraded
Test Case 9 Failed
Expected Output:
true
true
true
false
true
Actual Output:
Error: <Node object at 0x10044dc40>

Running Test Case 10: Maximum Nodes with Upgrade Lock
Test Case 10 Failed
Expected Output:
true
true
true
true
true
true
true
true
Actual Output:
Error: <Node object at 0x10043fe60>

Running Test Case 11: Unlocking After Upgrade Lock
Test Case 11 Failed
Expected Output:
true
true
true
false
true
Actual Output:
Error: <Node object at 0x10044dca0>

Running Test Case 12: Locking an Already Locked Node
Test Case 12 Passed

Running Test Case 13: Re-locking an Unlocked Node
Test Case 13 Passed

Running Test Case 14: Locking Sibling Nodes
Test Case 14 Passed

Running Test Case 15: Complex Upgrade and Lock Scenario
Test Case 15 Passed

Running Test Case 1: Locking a Node When an Ancestor is Locked
Test Case 16 Passed

Running Test Case 2: Locking a Node When a Descendant is Locked
Test Case 17 Passed

Running Test Case 3: Unlocking a Node Locked by Another User
Test Case 18 Passed

Running Test Case 4: Unlocking a Node That Is Not Locked
Test Case 19 Passed

Running Test Case 5: Upgrade Lock on an Already Locked Node
Test Case 20 Passed

Running Test Case 6: Upgrade Lock with No Locked Descendants
Test Case 21 Passed

Running Test Case 7: Upgrade Lock When Not All Descendants Are Locked by the Same User
Test Case 22 Passed

Running Test Case 8: Successful Lock Operation with No Conflicts
Test Case 23 Passed

Running Test Case 9: Unlocking a Node That Has Been Upgraded
Test Case 24 Failed
Expected Output:
true
true
true
false
true
Actual Output:
Error: <Node object at 0x10044f320>

Running Test Case 10: Maximum Nodes and Upgrade Lock
Test Case 25 Failed
Expected Output:
true
true
true
true
true
true
false
false
false
false
Actual Output:
Error: <Node object at 0x10044fc80>

Running Test Case 11: Unlocking After Upgrade Lock
Test Case 26 Failed
Expected Output:
true
true
true
false
true
Actual Output:
Error: <Node object at 0x10043fe00>

Running Test Case 12: Locking an Already Locked Node
Test Case 27 Passed

Running Test Case 13: Re-locking an Unlocked Node
Test Case 28 Passed

Running Test Case 14: Locking Sibling Nodes
Test Case 29 Passed

Running Test Case 15: Complex Upgrade and Lock Scenario
Test Case 30 Passed

Running Test Case 16: Lock, Unlock, and Relock Sequence
Test Case 31 Passed

Running Test Case 17: Locking with Maximum m (m=30)
Test Case 32 Failed
Expected Output:
true
true
Actual Output:
Error: <Node object at 0x10044e270>

Running Test Case 18: Upgrade Lock with Mixed Users in Descendants
Test Case 33 Passed

Running Test Case 19: Repeated Lock and Unlock on the Same Node
Test Case 34 Passed

Running Test Case 20: Locking Nodes with the Same User
Test Case 35 Passed

Running Test Case 21: Attempt to Lock Ancestor After Locking Descendant
Test Case 36 Passed

Running Test Case 22: Attempt to Lock Descendant After Locking Ancestor
Test Case 37 Passed

Running Test Case 23: Unlocking Node Locked with Different User ID
Test Case 38 Passed

Running Test Case 24: Upgrade Lock with No Locked Descendants
Test Case 39 Passed

Running Test Case 25: Locking All Descendants and Then Ancestor
Test Case 40 Failed
Expected Output:
true
true
true
true
true
Actual Output:
Error: <Node object at 0x10044db80>

Running Test Case 26: Unlocking After Upgrading Lock
Test Case 41 Failed
Expected Output:
true
true
true
false
true
Actual Output:
Error: <Node object at 0x10044ef00>

Running Test Case 27: Upgrade Lock by Different User
Test Case 42 Passed

Running Test Case 28: Locking Nodes After Unlocking Ancestor
Test Case 43 Passed

Running Test Case 29: Locking and Unlocking with Multiple Users
Test Case 44 Passed

Running Test Case 30: Edge Case with m=1 (Linked List Tree)
Test Case 45 Passed

Some test cases failed. Please review your code.