java – 如何使用ExpectedException规则在一个测试中测试多个异常?

前端之家收集整理的这篇文章主要介绍了java – 如何使用ExpectedException规则在一个测试中测试多个异常?前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。
对junit的ExpectedException规则的用法有疑问:

正如这里建议的那样:junit ExpectedException Rule
从junit 4.7开始,可以测试这样的异常(这比@Test(expected = Exception.class)要好得多):

  1. @Rule
  2. public ExpectedException exception = ExpectedException.none();
  3.  
  4. @Test
  5. public void testFailuresOfClass() {
  6. Foo foo = new Foo();
  7. exception.expect(Exception.class);
  8. foo.doStuff();
  9. }

现在我需要在一个测试方法中测试几个异常,并在运行以下测试后得到一个绿色条,因此认为每个测试都通过了.

  1. @Test
  2. public void testFailuresOfClass() {
  3. Foo foo = new Foo();
  4.  
  5. exception.expect(IndexOutOfBoundsException.class);
  6. foo.doStuff();
  7.  
  8. //this is not tested anymore and if the first passes everything looks fine
  9. exception.expect(NullPointerException.class);
  10. foo.doStuff(null);
  11.  
  12. exception.expect(MyOwnException.class);
  13. foo.doStuff(null,"");
  14.  
  15. exception.expect(DomainException.class);
  16. foo.doOtherStuff();
  17. }

但是过了一会儿,我意识到第一次检查通过后,测试方法就会退出.至少可以说这是模棱两可的.在junit 3中,这很容易实现……
所以这是我的问题:

如何使用ExpectedException规则在一个测试中测试多个异常?

解决方法

简短的回答:你做不到.

如果第一次调用–foo.doStuff() – 抛出异常,你永远不会到达foo.doStuff(null).你必须把你的测试分成几个(对于这个简单的情况,我建议回到简单的符号,没有ExpectedException):

  1. private Foo foo;
  2.  
  3. @Before
  4. public void setUp() {
  5. foo = new Foo();
  6. }
  7.  
  8. @Test(expected = IndexOutOfBoundsException.class)
  9. public void noArgsShouldFail() {
  10. foo.doStuff();
  11. }
  12.  
  13. @Test(expected = NullPointerException.class)
  14. public void nullArgShouldFail() {
  15. foo.doStuff(null);
  16. }
  17.  
  18. @Test(expected = MyOwnException.class)
  19. public void nullAndEmptyStringShouldFail() {
  20. foo.doStuff(null,"");
  21. }
  22.  
  23. @Test(expected = DomainException.class)
  24. public void doOtherStuffShouldFail() {
  25. foo.doOtherStuff();
  26. }

如果你真的想要一个且只有一个测试,如果没有抛出错误你就会失败,并抓住你期望的东西:

  1. @Test
  2. public void testFailuresOfClass() {
  3. Foo foo = new Foo();
  4.  
  5. try {
  6. foo.doStuff();
  7. fail("doStuff() should not have succeeded");
  8. } catch (IndexOutOfBoundsException expected) {
  9. // This is what we want.
  10. }
  11. try {
  12. foo.doStuff(null);
  13. fail("doStuff(null) should not have succeeded");
  14. } catch (NullPointerException expected) {
  15. // This is what we want.
  16. }
  17. // etc for other failure modes
  18. }

但是,这很快就会变得非常混乱,如果第一个期望失败,你就不会看到其他任何事情也会失败,这在排除故障时会很烦人.

猜你在找的Java相关文章