Question

我需要运行给定次数的代码。我想知道如何对该循环进行单元测试

public void executeCode(int iterations){

  for (int i = 0; i < iterations; i++)
      try {
           callToCode(parms...);
      } catch(Exception e) {
           // handle exception 
           i--;
      }
}

callToCode该方法具有100％的行覆盖率，但要求该方法必须在给定的迭代次数下执行。

我可以使用实例变量来跟踪执行，但是对这种循环进行单元测试的最佳方法是什么？

我只能使用Junit，而不能使用其他库

Answer 1

如果可以，请重构代码以将依赖项调用建模为对注入成员的调用。

public void executeCode(int iterations, Callable callable) {
  for (int i = 0; i < iterations; i++)
      try {
         callable.call();
      } catch(Exception e) {
         // handle exception 
         i--;
      }

}

然后在JUnit中，您可以传递您选择的计数可调用项。上面的代码只是许多示例之一，您还可以在测试类的构造函数中注入依赖项，例如

public class MyClass {
   private Dependency dep;
   public MyClass(Dependency dep) {
      this.dep = dep;
   }

   public void executeCode(int iterations, Callable callable) {
       //...
       dep.callToCode(parms...);
   }
}

然后再次在JUnit中注入另一个计数调用的类。

最后，如果callToCode（parms ...）;是您课程中的另一个方法，您也可以覆盖它进行计数，例如：

public class MyClassTest {
    @Test
    public void testCountLoop() {
        MyClass class = new MyClass() {
            int calls;
            @Override
            public void callToCode(parms...) {
                calls++;
            }
        }
        // ... run and assert calls
    }
}

Answer 2

我会将callToCode提取到另一个类，例如

active_from

然后，您的循环将在另一个类中，该类在构造函数中具有依赖性：

public class Caller{
    public void callToCode(String someparam){//Some logic}
}

然后在测试中，您可以使用Mockito.verify（使用任何参数调用两次）：

 public class OuterClass {
    Caller caller;
    public OuterClass(Caller caller){
        this.caller = caller;
    }
    public void executeCode(int iterations){

      for (int i = 0; i < iterations; i++)
         try {
              caller.callToCode(parms...);
         } catch(Exception e) {
              // handle exception 
              i--;
         }
      }
}

使用ArgumentCaptor，您还可以验证方法调用的参数。通常，如果您不能正确地对代码进行单元测试，那是设计问题的味道。通过分离代码的不同抽象级别，您可以分别测试每个级别，您将获得更简洁，易读的解决方案。

Junit for循环执行次数

2 个答案: