Trường hợp thử nghiệm đối với phạm vi chi nhánh 100% không có lỗi?

Question

Những tuyên bố vấn đề là

Một phương pháp mà có một lỗi zero mà bạn có thể viết một bộ kiểm tra để có 100% bảo hiểm tuyên bố nhưng không tìm ra lỗi và một bộ kiểm tra có 100% bảo hiểm chi nhánh không tiết lộ lỗi?

Dưới đây là phương pháp tôi đã viết cho cùng

public faultyMethod1(int x, int y) { 
    int X =x; 
    int Y = y; 

    if (Y !=0){ 
    Z = X/Y; 
    } else { 
    System.out.println("Sorry. That's an DiviDeByZeroException"); 
    } 
} 

faultyMethod1 (1,2); 
faultyMethod1 (2,0); 

Đoạn mã trên để đạt được bộ kiểm tra có 100% bảo hiểm chi nhánh mà không tiết lộ lỗi" bộ

gì về thử nghiệm để có độ bao phủ 100% nhưng không tìm thấy lỗi?

Answer 1

Hãy tạo một ví dụ khác ...

// The method, according to our imaginary specification, should do: 
// return x * y, IF x is less than 2 
// return x + y, in any other case 
public int doSomething(int x, int y) { 

if (x < 2) { 
    return x * x; // this is our bug, it SHOULD be x * y 
} 

return x + y; 

} 

Bây giờ tưởng tượng chúng ta có hai bài kiểm tra:

assertEquals(0, doSomething(0, 12)); // works, as 0 * 0 == 0 * 12 
assertEquals(20, doSomething(10, 10)); // works fine 

Vì vậy, bây giờ chúng tôi có 100 bảo hiểm% thử nghiệm (vì x < 2 chi nhánh đã được bảo hiểm, cũng như một trong những khác). Nhưng chúng tôi không tìm thấy lỗi, vì sử dụng giá trị 0 cho x ẩn nó (vì 0 * một cái gì đó luôn luôn là 0, y không liên quan). Chúng tôi sẽ cần một cái gì đó như thế này ...

assertEquals(12, doSomething(1, 12)); // fails, because it will be 1*1 == 1 

Vấn đề tương tự có thể xảy ra đối với bất kỳ tình huống nào khác, bao gồm chia cho 0. Không thể tưởng tượng một ví dụ tốt, nhưng tôi đoán bạn có được ý tưởng cơ bản về việc có bao phủ 100% không có nghĩa là tìm 100% tất cả các lỗi. (Một cách hay để tìm chúng là thử nghiệm đột biến, nhưng đó là một chủ đề khá nâng cao.)

Answer 2

Làm thế nào để gây nhầm lẫn logic và với OR?

// This method must never throw; on error, it shall return -1. 
int foo(final String s, final int n) { 
    if (s != null || n != 0) { 
     return s.length()/n; 
    } else { 
     return -1; 
    } 
} 

Các mục nhập thử nghiệm sau đây đạt được mức độ phù hợp 100% và không tiết lộ lỗi.

assert foo("everything is fine", 6) == 3; // happy path, ok 
assert foo(null, 0) == -1;     // error path, ok 

Bộ thử nghiệm không được bao phủ bởi chi nhánh, vì hai biểu thức HOẶC cùng nhau đánh giá với cùng giá trị trong mỗi trường hợp. Việc thêm hai trường hợp thử nghiệm sau đây hoàn thành phạm vi phủ sóng của chi nhánh và cho thấy lỗi đó.

assert foo("bingo", 0) == -1; // ArithmeticException 
assert foo(null, 4) == -1;  // NullPointerException 

Như một vấn đề của thực tế, bốn đầu vào cùng cũng đạt được bảo hiểm đường đó là một yêu cầu thậm chí mạnh hơn bảo hiểm chi nhánh.