Kiểm thử hộp trắng (white-box testing) là

Để đạ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.

Độ phức tạp Cyclomatic (Cyclomatic Complexity) có thể được tính bằng công thức V(G) = E - N + 2, trong đó E là số cạnh của đồ thị và N là số nút của đồ thị.

Trong đồ thị đã cho:
- Số cạnh (E) = 9
- Số nút (N) = 8

Áp dụng công thức: V(G) = 9 - 8 + 2 = 3

Vậy độ phức tạp Cyclomatic của đồ thị là 3.