Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Equivalence partitioning in Testing Fundamentals - Build an Automation Script

Choose your learning style10 modes available
Test input field with equivalence partitioning
Preconditions (1)
Step 1: Enter a value less than 18 in the age input field and submit the form.
Step 2: Enter a value between 18 and 60 inclusive in the age input field and submit the form.
Step 3: Enter a value greater than 60 in the age input field and submit the form.
✅ Expected Result: For values less than 18 or greater than 60, the form shows an error message 'Age must be between 18 and 60'. For values between 18 and 60 inclusive, the form submits successfully and shows a success message.
Automation Requirements - Selenium with Python
Assertions Needed:
Verify error message is displayed for invalid age inputs (less than 18 and greater than 60).
Verify success message is displayed for valid age inputs (between 18 and 60 inclusive).
Best Practices:
Use explicit waits to wait for elements to be visible.
Use clear and maintainable locators (e.g., By.ID or By.CSS_SELECTOR).
Separate test data from test logic.
Use assertions that clearly check the expected messages.
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 TestAgeInputEquivalencePartitioning(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('http://example.com/age-form')  # Replace with actual URL
        self.wait = WebDriverWait(self.driver, 10)

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

    def submit_age_and_get_message(self, age):
        age_input = self.wait.until(EC.visibility_of_element_located((By.ID, 'age')))
        age_input.clear()
        age_input.send_keys(str(age))
        submit_button = self.driver.find_element(By.ID, 'submit')
        submit_button.click()
        message = self.wait.until(EC.visibility_of_element_located((By.ID, 'message')))
        return message.text

    def test_age_less_than_18(self):
        message = self.submit_age_and_get_message(17)
        self.assertEqual(message, 'Age must be between 18 and 60')

    def test_age_between_18_and_60(self):
        for valid_age in [18, 30, 60]:
            message = self.submit_age_and_get_message(valid_age)
            self.assertEqual(message, 'Form submitted successfully')

    def test_age_greater_than_60(self):
        message = self.submit_age_and_get_message(61)
        self.assertEqual(message, 'Age must be between 18 and 60')

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

This test script uses Selenium with Python's unittest framework to automate the equivalence partitioning test for an age input field.

setUp opens the browser and navigates to the form page.

tearDown closes the browser after each test.

The helper method submit_age_and_get_message enters the age, submits the form, and waits for the message to appear, returning its text.

Three test methods cover the partitions:

  • test_age_less_than_18 tests an invalid low age and expects an error message.
  • test_age_between_18_and_60 tests valid ages including boundary values and expects a success message.
  • test_age_greater_than_60 tests an invalid high age and expects an error message.

Explicit waits ensure elements are ready before interaction. Locators use IDs for clarity and maintainability. Assertions check the exact expected messages to confirm correct behavior.

Common Mistakes - 4 Pitfalls
Using hardcoded sleeps instead of explicit waits
Using brittle XPath locators that depend on full element paths
Not clearing the input field before entering new data
Testing only one value per partition
Bonus Challenge

Now add data-driven testing with 3 different inputs for each partition (less than 18, valid range, greater than 60).

Show Hint

Practice

(1/5)
1. What is the main purpose of equivalence partitioning in software testing?
easy
A. To test every possible input value individually
B. To write code for automated testing
C. To divide input data into groups where test cases can be reduced
D. To check the user interface design

Solution

  1. Step 1: Understand equivalence partitioning concept

    Equivalence partitioning divides input data into groups where all inputs in a group behave similarly.
  2. Step 2: Identify the main goal

    The goal is to reduce the number of test cases by testing one value from each group instead of all values.
  3. Final Answer:

    To divide input data into groups where test cases can be reduced -> Option C
  4. Quick Check:

    Equivalence partitioning = reduce test cases [OK]
Hint: Group inputs to test fewer cases efficiently [OK]
Common Mistakes:
  • Thinking it tests every input value
  • Confusing with UI testing
  • Assuming it is about coding tests
2. Which of the following is the correct way to apply equivalence partitioning for an input field that accepts ages from 18 to 60?
easy
A. Test ages 17, 18, 30, 60, 61
B. Test ages 18, 30, 60 only
C. Test ages 0, 18, 60, 100
D. Test ages 18, 19, 20, 21

Solution

  1. Step 1: Identify equivalence partitions

    Partitions are: below valid range (<18), valid range (18-60), above valid range (>60).
  2. Step 2: Select test values from each partition

    Choose one value from each: 17 (below), 18 and 60 (edges of valid), 30 (inside valid), 61 (above).
  3. Final Answer:

    Test ages 17, 18, 30, 60, 61 -> Option A
  4. Quick Check:

    Test one from each partition [OK]
Hint: Pick one value from each input group including edges [OK]
Common Mistakes:
  • Testing only valid values
  • Ignoring boundary values
  • Testing too many values inside one partition
3. Given the input field accepts numbers 1 to 100, which test inputs represent valid equivalence partitions?
medium
A. [50, 75, 100]
B. [0, 1, 50, 100, 101]
C. [-1, 0, 101]
D. [1, 50, 100]

Solution

  1. Step 1: Define partitions

    Partitions are: below valid (<1), valid (1-100), above valid (>100).
  2. Step 2: Check which inputs cover all partitions

    [0, 1, 50, 100, 101] includes 0 (below), 1 and 100 (edges valid), 50 (inside valid), 101 (above).
  3. Final Answer:

    [0, 1, 50, 100, 101] -> Option B
  4. Quick Check:

    Inputs cover all partitions [OK]
Hint: Include below, inside, and above range values [OK]
Common Mistakes:
  • Missing values outside valid range
  • Testing only inside range
  • Ignoring boundary values
4. You have a form field that accepts a password length from 8 to 12 characters. Which test set correctly applies equivalence partitioning and fixes the error in this set: [7, 8, 10, 12, 13]?
medium
A. [7, 8, 10, 12, 13]
B. [8, 10, 12]
C. [7, 8, 12, 13]
D. [6, 8, 10, 12, 14]

Solution

  1. Step 1: Identify partitions and errors

    Partitions: below valid (<8), valid (8-12), above valid (>12). The original set misses some below and above values.
  2. Step 2: Fix test set to cover all partitions

    [6, 8, 10, 12, 14] adds 6 (below), 14 (above), and includes valid 8, 10, 12, covering all partitions correctly.
  3. Final Answer:

    [6, 8, 10, 12, 14] -> Option D
  4. Quick Check:

    Test covers below, valid, and above partitions [OK]
Hint: Include clear below and above boundary values [OK]
Common Mistakes:
  • Missing values outside valid range
  • Not testing boundary values
  • Using only valid inputs
5. A software accepts input scores from 0 to 100. Using equivalence partitioning, which test inputs should you select to cover all partitions if the input is extended to accept decimal values between 0.0 and 100.0?
hard
A. [ -1, 0.0, 50.5, 100.0, 101 ]
B. [ 0, 25, 50, 75, 100 ]
C. [ 0.0, 50.0, 100.0 ]
D. [ -0.1, 0, 50, 100, 100.1 ]

Solution

  1. Step 1: Define partitions including decimals

    Partitions: below valid (<0.0), valid (0.0 to 100.0), above valid (>100.0). Decimals allowed inside valid range.
  2. Step 2: Choose test inputs covering all partitions

    [ -1, 0.0, 50.5, 100.0, 101 ] includes -1 (below), 0.0 (valid edge), 50.5 (valid decimal), 100.0 (valid edge), 101 (above).
  3. Final Answer:

    [ -1, 0.0, 50.5, 100.0, 101 ] -> Option A
  4. Quick Check:

    Test inputs cover all partitions including decimals [OK]
Hint: Include decimals and boundary values in partitions [OK]
Common Mistakes:
  • Ignoring decimal values inside valid range
  • Missing values outside valid range
  • Testing only integers
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard