Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Device fragmentation challenges in Testing Fundamentals - Build an Automation Script

Choose your learning style10 modes available
Verify application UI and functionality across multiple device types and screen sizes
Preconditions (3)
Step 1: Open the application on the smartphone device
Step 2: Verify that the main menu is visible and accessible
Step 3: Navigate to the settings page and verify all controls are displayed correctly
Step 4: Repeat steps 1-3 on the tablet device
Step 5: Repeat steps 1-3 on the desktop device
✅ Expected Result: The application UI elements are correctly displayed and functional on all devices without layout issues or missing controls
Automation Requirements - Selenium WebDriver with Appium for mobile devices
Assertions Needed:
Verify visibility of main menu element
Verify accessibility of main menu
Verify all controls on settings page are displayed
Verify no layout breakage or overlapping elements
Best Practices:
Use explicit waits to handle element loading
Use device-specific capabilities in Appium to target different devices
Use Page Object Model to separate page structure from test logic
Avoid hardcoded waits and use responsive locators
Automated Solution
Testing Fundamentals
from appium 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 MainPage:
    def __init__(self, driver):
        self.driver = driver
        self.menu_locator = (By.ID, "main-menu")

    def is_menu_visible(self):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.menu_locator)
        )

class SettingsPage:
    def __init__(self, driver):
        self.driver = driver
        self.controls_locator = (By.CLASS_NAME, "settings-control")

    def are_controls_displayed(self):
        controls = WebDriverWait(self.driver, 10).until(
            EC.presence_of_all_elements_located(self.controls_locator)
        )
        return all(control.is_displayed() for control in controls)


def test_app_on_device(device_capabilities):
    driver = webdriver.Remote('http://localhost:4723/wd/hub', device_capabilities)
    try:
        main_page = MainPage(driver)
        assert main_page.is_menu_visible(), "Main menu is not visible"

        # Navigate to settings page
        settings_button = WebDriverWait(driver, 10).until(
            EC.element_to_be_clickable((By.ID, "settings-button"))
        )
        settings_button.click()

        settings_page = SettingsPage(driver)
        assert settings_page.are_controls_displayed(), "Settings controls are not all displayed"

    finally:
        driver.quit()


if __name__ == "__main__":
    devices = [
        {"platformName": "Android", "deviceName": "Android_Smartphone", "app": "/path/to/app.apk"},
        {"platformName": "iOS", "deviceName": "iPad_Tablet", "app": "/path/to/app.app"},
        {"platformName": "Windows", "deviceName": "Desktop", "app": "C:/path/to/app.exe"}
    ]

    for device in devices:
        test_app_on_device(device)

This test script uses Appium with Selenium WebDriver to automate testing on multiple devices.

The MainPage and SettingsPage classes follow the Page Object Model to keep locators and actions organized.

Explicit waits ensure elements are loaded before interacting or asserting visibility.

The test_app_on_device function runs the test steps on each device using its capabilities.

Assertions check that the main menu is visible and all settings controls are displayed, matching the manual test case expectations.

Finally, the driver quits to clean up after each test run.

Common Mistakes - 3 Pitfalls
Using hardcoded sleep() calls instead of explicit waits
Using device-specific locators that do not work across devices
Not quitting the driver after each test
Bonus Challenge

Now add data-driven testing with 3 different device configurations including different OS versions and screen sizes

Show Hint

Practice

(1/5)
1. What does device fragmentation mean in software testing?
easy
A. All devices run the software exactly the same way
B. There are many different devices and OS versions to test on
C. Testing is done only on one device type
D. Testing is only done on simulators, not real devices

Solution

  1. Step 1: Understand device fragmentation concept

    Device fragmentation means there are many different devices and operating system versions in use.
  2. Step 2: Match the meaning to options

    There are many different devices and OS versions to test on correctly describes this as many devices and OS versions to test on, making testing harder.
  3. Final Answer:

    There are many different devices and OS versions to test on -> Option B
  4. Quick Check:

    Device fragmentation = many devices and OS versions [OK]
Hint: Device fragmentation means many device types exist [OK]
Common Mistakes:
  • Thinking fragmentation means testing on only one device
  • Assuming all devices behave the same
  • Confusing simulators with real device variety
2. Which of the following is the correct way to handle device fragmentation during testing?
easy
A. Ignore OS versions and test only on one device brand
B. Test only on the newest device model
C. Use a mix of real devices and simulators covering popular OS versions
D. Test only on simulators without real devices

Solution

  1. Step 1: Identify best practice for device fragmentation

    Testing on a mix of real devices and simulators covering popular OS versions helps catch issues across many device types.
  2. Step 2: Compare options to best practice

    Use a mix of real devices and simulators covering popular OS versions matches this approach, while others ignore variety or real devices.
  3. Final Answer:

    Use a mix of real devices and simulators covering popular OS versions -> Option C
  4. Quick Check:

    Best practice = mix real devices + simulators [OK]
Hint: Use both real devices and simulators for broad coverage [OK]
Common Mistakes:
  • Testing only on newest devices misses older versions
  • Ignoring OS versions reduces test coverage
  • Relying solely on simulators misses real device issues
3. Consider this test plan snippet:
devices = ['iPhone 12', 'Samsung S21', 'Pixel 6']
results = []
for device in devices:
    if device == 'iPhone 12':
        results.append('Pass')
    else:
        results.append('Fail')
print(results)

What will be the output?
medium
A. ['Pass', 'Fail', 'Fail']
B. ['Pass', 'Pass', 'Pass']
C. ['Fail', 'Fail', 'Fail']
D. ['Fail', 'Pass', 'Fail']

Solution

  1. Step 1: Analyze the loop and condition

    The loop checks each device; if it is 'iPhone 12', append 'Pass', else 'Fail'.
  2. Step 2: Evaluate each device

    'iPhone 12' -> 'Pass', 'Samsung S21' -> 'Fail', 'Pixel 6' -> 'Fail'. So results = ['Pass', 'Fail', 'Fail'].
  3. Final Answer:

    ['Pass', 'Fail', 'Fail'] -> Option A
  4. Quick Check:

    Only iPhone 12 passes, others fail [OK]
Hint: Check condition for each device in the list [OK]
Common Mistakes:
  • Assuming all devices pass
  • Mixing up Pass and Fail logic
  • Ignoring the else condition
4. A tester wrote this code to test multiple devices:
devices = ['iPhone 11', 'Galaxy S20', 'Pixel 5']
for i in range(len(devices)):
    print(devices[i+1])

What error will occur when running this code?
medium
A. IndexError: list index out of range
B. SyntaxError: invalid syntax
C. TypeError: unsupported operand type(s)
D. No error, prints all devices

Solution

  1. Step 1: Understand the loop and indexing

    The loop runs from i=0 to i=2 (length 3). The code tries to access devices[i+1].
  2. Step 2: Identify when index goes out of range

    When i=2, devices[3] is accessed, which is out of range, causing IndexError.
  3. Final Answer:

    IndexError: list index out of range -> Option A
  4. Quick Check:

    Accessing devices[i+1] at last index causes IndexError [OK]
Hint: Check index +1 against list length to avoid errors [OK]
Common Mistakes:
  • Thinking code runs without error
  • Confusing IndexError with SyntaxError
  • Ignoring loop range and indexing
5. You must design a test strategy to handle device fragmentation for an app supporting Android and iOS. Which approach best balances coverage and resources?
hard
A. Test only on the latest Android and iOS devices
B. Test only on simulators for both Android and iOS
C. Test on every device model available in the market
D. Test on popular devices from both OS families plus simulators for older versions

Solution

  1. Step 1: Understand resource constraints and coverage needs

    Testing every device is impossible; testing only latest devices misses many users.
  2. Step 2: Choose balanced approach

    Test on popular devices from both OS families plus simulators for older versions tests popular devices plus simulators for older OS versions, balancing coverage and resources effectively.
  3. Final Answer:

    Test on popular devices from both OS families plus simulators for older versions -> Option D
  4. Quick Check:

    Balanced test strategy = popular devices + simulators [OK]
Hint: Cover popular devices and OS versions, not all [OK]
Common Mistakes:
  • Trying to test every device wastes resources
  • Testing only newest devices misses many users
  • Relying solely on simulators misses real device issues
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