Question

我有两段代码给我带来麻烦。我使用单元测试对它们进行测试，使用cobertura分析测试覆盖率，并且我不了解如何计算条件覆盖率。这是第一篇：

if ((x.getInt() == a) 
 || (x.getInt() == y.getInt()) { ...

Cobertura报告我需要覆盖4个案例，假设忽略短路，这似乎很好。

然后，在另一种方法中，我有另一个（更长的）条件：

if ((x == null)
 || ObjectUtils.equals(x.getInt(), a)
 || ObjectUtils.equals(x.getInt(), y.getInt())) {
  ...

以下是我不明白的部分：Cobertura报告说有5/6个案例被覆盖。我原本预计会有8个案例，我可以解释5个案例（考虑到x == null），但是

在这些情况下，cobertura如何处理条件覆盖，为什么会导致6个案例？

Answer 1

不是通过测试布尔标志状态的所有可能组合来测量覆盖率，而是仅测量那些足以涵盖所有用例的组合。

考虑以下课程：

public class MyClass {

public boolean allOr(boolean x, boolean y) {
    return x || y;
}

public boolean allOr(boolean x, boolean y, boolean z) {
    return x || y || z;
}

public boolean allOr(boolean w, boolean x, boolean y, boolean z) {
    return w || x || y || z;
}

public boolean allAnd(boolean x, boolean y) {
    return x && y;
}

public boolean allAnd(boolean x, boolean y, boolean z) {
    return x && y && z;
}

public boolean andOr(boolean x, boolean y, boolean z) {
    return x && y || z;
}

public boolean orAnd(boolean x, boolean y, boolean z) {
    return (x || y) && z;
}

}

提供完整报道的测试如下：

public class MyClassTest {

@Test
public void testAllOr2() {
    MyClass instance = new MyClass();
    // For OR clause, test that all false returns false
    assertFalse(instance.allOr(false, false));
    // For OR clause, test that any one true returns true
    assertTrue(instance.allOr(false, true));
    assertTrue(instance.allOr(true, false));
}

@Test
public void testAllOr3() {
    MyClass instance = new MyClass();
    // For OR clause, test that all false returns false
    assertFalse(instance.allOr(false, false, false));
    // For OR clause, test that any one true returns true
    assertTrue(instance.allOr(false, false, true));
    assertTrue(instance.allOr(false, true, false));
    assertTrue(instance.allOr(true, false, false));

    // These do not add to coverage
    // assertTrue(instance.allOr(false, true, true));
    // assertTrue(instance.allOr(true, false, true));
    // assertTrue(instance.allOr(true, true, false));
    // assertTrue(instance.allOr(true, true, true));
}

@Test
public void testAllOr4() {
    MyClass instance = new MyClass();
    // For OR clause, test that all false returns false
    assertFalse(instance.allOr(false, false, false, false));
    // For OR clause, test that any one true returns true
    assertTrue(instance.allOr(false, false, false, true));
    assertTrue(instance.allOr(false, false, true, false));
    assertTrue(instance.allOr(false, true, false, false));
    assertTrue(instance.allOr(true, false, false, false));
}

@Test
public void testAllAnd2() {
    MyClass instance = new MyClass();
    // For AND clause, test that all true returns true
    assertTrue(instance.allAnd(true, true));
    // For AND clause, test that any one false returns false
    assertFalse(instance.allAnd(true, false));
    assertFalse(instance.allAnd(false, true));
}

@Test
public void testAllAnd3() {
    MyClass instance = new MyClass();
    // For AND clause, test that all true returns true
    assertTrue(instance.allAnd(true, true, true));
    // For AND clause, test that any one false returns false
    assertFalse(instance.allAnd(false, true, true));
    assertFalse(instance.allAnd(true, false, true));
    assertFalse(instance.allAnd(true, true, false));
}

@Test
public void testAndOr() {
    MyClass instance = new MyClass();
    // Since AND takes precedence,
    // OR is the external operator, AND is the internal operator
    // For the AND clause, false can be achieved in two ways
    // Compare to testAllAnd2 # 2, 3
    assertFalse(instance.andOr(true, false, false));
    assertFalse(instance.andOr(false, true, false));
    // This completes the first test case for the external operator
    // Compare to testAllOr2 # 1

    // Now irrespective of the arguments
    // as long as the value returned by the internal operation is false
    // we can perform the testAllOr2 # 2
    assertTrue(instance.andOr(true, false, true));
    // We do not need the case for false, true, true
    // because we have tested that no matter what the first two args are
    // it does not make a difference as long as one of them is false

    // However, if both args are true
    // the value returned by the internal operation is true
    // we can perform the testAllOr2 # 3
    // This is only possible in one way
    // Compare testAllAnd2 # 1
    assertTrue(instance.andOr(true, true, false));
}

@Test
public void testOrAnd() {
    MyClass instance = new MyClass();
    // Since OR takes precedence,
    // AND is the external operator, OR is the internal operator
    // For the OR clause, true can be achieved in two ways
    // Compare to testAllOr2 # 2, 3
    assertTrue(instance.orAnd(false, true, true));
    assertTrue(instance.orAnd(true, false, true));
    // This completes the first test case for the external operator
    // Compare to testAllAnd2 # 1

    // Now irrespective of the arguments
    // as long as the value returned by the internal operation is true
    // we can perform the testAllAnd2 # 2
    assertFalse(instance.orAnd(false, true, false));
    // We do not need the case for true, false, false
    // because we have tested that no matter what the first two args are
    // it does not make a difference as long as one of them is true

    // However, if both args are false
    // the value returned by the internal operation is false
    // we can perform the testAllAnd2 # 3
    // This is only possible in one way
    // Compare testAllOr2 # 1
    assertFalse(instance.orAnd(false, false, true));
}

}

Cobertura中条件覆盖的计算

1 个答案: