Why testing ensures app quality in iOS Swift - Build It to Prove It

Build: Simple Counter with Test

This screen shows a number that can be increased by tapping a button. It includes a test to check if the counter works correctly. Testing helps catch mistakes early and keeps the app working well.

Target UI

-------------------
|   Simple Counter  |
|------------------|
|                  |
|       0          |
|                  |
|  [+] Increase     |
-------------------

Display a number starting at 0

Add a button labeled '+' that increases the number by 1 when tapped

Write a unit test to verify the number increases correctly

Show how testing helps ensure the app works as expected

Starter Code

iOS Swift

import SwiftUI

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 40) {
            Text("Simple Counter")
                .font(.title)
                .padding()
            Text("\(count)")
                .font(.system(size: 72, weight: .bold))
            Button(action: {
                // TODO: Increase count by 1
            }) {
                Text("+")
                    .font(.largeTitle)
                    .frame(width: 80, height: 80)
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .clipShape(Circle())
            }
        }
    }
}

struct CounterView_Previews: PreviewProvider {
    static var previews: some View {
        CounterView()
    }
}

// TODO: Add unit test for CounterView logic

Task 1

Task 2

Solution

iOS Swift

import SwiftUI

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 40) {
            Text("Simple Counter")
                .font(.title)
                .padding()
            Text("\(count)")
                .font(.system(size: 72, weight: .bold))
            Button(action: {
                count += 1
            }) {
                Text("+")
                    .font(.largeTitle)
                    .frame(width: 80, height: 80)
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .clipShape(Circle())
                    .accessibilityLabel("Increase count")
            }
        }
    }
}

// Unit test example
import XCTest

final class CounterViewTests: XCTestCase {
    func testIncrement() {
        var count = 0
        // Simulate button tap increasing count
        count += 1
        XCTAssertEqual(count, 1, "Count should increase by 1")
    }
}

struct CounterView_Previews: PreviewProvider {
    static var previews: some View {
        CounterView()
    }
}

This app shows a number starting at zero. When the user taps the '+' button, the number increases by one. This is done by adding count += 1 inside the button's action.

The unit test simulates increasing the count and checks if the value is correct. Testing like this helps catch errors early, so the app behaves as expected and stays reliable.

Accessibility label is added to the button for screen readers, making the app friendly for all users.

Final Result

Completed Screen

-------------------
|   Simple Counter  |
|------------------|
|                  |
|       1          |
|                  |
|  [+] Increase     |
-------------------

User taps the '+' button

The number on screen increases by 1 each tap

Unit test confirms the increment logic works correctly

Stretch Goal

Add a reset button to set the counter back to zero

💡 Hint

Add another button labeled 'Reset' that sets count = 0 when tapped

Practice

1. Why is testing important for mobile apps?
Testing helps to:

easy

A. Make the app run faster on all devices

B. Reduce the app size on the device

C. Add new features automatically

D. Find bugs before users encounter them

Solution

1. Step 1: Understand the purpose of testing

   Testing is done to catch errors or bugs early, before users find them.

2. Step 2: Compare options with testing goals

   Only Find bugs before users encounter them matches the main goal of testing, which is bug detection.

3. Final Answer:

   Find bugs before users encounter them -> Option D

4. Quick Check:

   Testing finds bugs early = B [OK]

Hint: Testing finds bugs early to improve app quality [OK]

Common Mistakes:

• Confusing testing with performance optimization
• Thinking testing adds features automatically
• Believing testing reduces app size

2. Which Swift code snippet correctly defines a simple test function?

easy

A. func testExample() { XCTAssertTrue(true) }

B. func testExample { XCTAssertTrue(true) }

C. func testExample() -> Bool { return true }

D. testExample() { XCTAssertTrue(true) }

Solution

1. Step 1: Check Swift function syntax

   Functions need parentheses () after the name and braces {} around the body.

2. Step 2: Identify correct test function format

   func testExample() { XCTAssertTrue(true) } correctly defines a function with parentheses and calls XCTAssertTrue inside.

3. Final Answer:

   func testExample() { XCTAssertTrue(true) } -> Option A

4. Quick Check:

   Correct Swift function syntax = A [OK]

Hint: Swift functions need () after name and {} for body [OK]

Common Mistakes:

• Omitting parentheses after function name
• Missing braces around function body
• Returning a value in a test function

3. What will be the output when this test runs?

func testSum() {
  let result = 2 + 3
  XCTAssertEqual(result, 5)
}

medium

A. Syntax error in test function

B. Test fails with error

C. Test passes with no errors

D. Test is skipped automatically

Solution

1. Step 1: Evaluate the calculation in testSum()

   The sum 2 + 3 equals 5, so result is 5.

2. Step 2: Check XCTAssertEqual condition

   XCTAssertEqual compares result (5) with expected value (5), which matches.

3. Final Answer:

   Test passes with no errors -> Option C

4. Quick Check:

   Correct assertion means test passes = A [OK]

Hint: If values match XCTAssertEqual, test passes [OK]

Common Mistakes:

• Assuming test fails if no print output
• Confusing XCTAssertEqual with XCTAssertTrue
• Thinking test runs only if called explicitly

4. Identify the error in this test code:

func testIsEven() {
  let number = 4
  XCTAssertTrue(number % 2 == 1)
}

medium

A. Syntax error in XCTAssertTrue usage

B. The test incorrectly checks for odd instead of even

C. Missing return type in function

D. Variable number should be a constant

Solution

1. Step 1: Understand the test purpose

   The function name suggests checking if number is even.

2. Step 2: Analyze the assertion condition

   number % 2 == 1 checks if number is odd, which is wrong for even check.

3. Final Answer:

   The test incorrectly checks for odd instead of even -> Option B

4. Quick Check:

   Mismatch between test name and condition = C [OK]

Hint: Check if test condition matches test name intent [OK]

Common Mistakes:

• Confusing odd and even conditions
• Ignoring test function naming conventions
• Assuming syntax error when logic is wrong

5. How does automated testing help maintain app quality after adding new features?

hard

A. By running tests to catch bugs introduced by changes

B. By automatically rewriting code for better performance

C. By reducing the app size after new features

D. By disabling old features to avoid conflicts

Solution

1. Step 1: Understand automated testing role

   Automated tests run existing checks quickly after code changes.

2. Step 2: Identify how tests maintain quality

   They catch bugs early that new features might cause, preventing issues.

3. Final Answer:

   By running tests to catch bugs introduced by changes -> Option A

4. Quick Check:

   Automated tests catch new bugs = D [OK]

Hint: Tests catch bugs after changes to keep app stable [OK]

Common Mistakes:

• Thinking tests rewrite or optimize code
• Believing tests reduce app size
• Assuming tests disable old features