Why systematic techniques improve coverage in Testing Fundamentals - Automation Benefits in Action

Verify that systematic testing techniques improve test coverage

Preconditions (3)

Step 1: Open the calculator application

Step 2: Enter 5 in the first number input field

Step 3: Enter 3 in the second number input field

Step 4: Click the 'Add' button

Step 5: Verify the result is 8

Step 6: Click the 'Subtract' button

Step 7: Verify the result is 2

Step 8: Click the 'Multiply' button

Step 9: Verify the result is 15

Step 10: Click the 'Divide' button

Step 11: Verify the result is 1.6667 (rounded to 4 decimals)

Step 12: Repeat the above steps with inputs 0 and 0

Step 13: Repeat the above steps with inputs -1 and 1

✅ Expected Result: All operations return correct results for all input sets, demonstrating that systematic testing covers normal, boundary, and edge cases.

Automation Requirements - Selenium with Python

Assertions Needed:

Verify displayed result matches expected calculation for each operation

Verify results for multiple input sets to cover different cases

Best Practices:

Use explicit waits to handle UI loading

Use parameterized tests or loops for multiple input sets

Use clear and maintainable locators (id or name attributes)

Separate test data from test logic

Automated Solution

Testing Fundamentals

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import unittest

class CalculatorSystematicTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('http://localhost:8000/calculator')  # Replace with actual URL
        self.wait = WebDriverWait(self.driver, 10)

    def tearDown(self):
        self.driver.quit()

    def calculate_and_verify(self, num1, num2, operation, expected):
        driver = self.driver
        wait = self.wait

        input1 = wait.until(EC.presence_of_element_located((By.ID, 'num1')))
        input2 = driver.find_element(By.ID, 'num2')
        result_field = driver.find_element(By.ID, 'result')

        input1.clear()
        input1.send_keys(str(num1))
        input2.clear()
        input2.send_keys(str(num2))

        button = driver.find_element(By.ID, operation)
        button.click()

        wait.until(lambda d: result_field.text != '')
        actual_result = result_field.text.strip()

        self.assertAlmostEqual(float(actual_result), expected, places=4, msg=f'Failed for {operation} with inputs {num1}, {num2}')

    def test_systematic_coverage(self):
        test_data = [
            (5, 3),
            (0, 0),
            (-1, 1)
        ]

        for num1, num2 in test_data:
            self.calculate_and_verify(num1, num2, 'add', num1 + num2)
            self.calculate_and_verify(num1, num2, 'subtract', num1 - num2)
            self.calculate_and_verify(num1, num2, 'multiply', num1 * num2)
            if num2 != 0:
                self.calculate_and_verify(num1, num2, 'divide', num1 / num2)
            else:
                # For division by zero, expect some error or empty result
                driver = self.driver
                driver.find_element(By.ID, 'divide').click()
                result_field = driver.find_element(By.ID, 'result')
                self.wait.until(lambda d: result_field.text != '')
                self.assertIn('error', result_field.text.lower() + ' ', 'Expected error message for division by zero')

if __name__ == '__main__':
    unittest.main()

This test script uses Selenium with Python's unittest framework to automate the calculator app.

setUp opens the browser and navigates to the calculator page.

calculate_and_verify is a helper method that inputs numbers, clicks the operation button, waits for the result, and asserts the output matches expected value with 4 decimal precision.

The test_systematic_coverage method runs the helper for three input sets: normal numbers, zeros, and negative/positive mix. This covers typical, boundary, and edge cases systematically.

Explicit waits ensure elements are ready before interaction. Clear locators by ID keep selectors stable. Assertions check correctness precisely.

This approach shows how systematic testing improves coverage by verifying multiple scenarios, not just one.

Common Mistakes - 3 Pitfalls

Using hardcoded sleep instead of explicit waits

Using brittle XPath locators that break easily

Testing only one input set

Bonus Challenge

Now add data-driven testing with 3 different input sets using unittest subTest or pytest parameterize.

Show Hint

Practice

1. Why do systematic testing techniques improve test coverage?

easy

A. They focus only on testing the user interface elements.

B. They reduce the number of tests to save time without missing bugs.

C. They randomly select test cases to find bugs quickly.

D. They organize tests to cover important cases like boundaries and input groups.

Solution

1. Step 1: Understand the purpose of systematic techniques

   Systematic techniques plan tests to cover different important scenarios, such as boundaries and input groups.

2. Step 2: Compare options with this purpose

   Only They organize tests to cover important cases like boundaries and input groups. describes organizing tests to cover important cases, which matches the purpose.

3. Final Answer:

   They organize tests to cover important cases like boundaries and input groups. -> Option D

4. Quick Check:

   Systematic testing = organized coverage [OK]

Hint: Systematic means planned and organized tests [OK]

Common Mistakes:

• Thinking fewer tests always mean better coverage
• Confusing random testing with systematic testing
• Believing UI testing covers all bugs

2. Which of the following is a correct example of a systematic testing technique?

easy

A. Skipping tests for rare input values.

B. Testing inputs randomly without any plan.

C. Testing only the first and last inputs of a range (boundary value analysis).

D. Testing only the most popular feature repeatedly.

Solution

1. Step 1: Identify systematic techniques

   Boundary value analysis is a known systematic technique focusing on edge cases.

2. Step 2: Evaluate options

   Testing only the first and last inputs of a range (boundary value analysis). matches a systematic technique; others describe random or incomplete testing.

3. Final Answer:

   Testing only the first and last inputs of a range (boundary value analysis). -> Option C

4. Quick Check:

   Boundary value analysis = systematic test [OK]

Hint: Look for planned test methods like boundary value analysis [OK]

Common Mistakes:

• Confusing random testing with systematic
• Ignoring edge cases in tests
• Assuming popular features cover all bugs

3. Consider this code snippet for testing input groups:

inputs = [1, 5, 10, 15, 20]
covered_groups = set()
for i in inputs:
    if i <= 5:
        covered_groups.add('low')
    elif i <= 15:
        covered_groups.add('medium')
    else:
        covered_groups.add('high')
print(sorted(covered_groups))

What will be the output?

medium

A. ['low', 'medium', 'high']

B. ['low', 'medium']

C. ['medium', 'high']

D. ['low', 'high']

Solution

1. Step 1: Analyze input classification

   Inputs 1 and 5 are 'low', 10 and 15 are 'medium', 20 is 'high'.

2. Step 2: Determine covered groups

   All three groups 'low', 'medium', and 'high' are added to covered_groups.

3. Final Answer:

   ['low', 'medium', 'high'] -> Option A

4. Quick Check:

   All input groups covered = ['low', 'medium', 'high'] [OK]

Hint: Check each input group coverage carefully [OK]

Common Mistakes:

• Missing the 'high' group for input 20
• Assuming 15 is 'high' instead of 'medium'
• Forgetting to sort the output

4. A tester wrote this code to check boundary values:

def test_boundary(x):
    if x > 0 and x < 10:
        return 'Inside'
    else:
        return 'Outside'

print(test_boundary(0))
print(test_boundary(10))

What is the problem with this test regarding boundary coverage?

medium

A. It misses testing the exact boundary values 0 and 10 correctly.

B. It tests values outside the range only.

C. It uses incorrect syntax for the function.

D. It returns wrong strings for inputs.

Solution

1. Step 1: Understand boundary conditions in code

   The code checks if x is strictly greater than 0 and less than 10, so 0 and 10 are excluded.

2. Step 2: Identify test coverage issue

   Testing 0 and 10 returns 'Outside', missing the boundary values as 'Inside' cases.

3. Final Answer:

   It misses testing the exact boundary values 0 and 10 correctly. -> Option A

4. Quick Check:

   Boundary values excluded = coverage gap [OK]

Hint: Check if boundaries are included or excluded in conditions [OK]

Common Mistakes:

• Assuming 0 and 10 are inside the range
• Ignoring strict inequality signs
• Thinking syntax error causes the problem

5. You want to improve test coverage for a function that accepts numbers from 1 to 100. Which systematic technique combination will best improve coverage?

hard

A. Test only random numbers within 1 to 100 repeatedly.

B. Use boundary value analysis for edges and equivalence partitioning for input groups.

C. Test only the middle value 50 multiple times.

D. Test only numbers divisible by 10.

Solution

1. Step 1: Identify coverage goals

   We want to cover edge cases and different input groups systematically.

2. Step 2: Match techniques to goals

   Boundary value analysis covers edges (1 and 100), equivalence partitioning divides inputs into groups.

3. Step 3: Evaluate options

   Use boundary value analysis for edges and equivalence partitioning for input groups. combines both techniques, improving coverage best; others are incomplete or random.

4. Final Answer:

   Use boundary value analysis for edges and equivalence partitioning for input groups. -> Option B

5. Quick Check:

   Combine boundaries + partitions = best coverage [OK]

Hint: Combine boundary and group tests for full coverage [OK]

Common Mistakes:

• Relying on random or single-value tests
• Ignoring input group diversity
• Testing only multiples or arbitrary subsets