钩@Before和@after在开始时被调用两次

Question

我对自动化测试和黄瓜也很新颖。我写了一个简单的cucumber-Junit示例，其中包含三个场景。

我期待在每个场景开始时调用@Before，在每个场景之后调用@After。所以总共只能执行三次，因为有三种情况。

当我跑我的以下步骤定义，首先@Before被调用，那么@After，然后再@Before，则方案1，那么@After，然后@Before，然后场景2，然后@After，然后直接情景3.因此没有在场景3之前和之后分别调用@Before和@After。另一方面，它们在执行第一个场景之前被调用两次。任何想法我在这里做错了吗？我的Hook项目中没有任何.rb文件。

我@Before contains：System.out.println("Setup performed");和我@After包含System.out.println("CleanUp Performed");

import cucumber.api.PendingException; 
import cucumber.api.java.After; 
import cucumber.api.java.Before; 
import cucumber.api.java.en.Given; 
import cucumber.api.java.en.Then; 
import cucumber.api.java.en.When; 
import static org.junit.Assert.assertEquals; 
import static org.junit.Assert.assertNotNull; 

public class CalculatorSteps { 
    private Calculator calculator; 

    @Before 
    public void setUp() { 
     calculator = new Calculator(); 
     System.out.println("Setup Performed..."); 
    } 

    //Scenario : add two numbers - With regular expression 
    @Given("^I have a calculator$") 
    public void i_have_a_calculator() { 
     assertNotNull(calculator); 
    } 

    @When("^I add (\\d+) and (\\d+)$") 
    public void i_add(int arg1, int arg2) { 
     calculator.add(arg1, arg2); 
    } 

    @Then("^the result should be (\\d+)$") 
    public void the_result_should_be(int result) { 
     assertEquals(result, calculator.getResult()); 
    } 

    //Scenario : Subtract one number from another - With regular expression 

    @Given("^I have a calculatorr$") 
    public void i_have_a_calculator1() throws Throwable { 
     assertNotNull(calculator); 
    } 

    @When("^I subtract (\\d+.\\d+) from (\\d+.\\d+)$") 
    public void i_subtract_from(int arg1, int arg2) { 
    calculator.subtract(arg1, arg2); 
    } 

    @Then("^the result should be (\\d+.\\d+)$") 
    public void the_result_should_be1(double result1) { 
     assertEquals(result1, calculator.getresult1(), 0.5); 
    } 

    @After 
    public void cleanUp() { 
     System.out.println("CleanUp Performed..."); 
    } 
} 

特性文件看起来像：

Feature: Calculator 
     I use Calculator instead of calculating myself 

     #Scenario: Add two numbers 
     #Given I have a calculator 
     #When I add 2 and 3 
     #Then the result should be 5 

    @smokeTest 
     Scenario Outline: Add two numbers 
     Given I have a calculator 
      When I add <num1> and <num2> 
     Then the result should be <ans> 

     Examples: 
     | num1 | num2 | ans | 
     | 2 | 3 | 5 | 
     | 4 | 5 | 9 | 

     @regressionTest 
     Scenario: Subtract one number from another 
     Given I have a calculator 
     When I subtract 2.5 from 7.5 
     Then the result should be 5.0 

输出的样子：

Feature: Calculator 
     I use Calculator instead of calculating myself 
    Setup Performed... 
    CleanUp Performed... 
    Setup Performed... 

     Scenario Outline: Add two numbers # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:19 
     Given I have a calculator  # CalculatorSteps.i_have_a_calculator() 
     When I add 2 and 3    # CalculatorSteps.i_add(int,int) 
     Then the result should be 5  # CalculatorSteps.the_result_should_be(int) 
    CleanUp Performed... 
    Setup Performed... 

     Scenario Outline: Add two numbers # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:20 
     Given I have a calculator  # CalculatorSteps.i_have_a_calculator() 
     When I add 4 and 5    # CalculatorSteps.i_add(int,int) 
     Then the result should be 9  # CalculatorSteps.the_result_should_be(int) 
    CleanUp Performed... 

     #@regressionTest 
     Scenario: Subtract one number from another # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:23 
     Given I have a calculator    # CalculatorSteps.i_have_a_calculator() 
     When I subtract 2.5 from 7.5    # CalculatorSteps.i_subtract_from(int,int) 
     Then the result should be 5.0   # CalculatorSteps.the_result_should_be1(double) 

    3 Scenarios (3 passed) 
    9 Steps (9 passed) 
    0m0,074s 

尝试过counter后和@DaveyDaveDave代码，输出如下所示：开始时打印的计数器行不在正确的位置，但至少可以正确执行。但是我仍然想知道为什么在最后的减法情况下它不执行@Before,@Given和@After。

Feature: Calculator 
    I use Calculator instead of calculating myself 
@Before Count is: 0 
@Given Count is: 1 
@After Count is: 2 
@Before Count is: 3 

    @smokeTest 
    Scenario Outline: Add two numbers # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:19 
    Given I have a calculator  # CalculatorSteps.i_have_a_calculator() 
    When I add 2 and 3    # CalculatorSteps.i_add(int,int) 
    Then the result should be 5  # CalculatorSteps.the_result_should_be(int) 
@Given Count is: 4 
@After Count is: 5 
@Before Count is: 6 

    @smokeTest 
    Scenario Outline: Add two numbers # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:20 
    Given I have a calculator  # CalculatorSteps.i_have_a_calculator() 
    When I add 4 and 5    # CalculatorSteps.i_add(int,int) 
    Then the result should be 9  # CalculatorSteps.the_result_should_be(int) 
@After Count is: 7 

    @regressionTest 
    Scenario: Subtract one number from another # src/test/java/cucumber/junit/maven/cucumber_jvm/maven/calculatorFeature.feature:23 
    #Given I have a calculator 
    When I subtract 2.5 from 7.5    # CalculatorSteps.i_subtract_from(int,int) 
    Then the result should be 5.0   # CalculatorSteps.the_result_should_be1(double) 

3 Scenarios (3 passed) 
8 Steps (8 passed) 
0m0,072s 

Answer 1

我觉得功能是在您所期望的顺序执行，而这仅仅是如何以及何时出现在输出的问题。

我只是复制和粘贴源，并增加了一个counter变量，当我运行它，我看到下面的输出：

Setup Performed... 0 
In given...1 
...CleanUp Performed... 2 
Setup Performed... 3 
In given...4 
...CleanUp Performed... 5 
Setup Performed... 6 
In given...7 
...CleanUp Performed... 8 

换句话说，这些数字表明，这些排序事情正如你所期望的那样发生。

如果有助于说服你，我创建了以下RequiresSetupCalculator，如果它在执行操作之前尚未设置，则会抛出异常，并且如果我们尝试运行设置时以前没有调用过cleanUp。

public class RequiresSetupCalculator { 
    private static RequiresSetupCalculator instance; 

    private int result = 0; 
    private double result1 = 0; 

    private boolean isSetup; 

    private RequiresSetupCalculator() { 
    } 

    public static synchronized RequiresSetupCalculator setup() { 
    if (instance == null) { 
     instance = new RequiresSetupCalculator(); 
    } 

    if (instance.isSetup) { 
     throw new RuntimeException("I have already been set up"); 
    } 

    instance.isSetup = true; 

    return instance; 
    } 

    public void cleanUp() { 
    if (!isSetup) { 
     throw new RuntimeException("I wasn't set up in the first place"); 
    } 

    isSetup = false; 
    } 

    public void add(final int arg1, 
       final int arg2) { 
    if (!isSetup) { 
     throw new RuntimeException("I haven't been set up, no calculating for you!"); 
    } 

    result = arg1 + arg2; 
    } 

    public int getResult() { 
    if (!isSetup) { 
     throw new RuntimeException("I haven't been set up, no calculating for you!"); 
    } 

    return result; 
    } 

    public void subtract(final int arg1, 
        final int arg2) { 
    if (!isSetup) { 
     throw new RuntimeException("I haven't been set up, no calculating for you!"); 
    } 

    result1 = arg2 - arg1; 
    } 

    public double getresult1() { 
    if (!isSetup) { 
     throw new RuntimeException("I haven't been set up, no calculating for you!"); 
    } 

    return result1; 
    } 
} 

要进行测试，如果你复制上面的到一个新的类，在保留现有Calculator，然后修改CalculatorSteps使用RequiresSetupCalculator和调用的@Before和@After方法setup和cleanUp方法你像这样的测试：

public class CalculatorSteps { 
    private RequiresSetupCalculator calculator; 

    @Before 
    public void setUp() { 
    calculator = RequiresSetupCalculator.setup(); 
    System.out.println("Setup Performed..."); 
    } 

    ... (existing test steps unchanged)... 

    @After 
    public void cleanUp() { 
    System.out.println("CleanUp Performed..."); 
    calculator.cleanUp(); 
    } 
} 

现在，当您运行测试，如果仍然通过，我认为我们可以肯定的是，@Before方法每次测试之前运行，一次且仅一次，而次每次测试后，方法运行一次也只能执行一次。

对我来说，这是成功的工作。如果您在运行测试时遇到异常，则会出现一些奇怪的现象，但我相当确信您会得到和我一样的结果。