Quy trình kiểm thử phần mềm gồm các nội dung: Lập kế hoạch kiểm thử (test plan), Phân tích và thiết kế kiểm thử (Test analyst / test designer ), Thực hiện kiểm thử (Test Executing), Đánh giá và báo cáo kiểm thử (Test Report & Evaluation).

Kiểm thử hộp trắng (white-box testing), còn được gọi là kiểm thử cấu trúc (structural testing), tập trung vào việc kiểm tra cấu trúc bên trong và logic của phần mềm. Trong phương pháp này, người kiểm thử có kiến thức về mã nguồn và sử dụng nó để thiết kế các test case. Mục tiêu là để đảm bảo rằng tất cả các đường dẫn thực thi trong mã nguồn đều được kiểm tra và phần mềm hoạt động đúng theo thiết kế. Vì vậy, tất cả các đáp án A, B, và C đều đúng.

Câu hỏi này kiểm tra kiến thức về kiểm thử hộp trắng, đặc biệt là các khái niệm liên quan đến đường thi hành và kiểm thử dòng điều khiển.

Phương án A đúng vì đường thi hành (execution path) đúng là một kịch bản thi hành của một đơn vị chương trình. Nó mô tả trình tự các lệnh được thực hiện khi chương trình chạy với một tập hợp đầu vào cụ thể.

Phương án B sai vì một đơn vị chương trình có thể có nhiều đường thi hành khác nhau, tùy thuộc vào các điều kiện và nhánh rẽ trong mã nguồn. Mỗi tập hợp đầu vào có thể dẫn đến một đường thi hành khác nhau.

Phương án C đúng vì mục tiêu của kiểm thử dòng điều khiển (control flow testing) là để đảm bảo mọi đường thi hành của đơn vị chương trình đều được kiểm tra và chạy đúng. Điều này bao gồm việc kiểm tra tất cả các nhánh, vòng lặp, và điều kiện trong mã.

Do đó, đáp án không đúng là B.

Để đạt được độ phủ cấp 1 (statement coverage), chúng ta cần thực hiện các test case sao cho mỗi dòng code được thực thi ít nhất một lần. Xét đoạn code đã cho:

1. `if (a==0) return 0;`: Cần một test case để `a == 0` (ví dụ: `a = 0`, `b = 1`, `c = 2`, `d = 3`). Test case này sẽ khiến hàm trả về 0.
2. `int x = 0;`: Dòng này luôn được thực thi nếu `a != 0`.
3. `if ((a==b) || ((c==d))) x = 1;`: Cần một test case để điều kiện `(a==b) || ((c==d))` là đúng (ví dụ: `a = 1`, `b = 1`, `c = 2`, `d = 3`). Điều này làm cho `x = 1`.
4. `if ((a==b) || ((c==d))) x = 1;`: Cần một test case để điều kiện `(a==b) || ((c==d))` là sai (ví dụ: `a = 1`, `b = 2`, `c = 3`, `d = 4`). Điều này làm cho `x = 0`.
5. `e = 1/x;`: Để dòng này được thực thi mà không gây ra lỗi chia cho 0, ta cần đảm bảo `x != 0`. Trường hợp `x=1` đã được đề cập ở trên. Tuy nhiên, trường hợp `x=0` cũng cần được xét, dù sẽ gây ra lỗi runtime.
6. `return e;`: Dòng này luôn được thực thi nếu không có `return` sớm.

Vậy tổng cộng, chúng ta cần ít nhất 3 test case để đảm bảo phủ hết các nhánh rẽ và các dòng lệnh (trừ trường hợp gây lỗi chia cho 0, nhưng vẫn cần test).

- Test case 1: a = 0, b = 1, c = 2, d = 3 (để phủ `a == 0`)
- Test case 2: a = 1, b = 1, c = 2, d = 3 (để phủ `(a==b) || (c==d)` là đúng, x = 1)
- Test case 3: a = 1, b = 2, c = 3, d = 4 (để phủ `(a==b) || (c==d)` là sai, x = 0)

Như vậy, đáp án đúng là C. 3

Đoạn code có các điều kiện sau:
1. `a == 0`: ảnh hưởng đến việc trả về giá trị 0 ngay lập tức.
2. `(a == b) || (c == d)`: ảnh hưởng đến giá trị của `x`. Nếu điều kiện này đúng, `x` sẽ bằng 1, ngược lại `x` sẽ bằng 0.
3. `e = 1/x`: có thể gây ra lỗi chia cho 0 nếu `x` bằng 0.

Để phủ cấp 2 (branch coverage), chúng ta cần đảm bảo mỗi nhánh của mỗi điều kiện được thực thi ít nhất một lần. Do đó cần xét các trường hợp sau:

* Testcase 1: `a = 0`. Nhánh `if (a == 0)` được thực thi và trả về 0.
* Testcase 2: `a != 0`, `a == b`, và `c != d`. Nhánh `if (a == 0)` không được thực thi, và `x` bằng 1.
* Testcase 3: `a != 0`, `a != b`, và `c == d`. Nhánh `if (a == 0)` không được thực thi, và `x` bằng 1.
* Testcase 4: `a != 0`, `a != b`, và `c != d`. Nhánh `if (a == 0)` không được thực thi, và `x` bằng 0.

Như vậy, cần tối thiểu 4 testcase để đảm bảo phủ cấp 2.

Đề bài yêu cầu số lượng test case để đảm bảo phủ cấp 3 (còn gọi là branch coverage). Đoạn code có các nhánh sau:
1. `if (a == 0)`: Cần 2 test case (true/false)
2. `if ((a == b) || (c == d))`: Cần các test case để phủ các trường hợp sau:
- a == b là true
- a == b là false và c == d là true
- a == b là false và c == d là false
Tuy nhiên, nếu x = 0, chương trình sẽ bị lỗi chia cho 0 (`e = 1/x`). Vì vậy, chúng ta cần thêm một test case để đảm bảo x != 0.
Vậy ta cần các test case sau:
1. a = 0 (để phủ nhánh `if (a==0)` là true)
2. a != 0, a = b (để phủ nhánh `(a==b) || (c==d)` là true và `a==b` là true)
3. a != 0, a != b, c = d (để phủ nhánh `(a==b) || (c==d)` là true và `a==b` là false, `c==d` là true)
4. a != 0, a != b, c != d (để phủ nhánh `(a==b) || (c==d)` là false)
Như vậy cần tối thiểu 4 test case để phủ hết các nhánh.