Membuat pengujian hierarki penelusuran

Membuat pengujian unit dengan kasus ekstrem untuk hierarki penelusuran biner

Anda dapat membuat kueri model secara langsung dan menguji hasil yang ditampilkan saat menggunakan parameter value yang berbeda dengan Konsol Cloud, atau dengan memanggil Vertex AI API secara langsung.

Petunjuk sistem

Anda adalah programmer berpengalaman, yang sangat memahami berbagai algoritma umum. Tugas Anda adalah membuat pengujian unit yang cukup mendetail untuk penerapan hierarki pencarian biner guna memastikan ketepatan penerapan class ini. Jangan menawarkan penjelasan, cukup buat pengujian unit.

Perintah Freeform

Saya memiliki implementasi kode hierarki penelusuran biner, tetapi saya tidak yakin apakah kode tersebut sudah benar. Untuk mengonfirmasinya, saya harap Anda dapat menulis pengujian unit untuk menguji setiap fungsi (kecuali fungsi pribadi) di class ini. Pengujian unit Anda harus menyertakan kasus ekstrem seperti melakukan operasi pada hierarki kosong dan menangani nilai duplikat. Selain itu, kode Anda harus berisi fungsi main.

bst.py

from dataclasses import dataclass
from typing import Optional

@dataclass
class TreeNode:
    value: int
    left: Optional['TreeNode'] = None
    right: Optional['TreeNode'] = None

class BST:
    def __init__(self):
        self.root: Optional[TreeNode] = None

    def insert(self, value: int) -> None:
        if not self.root:
            self.root = TreeNode(value)
        else:
            self._insert_helper(self.root, value)

    def _insert_helper(self, node: TreeNode, value: int) -> None:
        if value < node.value:
            if node.left is None:
                node.left = TreeNode(value)
            else:
                self._insert_helper(node.left, value)
        else:
            if node.right is None:
                node.right = TreeNode(value)
            else:
                self._insert_helper(node.right, value)

    def find(self, value: int) -> Optional[TreeNode]:
        return self._find_helper(self.root, value)

    def _find_helper(self, node: Optional[TreeNode], value: int) -> Optional[TreeNode]:
        if node is None or node.value == value:
            return node
        if value < node.value:
            return self._find_helper(node.left, value)
        return self._find_helper(node.right, value)

    def _lookup_min(self, node: TreeNode) -> TreeNode:
        current = node
        while current.left:
            current = current.left
        return current

    def print_inorder(self) -> None:
        self._print_inorder_helper(self.root)
        print()

    def _print_inorder_helper(self, node: Optional[TreeNode]) -> None:
        if node:
            self._print_inorder_helper(node.left)
            print(node.value, end=' ')
            self._print_inorder_helper(node.right)

Respons

import unittest
from bst import BST, TreeNode

class TestBST(unittest.TestCase):

    def test_insert_empty(self):
        bst = BST()
        bst.insert(5)
        self.assertEqual(bst.root.value, 5)

    def test_insert_multiple(self):
        bst = BST()
        bst.insert(5)
        bst.insert(3)
        bst.insert(7)
        bst.insert(1)
        bst.insert(4)
        bst.insert(6)
        bst.insert(8)
        self.assertEqual(bst.root.value, 5)
        self.assertEqual(bst.root.left.value, 3)
        self.assertEqual(bst.root.right.value, 7)

    def test_insert_duplicates(self):
        bst = BST()
        bst.insert(5)
        bst.insert(5)
        self.assertEqual(bst.root.value, 5)
        self.assertIsNone(bst.root.left)
        self.assertIsNone(bst.root.right)

    def test_find_empty(self):
        bst = BST()
        self.assertIsNone(bst.find(5))

    def test_find_present(self):
        bst = BST()
        bst.insert(5)
        bst.insert(3)
        bst.insert(7)
        self.assertEqual(bst.find(5).value, 5)
        self.assertEqual(bst.find(3).value, 3)
        self.assertEqual(bst.find(7).value, 7)

    def test_find_absent(self):
        bst = BST()
        bst.insert(5)
        bst.insert(3)
        bst.insert(7)
        self.assertIsNone(bst.find(1))
        self.assertIsNone(bst.find(9))

    def test_find_duplicates(self):
        bst = BST()
        bst.insert(5)
        bst.insert(5)
        self.assertEqual(bst.find(5).value, 5)

    def test_print_inorder_empty(self):
        bst = BST()
        bst.print_inorder()
        
    def test_print_inorder_non_empty(self):
        bst = BST()
        bst.insert(5)
        bst.insert(3)
        bst.insert(7)
        bst.insert(1)
        bst.insert(4)
        bst.insert(6)
        bst.insert(8)
        bst.print_inorder()


if __name__ == '__main__':
    unittest.main()
Model: gemini-1.5-flash-002
Suhu: 0,2
Token output maks: 8192
TopK: 40,0
TopP: 0,95