CHC4010 DevOps Week 2 – Practical: Testing

Exercise 1: Testing from a specification

Determine a set of Black Box test cases and test data from the following specification. Given an array of integers arr, return true if and only if it is a valid mountain array. That arr is a mountain array if and only if:

• arr.length > = 3

• There exists some i with $0 < \dot { 1 } < arr.length - 1$ such that:

  • $arr[0] < arr[1] < ... < arr[i - 1] < arr[i]$

  • $arr[i] > arr[i+1] > ... > arr[arr.length - 1]$

MOUNTAIN ARRAY

NOT A MOUNTAIN ARRAY

Example:

Test case	Test data	Expected result
An array that ascends. without descending	[-9, 0, 2, 5, 19]	False
An array that descends without ascending	[28, 15, 12, 5, -3, -4]	False
A valid mountain array	[0, 2, 3, 4, 5, 2, 1, 0]	True

Test cases:

1. Arrays of lengths 0 and 1 e.g. [], [1]

2. Arrays of length 2, ascending, descending and plateauing e.g. [1, 2], [2, 1], [1, 1]

3. An array that ascends without ever descending e.g. [1, 2, 3, 4, 5]

4. An array that descends without ever ascending e.g. [5, 4, 3, 2, 1]

5. A valley array (descends first then ascends) e.g. [3, 2, 1, 2, 3]

6. An array that ascends, plateaus, ascends again, and descends e.g. [1, 2, 2, 3, 4, 3]

7. An array that ascends, plateaus, and descends e.g. [1, 2, 2, 1]

8. An array that ascends, descends, plateaus, and descends again e.g. [1, 3, 2, 2, 1]

9. An array that plateaus, then descends e.g. [2, 2, 1]

10. An array that ascends, then plateaus e.g. [1, 2, 2]

11. An array that plateaus, then ascends e.g. [2, 2, 3]

12. An array that descends, then plateaus e.g. [2, 1, 1]

13. An array that ascends, descends, then ascends again e.g. [1, 2, 3, 2, 4]

14. An array that descends, ascends, then descends again e.g. [3, 1, 2, 1]

15. A valid mountain array of length 3 e.g. [1, 2, 1]

16. A mountain array that begins to descend towards the beginning e.g. [1, 3, 2, 1]

17. A mountain array that begins to descend towards the end e.g. [1, 2, 3, 1]

18. A mountain array that begins to descend around the midd e.g. [1, 2, 3, 2, 1]

Exercise 2: Test an implementation

Using your test plan walk through the algorithm below with the tests above.

def validMountainArray(arr: list[int]) -> bool:
    ascending = True
    i = 1
    while ascending and i < len(arr):
        ascending = arr[i] > arr[i - 1]
        i += 1
    if i == len(arr):
        return False
    descending = True
    while descending and i < len(arr):
        descending = arr[i] < arr[i - 1]
        i += 1
    return i == len(arr)

Test Case	Test Data	Expected Output	Actual Output	Correct?
Arrays of lengths 0 and 1	[],[1]	False	False
Arrays of length 2, various	[1, 2],[2, 1], [1, 1]	False	False
Ascends without descending	[1, 2, 3, 4, 5]	False	False
Descends without ascending	[5, 4, 3, 2, 1]	False	True	×
Valley array	[3, 2, 1, 2, 3]	False	False
Ascends, plateaus, ascends, descends	[1, 2, 2, 3, 4, 3]	False	False
Ascends, plateaus, descends	[1, 2, 2, 1]	False	True	×
Ascends, descends, plateaus, descends	[1, 3, 2, 2, 1]	False	False
Plateaus, then descends	[2, 2, 1]	False	True	×
Ascends, then plateaus	[1, 2, 2]	False	False
Plateaus, then ascends	[2, 2, 3]	False	True	×
Descends, then plateaus	[2, 1, 1]	False	True	×
Ascends, descends, then ascends	[1, 2, 3, 2, 4]	False	True	×
Descends, ascends, then descends	[3, 1, 2, 1]	False	False
Valid mountain of length 3 Mountain descends towards	[1,2, 1]	True	False	×
beginning	[1, 3, 2, 1]	True	True
Mountain descends towards end	[1, 2, 3, 1]	True	False	×
Mountain descends around middle	[1, 2, 3, 2, 1]	True	True

Exercise 3: Fix the implementation

Did the implementation above pass all your tests? If not, can you find and fix the bugs? Correct implementation:

def validMountainArray(arr: list[int]) -> bool:
    i = 0
    while i < len(arr) - 1 and arr[i] < arr[i + 1]:
        i += 1
    if i <= 0 or i >= len(arr) - 1:
        return False
    while i < len(arr) - 1 and arr[i] > arr[i + 1]:
        i += 1
    return i >= len(arr) - 1

Exercise 4: Automate your tests (optional)

Can you write a method that will test the algorithm with all of your test data, so that you don’t have to do so manually? Your method should print out all the test cases that failed and output a Boolean indicating the final result.

def validMountainArray(arr: list[int]) -> bool:
    ascending = True
    i = 1
    while ascending and i < len(arr):
        ascending = arr[i] > arr[i - 1]
        i += 1
    if i == len(arr):
        return False
    descending = True
    while descending and i < len(arr):
        descending = arr[i] < arr[i - 1]
        i += 1
    return i == len(arr)

test_cases = [
    ([], False),
    ([1], False),
    ([1, 2], False),
    ([2, 1], False),
    ([1, 1], False),
    ([1, 2, 3, 4, 5], False),
    ([5, 4, 3, 2, 1], False),
    ([3, 2, 1, 2, 3], False),
    ([1, 2, 2, 3, 4, 3], False),
    ([1, 2, 2, 1], False),
    ([1, 3, 2, 2, 1], False),
    ([2, 2, 1], False),
    ([1, 2, 2], False),
    ([2, 2, 3], False),
    ([2, 1, 1], False),
    ([1, 2, 3, 2, 4], False),
    ([3, 1, 2, 1], False),
    ([1, 2, 1], True),
    ([1, 3, 2, 1], True)
    ([1, 2, 3, 1], True)
    ([1, 2, 3, 2, 1], True),
]

for case in test_cases:
    assert(validMountainArray(case[0]) == case[1], f"should return {case[1]} for {case[0]}")