Bỏ qua tới nội dung chính

Trước khi có kiểm thử có hệ thống

Kiểm thử phần mềm: tìm ra lỗi trước người dùng

Kiểm thử phần mềm là gì ngoài chạy thử: kiểm thử đơn vị, giá trị biên, kiểm thử theo tính chất, độ phủ, kim tự tháp kiểm thử — và nên bắt đầu học từ đâu.

Ban biên tập OpenER

Cập nhật 18/11/2026 · 19 phút đọc · CC BY 4.0

Bạn sửa một dòng code trong trang bán hàng, mở trình duyệt bấm thử, thấy giỏ hàng vẫn cộng đúng, rồi đưa lên. Tối hôm đó một khách nhắn: mã giảm giá bị trừ hai lần. Một khách khác: đặt 0 sản phẩm mà vẫn thanh toán được. Không ai trong số họ làm gì lạ — họ chỉ dùng phần mềm theo những cách bạn chưa thử.

Ai viết code cũng có chạy thử. Nhưng chạy vài lần với những đầu vào mình tự nghĩ ra thường chỉ xác nhận điều mình đã tin. Kiểm thử phần mềm (software testing) là làm việc đó có phương pháp, để phần lớn lỗi bị chính người viết tìm ra, chứ không phải khách hàng.

Trước khi có kiểm thử có hệ thống

Thời những máy tính đầu tiên, kiểm thử và gỡ lỗi là một việc: người viết tự chạy chương trình, thấy sai thì sửa, ra kết quả thì coi là xong. Chương trình nhỏ, người dùng thường là chính người viết, nên cách đó tạm ổn. Khi phần mềm lớn lên — hàng trăm nghìn dòng, hàng chục người cùng viết, chạy cho ngân hàng và hãng bay — "chạy thử thấy được" không còn đủ; bài Nhập môn công nghệ phần mềm kể về giai đoạn đó. Kiểm thử thành một nghề riêng qua từng bước:

  1. Đổi mục đích: đi tìm lỗi — năm 1979, Glenford Myers viết The Art of Software Testing, với một định nghĩa đổi cách nghĩ của cả nghề: kiểm thử là chạy chương trình với ý định tìm ra lỗi. Người muốn chứng tỏ code chạy được sẽ chọn đầu vào dễ; người muốn làm nó hỏng sẽ chọn đầu vào khó. Ca kiểm thử tốt là ca có nhiều khả năng lộ ra một lỗi chưa ai thấy.
  2. Kiểm thử thành code — năm 1997, trên chuyến bay từ Zurich tới hội nghị OOPSLA ở Atlanta, Kent Beck và Erich Gamma cùng viết bản đầu tiên của JUnit, bộ khung kiểm thử cho Java, theo mẫu một bộ khung Beck làm trước đó cho Smalltalk. Kiểm thử không còn là danh sách việc bấm tay mà là code, chạy lại toàn bộ bằng một lệnh. Họ hàng của nó, gọi chung là xUnit, có ở gần như mọi ngôn ngữ — thư viện unittest có sẵn trong Python cũng làm theo mẫu JUnit.
  3. Viết kiểm thử trước — cuối thập niên 1990, Beck đề xướng Lập trình cực hạn (Extreme Programming), rồi viết cuốn Test-Driven Development: By Example (2002) về phát triển hướng kiểm thử (TDD): viết kiểm thử trước, code sau. Cùng thời, tích hợp liên tục (continuous integration) phổ biến dần: mỗi lần có người đổi code, máy chủ tự chạy toàn bộ kiểm thử.
  4. Để máy nghĩ ra ca kiểm thử — năm 2000, Koen Claessen và John Hughes giới thiệu QuickCheck cho ngôn ngữ Haskell: người viết chỉ nêu tính chất mà kết quả phải thỏa, máy tự sinh hàng trăm đầu vào ngẫu nhiên để tìm phản ví dụ.

Có kiểm thử chưa đủ — phải thử đúng chỗ. Ngày 4 tháng 6 năm 1996, tên lửa Ariane 5 của châu Âu bay chuyến đầu tiên, mang theo bốn vệ tinh khoa học Cluster. Khoảng 37 giây sau khi động cơ chính khởi động, tên lửa chệch hướng, vỡ ra và tự hủy. Nguyên nhân nằm trong phần mềm dẫn đường quán tính dùng lại từ Ariane 4: một phép đổi số thực 64 bit sang số nguyên 16 bit có dấu — loại chỉ chứa được từ −32.768 tới 32.767 — bị tràn, vì Ariane 5 tăng tốc theo phương ngang nhanh hơn Ariane 4 nhiều. Trên Ariane 4 con số đó chưa bao giờ vượt ngưỡng, nên phép đổi được để không bảo vệ. Bộ dẫn đường dự phòng chạy cùng phần mềm nên hỏng theo đúng cách đó. Báo cáo điều tra ghi rõ: dữ liệu quỹ đạo của Ariane 5 không có trong đặc tả của khối dẫn đường, và trong các lần mô phỏng cả hệ thống, khối này được thay bằng tín hiệu giả lập. Nếu thử với khối thật, lỗi đã có thể lộ ra trên mặt đất.

Máy xạ trị Therac-25, đã nhắc trong bài Hệ điều hành, cũng dùng lại phần mềm của đời máy trước — nơi khóa an toàn bằng phần cứng từng che đi lỗi. Code "chạy tốt bao năm" chỉ có nghĩa là nó chạy tốt trong hoàn cảnh cũ.

Đặt cạnh nhau:

Chạy thử cho có
Kiểm thử có hệ thống
Chọn đầu vào
Vài giá trị dễ, nghĩ ra lúc đó
Theo phương pháp: từng lớp đầu vào, từng ranh giới, cả đầu vào ngẫu nhiên
Kết quả đúng
"Trông có vẻ đúng"
Tính trước từ đặc tả, máy so từng con số
Sau mỗi lần sửa
Bấm lại vài chỗ còn nhớ
Chạy lại hàng nghìn kiểm thử trong vài phút
Ai tìm ra lỗi
Người dùng
Phần lớn là người viết và máy chủ tích hợp
Sửa code cũ
Ngại, sợ hỏng chỗ khác
Sửa xong chạy kiểm thử là biết

Ngày nay, nơi "chạy thử cho có" còn phổ biến nhất có lẽ là bảng tính. Như bài Lập trình đã nói, một công thức Excel là một chương trình nhỏ — nhưng gần như không ai kiểm thử nó. Năm 2010, hai nhà kinh tế Carmen Reinhart và Kenneth Rogoff công bố một nghiên cứu về nợ công được dẫn rộng rãi trong tranh luận chính sách. Năm 2013, Thomas Herndon, nghiên cứu sinh ở Đại học Massachusetts Amherst, làm lại phép tính cho một bài tập trên lớp và phát hiện, cùng vài vấn đề khác, một công thức trung bình đã bỏ sót năm nước. Một vùng ô kéo thiếu vài hàng — loại lỗi mà một phép thử với dữ liệu đã biết đáp án bắt được ngay.

Môn này trả lời câu hỏi gì

Môn Kiểm thử phần mềm trả lời câu hỏi: chỉ chạy được một phần rất nhỏ trong vô số trường hợp, thì chọn những trường hợp nào để tìm ra nhiều lỗi quan trọng nhất — và làm sao biết mình đã thử đủ?

"Vô số" ở đây gần như theo nghĩa đen. Một hàm nhận hai số nguyên 64 bit có 2¹²⁸ cặp đầu vào; thử một tỷ cặp mỗi giây vẫn cần khoảng 10²² năm, gấp hàng trăm tỷ lần tuổi vũ trụ. Vì vậy, như ý của Dijkstra mà bài Toán rời rạc, logic và chứng minh đã nhắc, kiểm thử chỉ cho thấy có lỗi, không chứng minh được không có lỗi. Muốn chứng minh thì cần phương pháp hình thức. Kiểm thử đi con đường thực dụng hơn: tìm lỗi sớm, nhanh và rẻ.

Câu hỏi lớn tách thành bốn việc:

  1. Chọn đầu vào trong một không gian khổng lồ.
  2. Biết đáp án đúng. Thứ cho biết đáp án gọi là nguồn đáp án (test oracle): một đặc tả, một phép tính tay, một chương trình khác, hay một tính chất luôn phải đúng.
  3. Tự động hóa, để kiểm thử chạy lại được sau mỗi lần sửa.
  4. Đo mức đủ: đã thử tới đâu, bộ kiểm thử có đủ sắc để bắt lỗi không.

Vì sao cần học? Vì lỗi càng phát hiện muộn càng đắt: lúc đang viết code, sửa mất vài phút; khi đã tới tay khách hàng, mất một buổi tìm nguyên nhân, một bản cập nhật, có khi cả uy tín. Và vì bộ kiểm thử tốt cho bạn dám sửa code — kể cả code do AI viết hộ.

Năm ý tưởng cốt lõi

1. Kiểm thử đơn vị: viết code để kiểm tra code

Kiểm thử đơn vị (unit testing) kiểm tra từng mảnh nhỏ — thường là một hàm — tách riêng khỏi phần còn lại. Ví dụ dưới là hàm tính thuế thu nhập theo biểu lũy tiến từng phần: mỗi phần thu nhập chịu thuế suất của bậc chứa nó. Biểu thuế này tự đặt ra cho ví dụ, không phải biểu thuế thu nhập cá nhân của Việt Nam. Tiền tính bằng số nguyên đồng, như bài Lập trình đã khuyên.

python
import unittest

def tinh_thue(thu_nhap):
    """Thuế (đồng) theo một biểu lũy tiến TỰ ĐẶT RA cho ví dụ:
    phần tới 10 triệu chịu 5%, phần từ trên 10 tới 30 triệu chịu 15%,
    phần trên 30 triệu chịu 25%."""
    if thu_nhap < 0:
        raise ValueError("thu nhập không được âm")
    if thu_nhap <= 10_000_000:
        return thu_nhap * 5 // 100
    if thu_nhap <= 30_000_000:
        return 500_000 + (thu_nhap - 10_000_000) * 15 // 100
    return 3_500_000 + (thu_nhap - 30_000_000) * 25 // 100

class KiemThuThue(unittest.TestCase):
    def test_bac_1(self):
        self.assertEqual(tinh_thue(8_000_000), 400_000)

    def test_bac_2(self):
        self.assertEqual(tinh_thue(20_000_000), 2_000_000)    # 500.000 + 10 triệu × 15%

    def test_bac_3(self):
        self.assertEqual(tinh_thue(50_000_000), 8_500_000)    # 3.500.000 + 20 triệu × 25%

    def test_thu_nhap_am(self):
        with self.assertRaises(ValueError):
            tinh_thue(-1)

if __name__ == "__main__":
    unittest.main()

Chạy file này, unittest tìm trong lớp kiểm thử mọi hàm có tên bắt đầu bằng test_, chạy từng hàm và in một dấu chấm cho mỗi kiểm thử qua:

text
....
----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK

Giờ thử làm hỏng: ở dòng cuối của hàm, gõ nhầm 3_500_000 thành 3_000_000. Chạy lại, máy chỉ ngay chỗ sai:

text
FAIL: test_bac_3 (__main__.KiemThuThue.test_bac_3)
AssertionError: 8000000 != 8500000

Để ý các con số mong đợi — 400.000, 2.000.000, 8.500.000 — được tính tay từ biểu thuế, không chép từ kết quả hàm chạy ra. Chép kết quả của hàm vào kiểm thử thì chỉ kiểm được rằng hàm… giống chính nó. Đó là câu hỏi về nguồn đáp án ở trên.

2. Chọn ca kiểm thử: lớp tương đương và giá trị biên

Thử 8.000.000 rồi 8.000.001 đồng gần như vô ích: hai giá trị đi qua cùng một nhánh code. Kỹ thuật phân hoạch tương đương (equivalence partitioning) chia miền đầu vào thành các lớp mà chương trình xử lý như nhau, rồi chọn một đại diện cho mỗi lớp. Hàm thuế có bốn lớp:

Lớp
Thu nhập
Đại diện
Giá trị biên
Không hợp lệ
âm
−5.000.000
−1
Bậc 1
từ 0 tới 10 triệu
8.000.000
0 và 10.000.000
Bậc 2
trên 10 tới 30 triệu
20.000.000
10.000.001 và 30.000.000
Bậc 3
trên 30 triệu
50.000.000
30.000.001

Cột cuối là phân tích giá trị biên (boundary value analysis): lỗi hay nằm ở mép mỗi lớp, nơi người viết gõ < thay cho <=, hay quên rằng 0 cũng là một con số. Bốn kiểm thử ở ý 1 đi qua đủ bốn lớp nhưng chưa thử biên nào. Nếu ai đó sửa dòng kiểm tra đầu vào thành if thu_nhap <= 0:, cả bốn vẫn qua — trong khi người không có thu nhập tháng này nhận về thông báo lỗi thay vì "thuế 0 đồng". Chỉ một kiểm thử ở biên 0 là bắt được. Lỗi của Ariane 5 cũng là lỗi biên: một con số vượt khỏi khoảng mà số nguyên 16 bit chứa được — mép mà Ariane 4 chưa từng chạm tới.

Chạy hàm ở các biên còn cho thấy: 10.000.000 và 10.000.001 đồng có cùng mức thuế 500.000 đồng, vì với thuế lũy tiến từng phần, chỉ phần vượt ngưỡng chịu thuế suất cao hơn. Một bản viết sai, áp 15% cho toàn bộ thu nhập khi đã qua ngưỡng, sẽ tính ra 1.500.000 đồng — thu nhập tăng một đồng, thuế gấp ba. Kiểm thử ở biên bắt được ngay.

3. Để máy nghĩ ra ca kiểm thử: kiểm thử ngẫu nhiên và kiểm thử theo tính chất

Bảng lớp tương đương chỉ tốt bằng trí tưởng tượng của người lập ra nó. Cách chữa là để máy sinh hàng nghìn đầu vào, và thay vì so với đáp án cụ thể, kiểm một tính chất (property) luôn phải đúng. Ví dụ, hàm chia tiền ăn của nhóm: hóa đơn bao nhiêu cũng vậy, các phần cộng lại phải đúng bằng hóa đơn, và không ai trả hơn ai quá 1 đồng.

python
import random

def chia_tien(tong, so_nguoi):
    """Chia hóa đơn `tong` đồng cho `so_nguoi` người."""
    moi_nguoi = round(tong / so_nguoi)
    return [moi_nguoi] * so_nguoi

# Kiểm thử bằng ví dụ: đều qua
assert chia_tien(300_000, 3) == [100_000, 100_000, 100_000]
assert chia_tien(450_000, 5) == [90_000] * 5

# Kiểm thử ngẫu nhiên: sinh 1.000 hóa đơn, kiểm hai tính chất phải luôn đúng
random.seed(2026)
for _ in range(1000):
    tong = random.randint(1, 2_000_000)
    so_nguoi = random.randint(1, 10)
    phan = chia_tien(tong, so_nguoi)
    if sum(phan) != tong or max(phan) - min(phan) > 1:
        print("Phản ví dụ:", tong, "đồng chia", so_nguoi, "người ->",
              phan[0], "đồng/người, cộng lại", sum(phan))
        break

Hai kiểm thử bằng ví dụ đều qua — vì ai cũng chọn những hóa đơn chia hết cho số người. Vòng lặp ngẫu nhiên thì in ra ngay:

text
Phản ví dụ: 249813 đồng chia 6 người -> 41636 đồng/người, cộng lại 249816

Làm tròn từng phần rồi nhân lên đã làm thừa 3 đồng. Chỉ vài đồng, nhưng nhân với hàng triệu giao dịch của một ứng dụng thanh toán là một khoản chênh mà ai đó phải đi tìm. Bản sửa chia phần dư cho vài người đầu; chạy lại vòng lặp, không còn phản ví dụ nào:

python
def chia_tien(tong, so_nguoi):
    """Chia hóa đơn `tong` đồng cho `so_nguoi` người, lệch nhau tối đa 1 đồng."""
    phan, du = divmod(tong, so_nguoi)
    return [phan + 1] * du + [phan] * (so_nguoi - du)

Đây là ý tưởng của QuickCheck. Các thư viện như Hypothesis cho Python còn tự thu nhỏ phản ví dụ về một ca thật đơn giản — kiểu hóa đơn 1 đồng chia 2 người, mỗi người trả 0 đồng — để người sửa nhìn là hiểu. Họ hàng gần của nó là fuzzing: ném dữ liệu ngẫu nhiên, kể cả rác, vào chương trình xem nó có sập không — chuyện Barton Miller nghĩ ra fuzzing và cách dùng nó tìm lỗ hổng có trong bài Bảo mật phần mềm.

4. Độ phủ: đo phần code đã chạy, không đo phần lỗi còn lại

Làm sao biết bộ kiểm thử đã đủ? Thước đo phổ biến nhất là độ phủ mã (code coverage): bao nhiêu phần trăm số dòng, hay số nhánh if, đã được chạy qua ít nhất một lần khi chạy kiểm thử. Với Python, công cụ coverage.py làm việc này bằng hai lệnh coverage run -m unittest và coverage report. Dòng nào chưa chạy là chỗ chắc chắn chưa được thử.

Nhưng chiều ngược lại thì không đúng. Hàm chia_tien bản lỗi chỉ có hai dòng, và hai kiểm thử bằng ví dụ đã chạy qua cả hai: độ phủ 100%, lỗi vẫn còn nguyên. Độ phủ cho biết code đã chạy, không cho biết kết quả đã được kiểm kỹ chưa, càng không cho biết những trường hợp code quên xử lý.

Một thước đo sắc hơn là kiểm thử đột biến (mutation testing): công cụ cố tình cài những lỗi nhỏ vào code — đổi < thành <=, + thành -, 15 thành 16 — rồi chạy bộ kiểm thử. Bản đột biến nào vẫn qua hết nghĩa là bộ kiểm thử không phân biệt được code đúng với code sai ở chỗ đó — như bản <= 0 ở ý 2.

5. Kim tự tháp kiểm thử và kiểm thử liên tục

Kiểm thử đơn vị nhanh và rẻ, nhưng phần mềm thật hay hỏng ở chỗ ghép. Ngày 23 tháng 9 năm 1999, tàu Mars Climate Orbiter của NASA mất liên lạc khi tới sao Hỏa. Phần mềm mặt đất của nhà thầu tính xung lực của những lần đốt động cơ nhỏ theo đơn vị Anh (pound-lực × giây), còn phần mềm dẫn đường hiểu con số đó theo hệ mét (newton × giây) như đặc tả quy định — lệch khoảng 4,45 lần. Mỗi phần đều đúng theo cách hiểu của nó; lỗi nằm ở giữa.

Vì thế người ta kiểm thử ở nhiều tầng, xếp thành kim tự tháp kiểm thử (test pyramid) — hình ảnh được Mike Cohn phổ biến. Lấy ví dụ một phần mềm tính lương:

Tầng
Kiểm cái gì
Trong phần mềm tính lương
Tốc độ
Số lượng
Đầu cuối (end-to-end)
Cả hệ thống, như người dùng thật
Mở trình duyệt, đăng nhập, bấm "Xuất phiếu lương", đọc con số trên màn hình
Vài giây tới vài phút mỗi ca
Ít
Tích hợp (integration)
Các phần ghép với nhau
Đọc bảng lương từ cơ sở dữ liệu, tính thuế, ghi phiếu: hai bên có cùng hiểu "đồng" hay "nghìn đồng" không?
Chậm hơn, cần cơ sở dữ liệu thật
Vừa phải
Đơn vị (unit)
Một hàm, tách riêng
tinh_thue, chia_tien
Vài mili giây
Rất nhiều

Đáy rộng vì kiểm thử đơn vị nhanh, chạy hàng nghìn ca mỗi lần, hỏng thì chỉ thẳng vào một hàm. Đỉnh hẹp vì kiểm thử đầu cuối chậm, đắt và hay chập chờn (flaky) — cùng một ca, hôm qua thì qua, hôm nay thì hỏng, chỉ vì mạng chậm — nhưng không bỏ được: chỉ nó thấy hệ thống đúng như người dùng thấy. Các công cụ như Selenium hay Playwright điều khiển trình duyệt thật cho tầng này.

Cuối cùng là thói quen. Kiểm thử hồi quy (regression testing): mỗi lỗi tìm ra được viết thành một kiểm thử trước khi sửa, để nó không quay lại. Tích hợp liên tục: mỗi lần đẩy code lên, máy chủ chạy toàn bộ kiểm thử, hỏng thì không cho gộp. Và với TDD, vòng lặp ngắn đỏ – xanh – dọn lại (red – green – refactor): viết một kiểm thử đang hỏng, viết code vừa đủ để nó qua, rồi sửa cho gọn mà không sợ — vì có kiểm thử đứng canh.

Kiểm thử nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, mỗi tầng hứa với tầng trên một hợp đồng: đưa lên cái gì, giấu đi cái gì. Kiểm thử không thuộc riêng tầng nào — nó là cách kiểm xem mỗi tầng có giữ lời hứa không:

  • Ở tầng phần cứng: chip được thử hàng loạt trước khi xuất xưởng — và lỗi phép chia của Pentium trong bài Toán rời rạc, logic và chứng minh nhắc rằng chỉ thử thôi chưa đủ.
  • Ở tầng hệ thống: hệ điều hành, trình biên dịch, cơ sở dữ liệu đều có bộ kiểm thử khổng lồ. SQLite, cơ sở dữ liệu có trong mọi điện thoại Android và iPhone, có lượng code kiểm thử gấp hàng trăm lần code chính.
  • Ở tầng ứng dụng: kiểm thử đơn vị giữ hợp đồng của từng hàm, kiểm thử tích hợp giữ hợp đồng giữa các phần — đúng chỗ Mars Climate Orbiter hỏng.

Đưa lên

Bằng chứng — không phải chứng minh — rằng code giữ đúng hợp đồng với những đầu vào đã thử, cùng một lưới an toàn chạy lại được sau mỗi lần sửa, để tầng trên dám xây tiếp.

Giấu đi

Cách code được cài đặt bên trong. Kiểm thử tốt chỉ nhìn vào hợp đồng, nên có thể viết lại cả hàm mà không phải sửa một kiểm thử nào.

Học trước và học sau

· 6 môn

Lập trình

Programming

Hàm, điều kiện, vòng lặp và những dòng assert đầu tiên. Phải viết được code trước khi kiểm thử nó. Học trước.

Xem chủ đề trên OpenER: Programming

Cấu trúc dữ liệu và giải thuật

Data Structures and Algorithms

Một cấu trúc dữ liệu tự cài là bài tập kiểm thử đầu tiên rất tốt: danh sách rỗng, một phần tử, phần tử trùng nhau — toàn những ca biên.

Xem chủ đề trên OpenER: Data Structures and Algorithms

Nhập môn công nghệ phần mềm

Introduction to Software Engineering

Kiểm thử là một khâu trong quy trình làm phần mềm cùng nhiều người, bên cạnh yêu cầu, thiết kế, quản lý mã nguồn. Nên học trước hoặc song song.

Xem chủ đề trên OpenER: Introduction to Software Engineering

Nguyên lý và mẫu thiết kế phần mềm

Software Engineering Principles and Patterns

Code chia nhỏ, ít phụ thuộc thì dễ kiểm thử. Đối tượng giả (mock) đứng thay cơ sở dữ liệu hay mạng khi kiểm thử đơn vị.

Xem chủ đề trên OpenER: Software Engineering Principles and Patterns

Phương pháp hình thức trong kỹ thuật phần mềm

Formal Methods for Software Engineering

Đi tiếp từ chỗ kiểm thử dừng lại: chứng minh code đúng với mọi đầu vào, không chỉ những đầu vào đã thử.

Xem chủ đề trên OpenER: Formal Methods for Software Engineering

Bảo mật phần mềm

Software Security

Fuzzing và kiểm thử bằng dữ liệu cố tình độc hại — kiểm thử nhìn bằng con mắt của kẻ tấn công.

Xem chủ đề trên OpenER: Software Security

Ứng dụng thật và nghề nghiệp

  • Mọi lập trình viên: ở các đội làm phần mềm nghiêm túc, viết kiểm thử cho code của mình là việc hằng ngày.
  • Kỹ sư kiểm thử, QA/QC: thiết kế ca kiểm thử, kiểm thử khám phá (exploratory testing) — dùng phần mềm như một người dùng khó tính — và xây bộ kiểm thử tự động, đầu cuối cho cả đội.
  • Phần mềm an toàn tính mạng: hàng không, y tế, ô tô. Chuẩn hàng không DO-178C đòi phần mềm ở mức nghiêm trọng nhất đạt một tiêu chí độ phủ rất ngặt gọi là MC/DC (modified condition/decision coverage).
  • Kiểm thử chịu tải (load testing): hệ thống đăng ký tín chỉ, bán vé tàu Tết chịu được bao nhiêu người cùng lúc.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • viết kiểm thử đơn vị bằng các bộ khung như unittest, pytest hay JUnit;
  • thiết kế ca kiểm thử bằng lớp tương đương và giá trị biên, thay vì nghĩ đâu thử đó;
  • nêu tính chất của một hàm và để máy sinh đầu vào đi tìm phản ví dụ;
  • đọc báo cáo độ phủ, biết nó nói gì và không nói gì;
  • dùng đối tượng giả để tách phần cần thử khỏi cơ sở dữ liệu hay mạng, sắp kiểm thử của cả dự án theo kim tự tháp và cho chúng chạy tự động mỗi lần đổi code.

Nên biết trước: lập trình vững ở một ngôn ngữ, và một chút cấu trúc dữ liệu. Chưa vững thì đi qua các chủ đề Programming và Data Structures and Algorithms trước.

Bắt đầu trên OpenER: trang chủ đề Software Testing có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là Software Testing trên NPTEL, do IIIT Bangalore giảng, đi theo mạch sách của Ammann và Offutt: độ phủ trên đồ thị và biểu thức logic, phân hoạch miền đầu vào, kiểm thử đột biến. Thiên về thực hành hằng ngày thì có chuỗi Automated Software Testing của TU Delft trên edX (cần tài khoản): phần đầu về kiểm thử đơn vị, giá trị biên, độ phủ, đối tượng giả; phần sau tới kiểm thử đột biến và kiểm thử theo tính chất. Lời khuyên: thử trên code của chính bạn, ngay hôm nay. Chọn một hàm bạn đã viết, lập bảng lớp tương đương và giá trị biên, viết năm kiểm thử — rồi cố tình làm hỏng hàm đó xem kiểm thử có kêu không.

Tài liệu tham khảo

  • Glenford J. Myers, Corey Sandler, Tom Badgett — The Art of Software Testing, ấn bản 3 (Wiley); ấn bản đầu của Myers năm 1979.
  • Paul Ammann, Jeff Offutt — Introduction to Software Testing, ấn bản 2 (Cambridge University Press).
  • Kent Beck — Test-Driven Development: By Example (Addison-Wesley).
  • Titus Winters, Tom Manshreck, Hyrum Wright (biên tập) — Software Engineering at Google, các chương 11–14 về kiểm thử; bản HTML đọc miễn phí.
  • Andreas Zeller và cộng sự — The Fuzzing Book, sách mở tại fuzzingbook.org, có notebook chạy thử.
  • Koen Claessen, John Hughes — "QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs", ICFP 2000.
  • Tài liệu chính thức của Python — unittest: Unit testing framework.
  • ESA — Ariane 5 Flight 501 Failure: Report by the Inquiry Board (chủ tịch J. L. Lions), 19/7/1996.
  • NASA — Mars Climate Orbiter Mishap Investigation Board Phase I Report, 1999.

Ban biên tập OpenER, “Kiểm thử phần mềm: tìm ra lỗi trước người dùng”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.