Java 循环JUnit测试的最佳实践

在学校作业中，我应该为参数<80返回

true

，否则返回

false

的方法编写黑盒测试。目前我的方法是

for (int i = 0; i < 80; i++) {
    assertTrue(someMethod(i));
}
for (int i = 80; i <= 100; i++) {
    assertFalse(someMethod(i));
}

for（int i=0；i<80；i++）{
资产真实性（方法一）；
}
对于（inti=80；i您通常可以只测试边缘情况，也可以测试其中一个范围的一个额外代表，例如

assertTrue(someMethod(79));
assertFalse(someMethod(80));

// not reaaaally necessary
assertTrue(someMethod(50));
assertFalse(someMethod(100));

在您的情况下，您可能还希望将截止点添加为常量（例如<代码>静态最终INTITE阈值= 80 ），并将其应用于测试用例中；如果阈值改变，则更容易更改。

对于您的情况，您可以重复100次：

@ParameterizedTest
@MethodSource("args")
public void so(int argument)
{
   assertTrue((argument < 80) == someMethod(argument));
}

private static IntStream args()
{
   return IntStream.range(0, 100);
}

您可以（在JUnit5中）执行以下操作：

编写（至少）三个测试用例，涵盖三个主要用例，即输入
<80
、输入
>80
和输入
=80

看起来是这样的：

@Test
@DisplayName("[< 80]")
@Tag("below_eighty")
void numberBelowEightyTest(TestInfo testInfo) {
    int number = 79;
    assertTrue(someMethod(number));
}

@Test
@DisplayName("[= 80]")
@Tag("equals_eighty")
void numberEqualsEightyTest(TestInfo testInfo) {
    int number = 80;
    assertFalse(someMethod(number));
}

@Test
@DisplayName("[> 80]")
@Tag("above_eighty")
void numberAboveEightyTest(TestInfo testInfo) {
    int number = 81;
    assertFalse(someMethod(number));
}

@测试
@显示名称（“[<80]”）
@标签（“低于80”）
void numberBelowEightyTest（TestInfo TestInfo）{
整数=79；
assertTrue（somethod（number））；
}
@试验
@显示名称（“[=80]”）
@标签（“等于八十”）
void numberRequalSightyTest（TestInfo TestInfo）{
整数=80；
assertFalse（somethod（number））；
}
@试验
@DisplayName（“[>80]”）
@标签（“超过80”）
无效编号超过80次测试（TestInfo TestInfo）{
整数=81；
assertFalse（somethod（number））；
}

在测试了这三个用例之后，由于直接测试了边界以及最近的邻居，您可以确定所有剩余的数字。
如果有人使用JUnit 4：

@RunWith(Parameterized.class)
public class PerformanceStatusTest {

    @Parameterized.Parameters
    public static List<Integer> data() {
        return IntStream.range(0, 100)
                .boxed()
                .collect(Collectors.toList());
    }

    private int testValue;

    public PerformanceStatusTest(final int testValue) {
        this.testValue = testValue;
    }

    @Test
    public void someMethodTest() {
        assertTrue((testValue < 80) == someMethod(testValue));
    }
} 

@RunWith（参数化的.class）
公开课表现测试{
@参数化。参数化
公共静态列表数据（）{
返回IntStream.range（0，100）
.boxed（）
.collect（Collectors.toList（））；
}
私有int测试值；
公共性能测试（最终int测试值）{
this.testValue=testValue；
}
@试验
公共方法测试（）{
assertTrue（（testValue<80）=someMethod（testValue））；
}
} 
提到另一个选项，在这个简单的例子中，它将执行全范围检查：在JUnit 5平台上使用基于属性的测试：

import org.junit.jupiter.api.*;

import net.jqwik.api.*;
import net.jqwik.api.constraints.*;

class PartitionedFunctionProperty {

    @Property
    void below80returnTrue(@ForAll @IntRange(min= 0, max = 79) int aNumber) {
        Assertions.assertTrue(someMethod(aNumber));
    }

    @Property
    void from80returnFalse(@ForAll @IntRange(min = 80, max = 100) int aNumber) {
        Assertions.assertFalse(someMethod(aNumber));
    }

    private boolean someMethod(int aNumber) {
        if (aNumber < 80) return true;
        return false;
    }
}

查找。
循环根本不是正确的方法。ParameterizedTest是一个很好的工具。但是，测试中的逻辑不是一个好主意。您建议复制
import org.junit.jupiter.api.*;

import net.jqwik.api.*;
import net.jqwik.api.constraints.*;

class PartitionedFunctionProperty {

    @Property
    void below80returnTrue(@ForAll @IntRange(min= 0, max = 79) int aNumber) {
        Assertions.assertTrue(someMethod(aNumber));
    }

    @Property
    void from80returnFalse(@ForAll @IntRange(min = 80, max = 100) int aNumber) {
        Assertions.assertFalse(someMethod(aNumber));
    }

    private boolean someMethod(int aNumber) {
        if (aNumber < 80) return true;
        return false;
    }
}

timestamp = 2018-12-05T14:50:36.668, generated = [80]
timestamp = 2018-12-05T14:50:36.671, generated = [81]
timestamp = 2018-12-05T14:50:36.672, generated = [82]
timestamp = 2018-12-05T14:50:36.672, generated = [83]
...
timestamp = 2018-12-05T14:50:36.676, generated = [98]
timestamp = 2018-12-05T14:50:36.676, generated = [99]
timestamp = 2018-12-05T14:50:36.677, generated = [100]

timestamp = 2018-12-05T14:50:36.679
    tries = 21
    checks = 21
    generation-mode = EXHAUSTIVE
    after-failure = SAMPLE_ONLY
    seed = 4490524914178941008