Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Testing vs debugging distinction in Testing Fundamentals - Automation Approaches Compared

Choose your learning style10 modes available
Verify that the calculator adds two numbers correctly and debug if it fails
Preconditions (2)
Step 1: Enter number 5 in the first input field
Step 2: Enter number 3 in the second input field
Step 3: Click the 'Add' button
Step 4: Observe the result displayed
✅ Expected Result: The result displayed should be 8
Automation Requirements - unittest with Selenium WebDriver
Assertions Needed:
Verify the displayed result equals '8'
Best Practices:
Use explicit waits to wait for result element
Use clear and maintainable locators (e.g., By.ID or By.NAME)
Separate test logic from debugging code
Use descriptive assertion messages
Automated Solution
Testing Fundamentals
import unittest
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

class CalculatorTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('http://localhost:8000/calculator')  # Example URL

    def test_addition(self):
        driver = self.driver
        # Enter first number
        input1 = driver.find_element(By.ID, 'input1')
        input1.clear()
        input1.send_keys('5')

        # Enter second number
        input2 = driver.find_element(By.ID, 'input2')
        input2.clear()
        input2.send_keys('3')

        # Click Add button
        add_button = driver.find_element(By.ID, 'add-btn')
        add_button.click()

        # Wait for result to appear
        wait = WebDriverWait(driver, 10)
        result_element = wait.until(EC.visibility_of_element_located((By.ID, 'result')))

        # Assert the result is '8'
        result_text = result_element.text
        self.assertEqual(result_text, '8', f'Expected result to be 8 but got {result_text}')

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

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

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

setUp() opens the browser and navigates to the calculator page.

test_addition() enters the numbers 5 and 3, clicks the Add button, waits explicitly for the result element to appear, then asserts the displayed result equals '8'.

Explicit waits ensure the test waits for the result instead of using fixed delays.

Locators use By.ID for clarity and maintainability.

tearDown() closes the browser after the test.

This clear separation of test steps and assertions helps distinguish testing (checking the result) from debugging (fixing issues if the test fails).

Common Mistakes - 3 Pitfalls
Using time.sleep() instead of explicit waits
Using brittle XPath locators that break easily
Mixing debugging print statements inside test assertions
Bonus Challenge

Now add data-driven testing with 3 different pairs of numbers to verify addition works for all.

Show Hint

Practice

(1/5)
1. What is the main purpose of testing in software development?
easy
A. To find bugs by checking if the software works as expected
B. To fix the cause of bugs in the code
C. To write new features for the software
D. To design the user interface

Solution

  1. Step 1: Understand the role of testing

    Testing is about running the software to check if it behaves correctly and to find any bugs.
  2. Step 2: Differentiate testing from debugging

    Debugging is about finding and fixing the cause of bugs, not just finding them.
  3. Final Answer:

    To find bugs by checking if the software works as expected -> Option A
  4. Quick Check:

    Testing = Find bugs [OK]
Hint: Testing finds bugs; debugging fixes bugs [OK]
Common Mistakes:
  • Confusing testing with fixing bugs
  • Thinking testing creates new features
  • Mixing testing with design tasks
2. Which of the following best describes debugging?
easy
A. Writing code to add features
B. Finding and fixing the cause of bugs
C. Running tests to find errors
D. Designing test cases

Solution

  1. Step 1: Define debugging

    Debugging means investigating the cause of bugs and correcting them in the code.
  2. Step 2: Compare with other options

    Running tests is testing, not debugging. Writing features and designing tests are different tasks.
  3. Final Answer:

    Finding and fixing the cause of bugs -> Option B
  4. Quick Check:

    Debugging = Fix bugs [OK]
Hint: Debugging fixes bugs, not just finds them [OK]
Common Mistakes:
  • Confusing debugging with testing
  • Thinking debugging is writing new code
  • Mixing debugging with test design
3. Consider this scenario: A tester runs a test and finds the software crashes when clicking a button. What is the next step in debugging?
medium
A. Write more test cases for other buttons
B. Ignore the crash and continue testing
C. Analyze the code to find why the crash happens
D. Change the button label text

Solution

  1. Step 1: Identify the testing result

    The test found a crash when clicking a button, indicating a bug.
  2. Step 2: Understand debugging action

    Debugging means analyzing the code to find the cause of the crash and fix it.
  3. Final Answer:

    Analyze the code to find why the crash happens -> Option C
  4. Quick Check:

    Debugging = Analyze and fix bug [OK]
Hint: After finding bug, analyze code cause [OK]
Common Mistakes:
  • Continuing testing without fixing bugs
  • Ignoring bugs found during testing
  • Changing unrelated UI elements
4. A developer writes code but the program crashes. Which step is part of debugging to fix this?
medium
A. Run tests to find if the program crashes
B. Write more features before fixing the crash
C. Ignore the crash and release the software
D. Check the error message and trace the code causing the crash

Solution

  1. Step 1: Identify debugging task

    Debugging involves checking error messages and tracing code to find the cause of crashes.
  2. Step 2: Eliminate incorrect options

    Running tests finds bugs but does not fix them. Writing features or ignoring crashes are wrong.
  3. Final Answer:

    Check the error message and trace the code causing the crash -> Option D
  4. Quick Check:

    Debugging = Trace and fix errors [OK]
Hint: Use error messages to trace bugs [OK]
Common Mistakes:
  • Confusing testing with debugging
  • Skipping error analysis
  • Adding features before fixing bugs
5. A software tester finds a bug where the app crashes only when a specific input is given. What is the best combined approach to handle this?
hard
A. Write a test case for that input and then debug the code to fix the crash
B. Ignore the input and test other features
C. Fix the code without writing any test cases
D. Write test cases for all inputs except the problematic one

Solution

  1. Step 1: Understand testing role

    Writing a test case for the specific input helps reproduce and confirm the bug.
  2. Step 2: Understand debugging role

    Debugging the code to fix the crash addresses the root cause of the bug.
  3. Step 3: Combine testing and debugging

    Both steps together ensure the bug is found, fixed, and verified.
  4. Final Answer:

    Write a test case for that input and then debug the code to fix the crash -> Option A
  5. Quick Check:

    Test to find + Debug to fix = Correct approach [OK]
Hint: Test to find bug, debug to fix bug [OK]
Common Mistakes:
  • Skipping test case creation for bugs
  • Fixing bugs without verifying
  • Ignoring problematic inputs
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