Hướng dẫn assertexception phpunit - khẳng định ngoại lệ phpunit

TLDR; Cuộn tới: Sử dụng nhà cung cấp dữ liệu của PHPUNIT

Nội phân Chính showShow

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

• Làm thế nào để kiểm tra nhiều ngoại lệ?
• Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:
• Bắt một ngoại lệ và kiểm tra nó với một khẳng định
• Sử dụng nhà cung cấp dữ liệu của PHPUNIT
• Kiểm tra ngoại lệ gotchas
• Ngoại lệ của loại "typeerror"
• ngoại lệ của loại "typeerror" một lần nữa

Nội phân chính

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

Phpunit 9.5 cung cấp các phương pháp sau để kiểm tra ngoại lệ:

Tuy nhiên, tài liệu mơ hồ về thứ tự của bất kỳ phương pháp nào ở trên trong mã kiểm tra.

assertSame($expected, $actual);
    }
}

output:

 ✔ Simple assertion
OK (1 test, 1 assertion)

Nếu bạn đã quen với việc sử dụng các xác nhận chẳng hạn: ví dụ:

expectException(\InvalidArgumentException::class);
    }
}

output:

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

Bạn có thể ngạc nhiên khi thất bại trong bài kiểm tra ngoại lệ:

Lỗi là vì:

Khi một ngoại lệ được ném, PHP không thể quay lại dòng mã xuất hiện sau dòng ném ngoại lệ. Bắt một ngoại lệ thay đổi không có gì trong vấn đề này. Ném một ngoại lệ là một vé một chiều.

Không giống như các lỗi, các ngoại lệ không có khả năng phục hồi từ chúng và khiến PHP tiếp tục thực thi mã như thể không có ngoại lệ nào cả.

$this->expectException(\InvalidArgumentException::class);

Do đó, phpunit thậm chí không đến được nơi:

throw new \InvalidArgumentException();

Nếu nó được đi trước:

Hơn nữa, phpunit sẽ không bao giờ có thể đến được nơi đó, bất kể khả năng nắm bắt ngoại lệ của nó.

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

Do đó, sử dụng bất kỳ phương pháp kiểm tra ngoại lệ nào của PHPUnit:before a code where an exception is expected to be thrown in contrary to an assertion that is placed after an actual value is set.

Phải là trước một mã trong đó một ngoại lệ dự kiến ​​sẽ được ném trái ngược với một khẳng định được đặt sau khi một giá trị thực tế được đặt.

Một thứ tự thích hợp sử dụng kiểm tra ngoại lệ:

________số 8

Bởi vì việc gọi đến các phương thức nội bộ PHPUNIT để kiểm tra các ngoại lệ phải là trước khi một ngoại lệ được ném, điều đó có ý nghĩa rằng các phương thức PHPUNIT liên quan đến các ngoại lệ thử nghiệm bắt đầu từ

expectException(\InvalidArgumentException::class);
    }
}

5 thay vì

expectException(\InvalidArgumentException::class);
    }
}

6.

Biết rồi:

Khi một ngoại lệ được ném, PHP không thể quay lại dòng mã xuất hiện sau dòng ném ngoại lệ.

expectException(\RuntimeException::class);
        throw new \RuntimeException();

        # Should Fail
        $this->expectException(\RuntimeException::class);
        throw new \InvalidArgumentException();
    }
}

Bạn sẽ có thể dễ dàng phát hiện ra một lỗi trong bài kiểm tra này:

expectException(\InvalidArgumentException::class);
    }
}

7 đầu tiên sẽ ổn, nó mong đợi một lớp ngoại lệ trước khi một lớp ngoại lệ chính xác như mong đợi được ném nên không có gì sai ở đây.

Phần thứ hai sẽ thất bại mong đợi lớp

expectException(\InvalidArgumentException::class);
    }
}

8 trước khi một ngoại lệ hoàn toàn khác được ném nên nó sẽ thất bại nhưng liệu thực thi phpunit có đạt được vị trí đó không?

assertSame($expected, $actual);
    }
}

0

expectException(\InvalidArgumentException::class);
    }
}

9?

Đầu ra của thử nghiệm là:

Không, nó là xa

expectException(\InvalidArgumentException::class);
    }
}

9 nếu bài kiểm tra vượt qua và nó sẽ

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

1 về ngoại lệ thứ hai. Tại sao vậy?

Lưu ý rằng đầu ra có:

OK (1 bài kiểm tra, 1 xác nhận)

Trường hợp số lượng kiểm tra là đúng nhưng chỉ có

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

2.

Cần có 2 xác nhận =

expectException(\InvalidArgumentException::class);
    }
}

9 và

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

1 làm cho bài kiểm tra không vượt qua.

assertSame($expected, $actual);
    }
}

1

Đó chỉ đơn giản là vì PHPUNIT được thực hiện với việc thực hiện

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

5 sau dòng:

assertSame($expected, $actual);
    }
}

2

Đó là một vé một chiều ngoài phạm vi của

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

5 đến một nơi nào đó mà phpunit bắt được

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

7 và làm những gì nó cần làm, nhưng bất cứ điều gì chúng ta có thể biết chúng ta sẽ không thể quay trở lại

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

5 do đó mã:

Sẽ không bao giờ được thực hiện và đó là lý do tại sao quan điểm của PHPUNIT, kết quả kiểm tra là

expectException(\InvalidArgumentException::class);
    }
}

9 thay vì

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

1.

assertSame($expected, $actual);
    }
}

3

Đó không phải là một tin tốt nếu bạn muốn sử dụng nhiều cuộc gọi

expectException(\InvalidArgumentException::class);
    }
}

7 hoặc kết hợp các cuộc gọi

expectException(\InvalidArgumentException::class);
    }
}

7 và

$this->expectException(\InvalidArgumentException::class);

3 trong cùng một phương thức kiểm tra:

Lưu ý rằng đầu ra có:

OK (1 bài kiểm tra, 1 xác nhận)

Làm thế nào để kiểm tra nhiều ngoại lệ?

Chia nhiều ngoại lệ thành các bài kiểm tra riêng biệt:

assertSame($expected, $actual);
    }
}

4

gives:

assertSame($expected, $actual);
    }
}

5

$this->expectException(\InvalidArgumentException::class);

5 như nó nên.

Tuy nhiên, phương pháp này có một nhược điểm ở cách tiếp cận cơ bản của nó - đối với mỗi ngoại lệ, bạn cần một bài kiểm tra riêng. Điều đó sẽ làm cho một loạt các bài kiểm tra chỉ để kiểm tra các ngoại lệ.

Bắt một ngoại lệ và kiểm tra nó với một khẳng định

Nếu bạn không thể tiếp tục thực thi tập lệnh sau khi một ngoại lệ được ném, bạn có thể chỉ cần nắm bắt một ngoại lệ dự kiến ​​và sau đó lấy tất cả dữ liệu về nó với các phương thức mà một ngoại lệ cung cấp và sử dụng với sự kết hợp của các giá trị và xác nhận dự kiến:

assertSame($expected, $actual);
    }
}

6

gives:

assertSame($expected, $actual);
    }
}

7

$this->expectException(\InvalidArgumentException::class);

5 như nó nên nhưng trời ơi, bạn đã đọc tất cả những điều trên? Bạn cần chăm sóc để xóa các biến

$this->expectException(\InvalidArgumentException::class);

7 để phát hiện nếu một ngoại lệ được ném, thì sinh vật này

$this->expectException(\InvalidArgumentException::class);

8 để có một vị trí chính xác của ngoại lệ trong trường hợp nó không được ném Ngoại lệ không được ném.

Sử dụng nhà cung cấp dữ liệu của PHPUNIT

PHPUNIT có một cơ chế hữu ích gọi là nhà cung cấp dữ liệu. Nhà cung cấp dữ liệu là một phương thức trả về dữ liệu (mảng) với các bộ dữ liệu. Một tập dữ liệu duy nhất được sử dụng làm (các) đối số khi phương pháp thử nghiệm -

 ✘ Exception
   ├ InvalidArgumentException:

ERRORS!
Tests: 1, Assertions: 0, Errors: 1.

5 được gọi bởi PHPUNIT.

Nếu nhà cung cấp dữ liệu trả về nhiều tập dữ liệu thì phương thức kiểm tra sẽ được chạy nhiều lần, mỗi lần với một tập dữ liệu khác. Điều đó hữu ích khi kiểm tra nhiều ngoại lệ hoặc/và nhiều thuộc tính của ngoại lệ như tên lớp, tin nhắn, mã vì mặc dù: mặc dù:test method will be run multiple times, each time with another data set. That is helpful when testing multiple exceptions or/and multiple exception's properties like class name, message, code because even though:

Khi một ngoại lệ được ném, PHP không thể quay lại dòng mã xuất hiện sau dòng ném ngoại lệ.

PHPUNIT sẽ chạy phương thức kiểm tra nhiều lần, mỗi lần với các dữ liệu khác nhau được đặt thay vì kiểm tra ví dụ như nhiều trường hợp ngoại lệ trong một phương thức kiểm tra chạy (sẽ không thành công).

Đó là lý do tại sao chúng tôi có thể tạo một phương thức kiểm tra chịu trách nhiệm kiểm tra chỉ một ngoại lệ tại thời điểm đó nhưng chạy phương thức kiểm tra đó nhiều lần với dữ liệu đầu vào khác nhau và ngoại lệ được mong đợi bằng cách sử dụng nhà cung cấp dữ liệu của PHPUNIT.

Định nghĩa của phương pháp nhà cung cấp dữ liệu có thể được thực hiện bằng cách thực hiện chú thích

throw new \InvalidArgumentException();

2 cho phương thức kiểm tra cần được cung cấp bởi nhà cung cấp dữ liệu với một tập dữ liệu.

assertSame($expected, $actual);
    }
}

8

Kết quả cho:

assertSame($expected, $actual);
    }
}

9

Lưu ý rằng ngay cả chỉ có một phương pháp thử nghiệm trong toàn bộ

throw new \InvalidArgumentException();

3 đầu ra của phpunit là:

OK (2 bài kiểm tra, 2 xác nhận)2 tests, 2 assertions)

Vì vậy, ngay cả dòng:

 ✔ Simple assertion
OK (1 test, 1 assertion)

0

Đã ném ngoại lệ lần đầu tiên không có vấn đề gì khi kiểm tra một ngoại lệ khác với cùng một phương thức kiểm tra vì PHPunit đã chạy lại với bộ dữ liệu khác nhau nhờ nhà cung cấp dữ liệu.

Mỗi tập dữ liệu được trả về bởi nhà cung cấp dữ liệu có thể được đặt tên, bạn chỉ cần sử dụng một chuỗi làm khóa mà theo đó bộ dữ liệu được lưu trữ. Do đó, tên lớp ngoại lệ dự kiến ​​được sử dụng hai lần. Là khóa của mảng tập dữ liệu và là một giá trị (trong khóa 'ClassName') sau đó được sử dụng làm đối số cho

expectException(\InvalidArgumentException::class);
    }
}

7.

Sử dụng các chuỗi làm tên khóa cho các bộ dữ liệu làm cho bản tóm tắt khá và tự giải thích:

✔ Ném ngoại lệ với RunTimEexceptionRuntimeException

✔ Ném Ngoại lệ với InflaiDarGumentExceptionInvalidArgumentException

Và nếu bạn thay đổi dòng:

 ✔ Simple assertion
OK (1 test, 1 assertion)

1

to:

 ✔ Simple assertion
OK (1 test, 1 assertion)

2

của

throw new \InvalidArgumentException();

5

Để có được các trường hợp ngoại lệ sai và chạy lại PHPUNIT, bạn sẽ thấy:

 ✔ Simple assertion
OK (1 test, 1 assertion)

3

như mong đợi:

Thất bại! Kiểm tra: 2, Khẳng định: 2, Thất bại: 2.

với chính xác các tên của bộ dữ liệu gây ra một số vấn đề:

✘ Ném ngoại lệ với RunTimEexceptionRuntimeException

✘ Ném Ngoại lệ với InflaiDarGumentExceptionInvalidArgumentException

Làm cho

throw new \InvalidArgumentException();

5 không ném bất kỳ trường hợp ngoại lệ nào:

 ✔ Simple assertion
OK (1 test, 1 assertion)

4

và chạy phpunit một lần nữa đưa ra:

 ✔ Simple assertion
OK (1 test, 1 assertion)

5

Có vẻ như sử dụng nhà cung cấp dữ liệu có một số lợi thế:

1. Dữ liệu đầu vào và/hoặc dữ liệu dự kiến ​​được tách ra khỏi phương pháp kiểm tra thực tế.
2. Mỗi tập dữ liệu có thể có một tên mô tả chỉ ra rõ ràng tập dữ liệu nào đã khiến kiểm tra truyền hoặc thất bại.
3. Trong trường hợp thử nghiệm thất bại, bạn nhận được một tin nhắn thất bại thích hợp khi đề cập rằng một ngoại lệ không bị ném hoặc một ngoại lệ sai đã bị ném thay vì một khẳng định rằng x không phải là y.
4. Chỉ có một phương pháp thử nghiệm duy nhất cần thiết để kiểm tra một phương pháp duy nhất có thể ném nhiều ngoại lệ.
5. Có thể kiểm tra nhiều ngoại lệ và/hoặc nhiều thuộc tính của ngoại lệ như tên lớp, tin nhắn, mã.
6. Không cần bất kỳ mã không cần thiết nào như thử Catch Block, thay vào đó chỉ sử dụng tính năng tích hợp của Phpunit.

Kiểm tra ngoại lệ gotchas

Ngoại lệ của loại "typeerror"

Với kiểu dữ liệu PHP7 Hỗ trợ Thử nghiệm này:

 ✔ Simple assertion
OK (1 test, 1 assertion)

6

Thất bại với đầu ra:

 ✔ Simple assertion
OK (1 test, 1 assertion)

7

Mặc dù có trong phương pháp

throw new \InvalidArgumentException();

7:

 ✔ Simple assertion
OK (1 test, 1 assertion)

8

và bài kiểm tra vượt qua một mảng thay vì một chuỗi:

 ✔ Simple assertion
OK (1 test, 1 assertion)

9

PHP không đạt được mã:

expectException(\InvalidArgumentException::class);
    }
}

0

Bởi vì ngoại lệ được ném sớm hơn do loại gõ

throw new \InvalidArgumentException();

8:

expectException(\InvalidArgumentException::class);
    }
}

1

Do đó,

throw new \InvalidArgumentException();

9 bị ném thay vì

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0

ngoại lệ của loại "typeerror" một lần nữa

Biết rằng chúng tôi không cần

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

1 để kiểm tra loại dữ liệu vì PHP đã quan tâm đến điều đó nếu chúng tôi chỉ định loại dữ liệu trong khai báo phương thức

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

2, chúng tôi có thể muốn ném

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 nếu tin nhắn quá dài

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

4.

expectException(\InvalidArgumentException::class);
    }
}

2

Sửa đổi cũng

throw new \InvalidArgumentException();

3 vì vậy chúng tôi có hai trường hợp (phương pháp thử nghiệm) trong đó một

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 nên được ném - đầu tiên

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

7 khi tin nhắn quá dài và thứ hai ____78 khi tin nhắn là một loại sai.

Trong cả hai bài kiểm tra, chúng tôi mong đợi thay vì một lớp ngoại lệ cụ thể như

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 hoặc

throw new \InvalidArgumentException();

9 chỉ là một lớp

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 chung bằng cách sử dụng

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2

Kết quả kiểm tra là:

expectException(\InvalidArgumentException::class);
    }
}

3

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

3 mong đợi một

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 chung và sử dụng

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2

vượt qua với

expectException(\InvalidArgumentException::class);
    }
}

9 khi

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 bị ném

nhưng

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

8 Sử dụng cùng một

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2

expectException(\RuntimeException::class);
        throw new \RuntimeException();

        # Should Fail
        $this->expectException(\RuntimeException::class);
        throw new \InvalidArgumentException();
    }
}

0 với mô tả:

Thất bại khẳng định ngoại lệ đó là loại "kiểu chữ" phù hợp với ngoại lệ "ngoại lệ".exception of type "TypeError" matches expected exception "Exception".

Có vẻ khó hiểu khi phpunit phàn nàn rằng ngoại lệ

throw new \InvalidArgumentException();

9 không phải là

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6, nếu không nó sẽ không có vấn đề gì với

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2 bên trong

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

8 vì nó không có bất kỳ vấn đề nào với

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

3 ném

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 và mong đợi:

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2exception

throw new \InvalidArgumentException();

9 was not an

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6, otherwise it would not have had any problem with

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2 inside the

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

8 as it did not have any problem with the

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

3 throwing

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 and expecting:

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2

Vấn đề là phpunit đánh lừa bạn với mô tả như trên vì

throw new \InvalidArgumentException();

9 không phải là một ngoại lệ.

throw new \InvalidArgumentException();

9 không kéo dài từ lớp

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 cũng như từ bất kỳ con nào khác.not an exception.

throw new \InvalidArgumentException();

9 does not extends from the

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 class nor from any other its children.

throw new \InvalidArgumentException();

9 thực hiện giao diện

assertSame($expected, $actual);
    }
}

02 Xem tài liệu

nhưng trái lại

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 mở rộng tài liệu ____104

và

assertSame($expected, $actual);
    }
}

04 mở rộng tài liệu

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6

Do đó

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 cũng mở rộng

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6.

Đó là lý do tại sao ném bài kiểm tra

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

0 vượt qua OK và

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2 nhưng ném

throw new \InvalidArgumentException();

9 sẽ không (nó không mở rộng

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6)

Tuy nhiên, cả

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 và

throw new \InvalidArgumentException();

9 đều thực hiện giao diện

assertSame($expected, $actual);
    }
}

02.

Do đó thay đổi trong cả hai bài kiểm tra

expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException();
    }
}

2

đến

assertSame($expected, $actual);
    }
}

17

làm cho kiểm tra màu xanh lá cây:

expectException(\InvalidArgumentException::class);
    }
}

4

Xem danh sách các lỗi và các lớp ngoại lệ và cách chúng có liên quan với nhau.

Để rõ ràng: Đó là một thông lệ tốt để sử dụng một ngoại lệ hoặc lỗi cụ thể cho kiểm tra đơn vị thay vì một

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6 hoặc

assertSame($expected, $actual);
    }
}

02 chung Thực tế không phải

$this->expectException(string $exceptionClassName);
$this->expectExceptionCode(int|string $code);
$this->expectExceptionMessage(string $message);
$this->expectExceptionMessageMatches(string $regularExpression);
$this->expectExceptionObject(\Exception $exceptionObject);

6s mà

assertSame($expected, $actual);
    }
}

02