Membina Kalkulator Rentetan dengan Pembangunan Dipacu Ujian (TDD): Panduan Langkah demi Langkah

Kami akan melaksanakan kalkulator rentetan dalam Python menggunakan pendekatan pembangunan dipacu ujian (TDD). Ini bermakna kami akan menulis ujian untuk setiap ciri sebelum melaksanakan fungsi yang sepadan.

Anda boleh merujuk pautan https://osherove.com/tdd-kata-1 sebagai pusat pemeriksaan anda untuk melaksanakan TDD. Pautan menyediakan arahan langkah demi langkah yang boleh anda ikuti.

Bermula

Dalam folder projek anda, cipta dua fail: string_calculator.py dan tests/test_string_calculator.py. Kami akan melaksanakan ciri langkah demi langkah. Mula-mula, kita perlu mencipta kelas StringCalculator dengan kaedah tambah.

Langkah 1: Rentetan Kosong Harus Mengembalikan "0"

Mari kita tulis ujian pertama untuk aplikasi kita menggunakan perpustakaan unittest. Buka fail tests/test_string_calculator.py dan mulakan dengan kod berikut:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Sekarang, mari kita laksanakan kelas StringCalculator dalam fail string_calculator.py:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Untuk menjalankan ujian, ikut langkah berikut:

1. Pastikan anda berada dalam direktori projek tempat fail string_calculator.py dan tests/test_string_calculator.py anda berada.

2. Buka terminal atau gesaan arahan anda.

3. Jalankan arahan berikut untuk melaksanakan ujian:
   

python -m unittest discover tests

Arahan ini akan menemui dan menjalankan semua ujian secara automatik dalam folder ujian.

Output Jangkaan:

Anda sepatutnya melihat sesuatu seperti ini jika ujian itu lulus:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Jika semuanya disediakan dengan betul dan kes ujian lulus, ini bermakna pelaksanaan anda untuk mengendalikan rentetan kosong berfungsi seperti yang diharapkan.

Langkah 2: Menambah Satu atau Dua Nombor Harus Mengembalikan Jumlahnya

Kami perlu mengemas kini kaedah untuk mengendalikan kes di mana hanya terdapat satu nombor atau dua nombor dalam rentetan input, dan ia harus mengembalikan jumlahnya. Untuk rentetan kosong, kaedah harus mengembalikan 0.

Menulis Ujian

Buka fail tests/test_string_calculator.py dan tambahkan kes ujian berikut untuk merangkumi semua senario:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Melaksanakan Kod

Sekarang, kemas kini kaedah tambah dalam fail string_calculator.py untuk mengendalikan penambahan satu atau dua nombor:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Anda boleh menguji kod sekali lagi dengan mengikuti langkah sebelumnya.

Langkah 3 : Mengendalikan Nombor Berbilang

Kami akan menulis kes ujian untuk menyemak sama ada kaedah itu boleh mengendalikan berbilang nombor yang dipisahkan dengan koma.

Menulis Ujian

Buka fail tests/test_string_calculator.py dan tambahkan kes ujian untuk mengendalikan berbilang nombor:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Fungsi ini telah pun dilaksanakan, jadi kami boleh meneruskan untuk menguji kod dan kemudian meneruskan ke langkah seterusnya.

Langkah 4: Mengendalikan Garis Baharu Antara Nombor

Kini, kita perlu meningkatkan kaedah tambah untuk mengendalikan baris baharu (n) sebagai pemisah yang sah antara nombor, selain koma.

Menulis Ujian

Buka fail tests/test_string_calculator.py dan tambahkan kes ujian untuk menyemak sama ada kaedah mengendalikan baris baharu sebagai pemisah dengan betul:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Melaksanakan Kod

Seterusnya, kemas kini kaedah tambah dalam fail string_calculator.py untuk mengendalikan baris baharu (n) sebagai pemisah. Kita boleh mengubah suai kaedah untuk menggantikan n dengan koma, kemudian belah rentetan dengan koma.

Berikut ialah kod yang dikemas kini untuk kaedah tambah:

python -m unittest discover tests

Anda boleh menguji kod sekali lagi dengan mengikuti langkah sebelumnya yang ditakrifkan dalam langkah1.

Langkah 5: Mengendalikan Pembatas Tersuai

Dalam langkah ini, kami akan meningkatkan lagi fungsi untuk membenarkan pembatas tersuai. Sebagai contoh, pengguna harus dapat menentukan pembatas tersuai pada permulaan rentetan. Contohnya:

• Rentetan input boleh bermula dengan // diikuti dengan pembatas tersuai, cth., //;n1;2;3 harus mengembalikan 6.
• Kami akan menyokong pembatas seperti //;n1;2;3.

Menulis Ujian

Buka fail tests/test_string_calculator.py dan tambahkan kes ujian untuk mengendalikan fungsi pembatas tersuai:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Melaksanakan Kod

Untuk mengendalikan pembatas tersuai, kemas kini kaedah tambah untuk mencari pembatas dalam rentetan input. Pembatas hendaklah dinyatakan pada permulaan rentetan selepas //.

Berikut ialah kaedah tambah yang dikemas kini:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Langkah 6: Mengendalikan Nombor Negatif

Dalam langkah ini, kita perlu mengubah suai kaedah tambah untuk mengendalikan nombor negatif. Apabila nombor negatif diluluskan, ia harus membuang pengecualian dengan mesej "negatif tidak dibenarkan", dan memasukkan nombor negatif yang diluluskan.

Menulis Ujian

Buka fail tests/test_string_calculator.py dan tambahkan kes ujian untuk mengendalikan pengecualian nombor negatif:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Melaksanakan Kod

Sekarang, ubah suai kaedah tambah untuk menyemak nombor negatif dan naikkan ValueError dengan mesej yang sesuai.

Berikut ialah kaedah tambah yang dikemas kini:

def test_add_multiple_numbers(self):
    """
    Test case: Adding multiple numbers should return their sum.
    Input: "1,2,3,4,5"
    Expected Output: 15
    """
    self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)

Langkah 7: Mengira Panggilan Kaedah Tambah

Dalam langkah ini, kami akan menambah kaedah yang dipanggil GetCalledCount() ke kelas StringCalculator yang akan mengembalikan berapa kali kaedah add() telah digunakan. Kami akan mengikuti proses TDD dengan menulis ujian yang gagal dahulu, dan kemudian melaksanakan ciri tersebut.

Menulis Ujian

Mulakan dengan menambah kes ujian untuk kaedah GetCalledCount(). Ujian ini harus memastikan bahawa kaedah mengira dengan betul bilangan kali add() dipanggil.

Buka fail tests/test_string_calculator.py dan tambahkan ujian berikut:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Melaksanakan Kod

Sekarang, laksanakan kaedah GetCalledCount() dalam kelas StringCalculator. Kaedah ini perlu menjejaki berapa kali add() telah digunakan.

Berikut ialah kelas StringCalculator yang dikemas kini:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Langkah 8 & 9: Abaikan Nombor Lebih Besar Daripada 1000 dan Kendalikan Pembatas Tersuai Sebarang Panjang

Dalam langkah ini, kami akan melaksanakan dua keperluan:

1. Nombor lebih daripada 1000 harus diabaikan dalam jumlah.
2. Pembatas tersuai boleh dalam sebarang panjang, dengan format //[pembatas]n, dan kaedah harus mengendalikannya.

Kami akan menulis ujian untuk kedua-dua keperluan ini dahulu, kemudian melaksanakan fungsi dalam kelas StringCalculator.

Menulis Ujian

Tambahkan ujian berikut untuk kedua-dua nombor abaikan yang lebih besar daripada 1000 dan mengendalikan pembatas tersuai dengan sebarang panjang. Buka fail tests/test_string_calculator.py dan tambahkan yang berikut:

python -m unittest discover tests

Melaksanakan Kod

Sekarang, laksanakan fungsi dalam kelas StringCalculator. Ini termasuk:

1. Mengabaikan nombor yang lebih besar daripada 1000.
2. Mengendalikan pembatas tersuai untuk sebarang panjang.

Berikut ialah kelas StringCalculator yang dikemas kini:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Langkah 10: Sokongan Pembatas Berbilang

Dalam langkah ini, kami akan mengubah suai kaedah add() untuk menyokong berbilang pembatas bagi sebarang panjang. Ini akan membolehkan kami mengendalikan kes yang terdapat berbilang pembatas dalam format //[delimiter1][delimiter2]n.

Menulis Ujian

Mulakan dengan menambah kes ujian untuk menyemak berbilang pembatas. Buka fail tests/test_string_calculator.py dan tambahkan ujian berikut:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Melaksanakan Kod

Sekarang, ubah suai kaedah add() untuk mengendalikan berbilang pembatas. Pembatas akan dihantar ke dalam [] dan kami perlu menyokong pengendalian berbilang pembatas dalam format //[delimiter1][delimiter2]n.

Berikut ialah kelas StringCalculator yang dikemas kini untuk menyokong ini:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Menguji Ia

Jalankan ujian sekali lagi untuk mengesahkan bahawa semuanya berfungsi, termasuk keserasian ke belakang dengan format lama dan sokongan untuk format berbilang pembatas baharu:

def test_add_multiple_numbers(self):
    """
    Test case: Adding multiple numbers should return their sum.
    Input: "1,2,3,4,5"
    Expected Output: 15
    """
    self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)

Output yang Dijangka

Ujian harus lulus untuk kedua-dua format lama dan baharu:

def test_add_numbers_with_newlines(self):
    """
    Test case: Adding numbers separated by newlines should return their sum.
    Input: "1\n2\n3"
    Expected Output: 6
    """
    self.assertEqual(self.calculator.add("1\n2\n3"), 6)

Menghargai anda mengikuti siri TDD ini! Saya harap anda mendapati ia berguna.

Atas ialah kandungan terperinci Membina Kalkulator Rentetan dengan Pembangunan Dipacu Ujian (TDD): Panduan Langkah demi Langkah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!