Software Engineering

Question

1. A program statement has this predicate. Notation || means “or”, whereas && means “and”. if (a > 1 || (b >= 2 || c < 3 && d > 4) && (e > 5 || f <= 6 && g > 7))

print (1);

else

print(-1);

a. By the multiple condition test coverage Cmcc, derive the number of test cases using True/False.

b. Prepare only two test cases based on the last two answers of your Cmcc test coverage shown above in the format of (a, b, c, d, e, f, g, exp_value). Please choose suitable numeric values for those variables to conduct tests.

Answer 1

To tackle this problem, we need to analyze the given predicate and determine the number of test cases required to achieve Multiple Condition Coverage (Cmcc), and then prepare two test cases based on this analysis.

### Analyzing the Predicate

The given predicate is:

```

if (a > 1 || (b >= 2 || c < 3 && d > 4) && (e > 5 || f <= 6 && g > 7))

```

This can be broken down into simpler conditions:

1. \( a > 1 \)

2. \( b >= 2 \)

3. \( c < 3 \)

4. \( d > 4 \)

5. \( e > 5 \)

6. \( f <= 6 \)

7. \( g > 7 \)

### Simplifying the Predicate

Let's simplify the given predicate step by step:

1. \( a > 1 \)

2. \( b >= 2 \)

3. \( c < 3 && d > 4 \)

4. \( e > 5 \)

5. \( f <= 6 && g > 7 \)

So, the predicate becomes:

\[ a > 1 \]

\[ || ((b >= 2) || (c < 3 && d > 4)) && ((e > 5) || (f <= 6 && g > 7)) \]

### Applying Multiple Condition Coverage (Cmcc)

To achieve Cmcc, we need to ensure that all combinations of truth values for each condition are covered. However, for practical purposes, we often use a minimized set of combinations that still ensures every condition is tested with both true and false values while achieving decision coverage.

Here are the conditions and their combinations:

| a | b | c | d | e | f | g |

|---|---|---|---|---|---|---|

| T | T | T | T | T | T | T |

| T | T | T | T | T | T | F |

| T | T | T | T | T | F | T |

| T | T | T | T | T | F | F |

| T | T | T | T | F | T | T |

| T | T | T | T | F | T | F |

| T | T | T | T | F | F | T |

| T | T | T | T | F | F | F |

| F | T | T | T | T | T | T |

| F | T | T | T | T | T | F |

| F | T | T | T | T | F | T |

| F | T | T | T | T | F | F |

| F | T | T | T | F | T | T |

| F | T | T | T | F | T | F |

| F | T | T | T | F | F | T |

| F | T | T | T | F | F | F |

| F | F | T | T | T | T | T |

| F | F | T | T | T | T | F |

| F | F | T | T | T | F | T |

| F | F | T | T | T | F | F |

| F | F | T | T | F | T | T |

| F | F | T | T | F | T | F |

| F | F | T | T | F | F | T |

| F | F | T | T | F | F | F |

| F | F | F | T | T | T | T |

| F | F | F | T | T | T | F |

| F | F | F | T | T | F | T |

| F | F | F | T | T | F | F |

| F | F | F | T | F | T | T |

| F | F | F | T | F | T | F |

| F | F | F | T | F | F | T |

| F | F | F | T | F | F | F |

| F | F | F | F | T | T | T |

| F | F | F | F | T | T | F |

| F | F | F | F | T | F | T |

| F | F | F | F | T | F | F |

| F | F | F | F | F | T | T |

| F | F | F | F | F | T | F |

| F | F | F | F | F | F | T |

| F | F | F | F | F | F | F |

We can simplify the above table to avoid redundant combinations, focusing on critical test cases that cover all scenarios.

### Two Test Cases

Here are two test cases that cover significant combinations of the conditions:

1. **Test Case 1**: (a, b, c, d, e, f, g, exp_value)

- **Values**: (0, 1, 2, 3, 4, 5, 6, -1)

- a = 0: False

- b = 1: False

- c = 2: True

- d = 3: False

- e = 4: False

- f = 5: True

- g = 6: False

- Expected Value: -1 (all combined conditions result in false)

2. **Test Case 2**: (a, b, c, d, e, f, g, exp_value)

- **Values**: (2, 3, 1, 5, 6, 7, 8, 1)

- a = 2: True

- b = 3: True

- c = 1: True

- d = 5: True

- e = 6: True

- f = 7: False

- g = 8: True

- Expected Value: 1 (a > 1 is true)

These test cases ensure that we are covering different combinations of conditions while validating the outcome.