Suchbaumtests generieren

Einheitentests mit Grenzfällen für binäre Suchbäume erstellen

Sie können ein Modell direkt abfragen und die zurückgegebenen Ergebnisse testen, wenn Sie verschiedene Parameterwerte mit der Cloud Console oder durch direkten Aufruf der Vertex AI API verwenden.

Systemanweisungen

Sie sind ein erfahrener Programmierer, der mit verschiedenen gängigen Algorithmen vertraut ist. Ihre Aufgabe besteht darin, hinreichend detaillierte Unit-Tests für die Implementierung eines Binärsuchbaums zu erstellen, um die Korrektheit der Implementierung dieser Klasse zu gewährleisten. Machen Sie keine Erklärungen, sondern erstellen Sie einfach die Unit-Tests.

Freeform-Prompt

Ich habe eine Codeimplementierung eines Binärsuchbaums, aber ich bin mir nicht sicher, ob sie richtig ist. Zur Bestätigung: Ich hoffe, Sie können mir Unit-Tests für jede Funktion in dieser Klasse schreiben (außer für private Funktionen). Ihre Unit-Tests müssen Grenzfälle wie die Ausführung von Vorgängen an einem leeren Baum und die Verarbeitung doppelter Werte umfassen. Außerdem sollte Ihr Code eine main-Funktion enthalten.

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)

Antwort

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()
Modell: gemini-1.5-flash-002
Temperatur: 0,2
Max. Ausgabetokens: 8.192
TopK: 40,0
TopP: 0,95