4

問題を引き起こしているコードが2つあります。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つのケースにつながるのですか？

4

1 に答える 1

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));
}

}
于 2014-01-22T00:22:49.310 に答える