XCTest framework in iOS Swift - Mini App: Build & Ship

Build: Simple Calculator Tests

Create unit tests for a simple calculator class using XCTest framework to verify addition and subtraction functions work correctly.

Target UI

-------------------------
| Simple Calculator Tests |
-------------------------
| Test Addition          |
| Test Subtraction       |
-------------------------

Create a Calculator class with add and subtract methods.

Write XCTest unit tests to check if add and subtract return correct results.

Use XCTAssertEqual to compare expected and actual results.

Include setup and teardown methods in the test class.

Starter Code

iOS Swift

import XCTest
@testable import YourAppModule

class Calculator {
    func add(_ a: Int, _ b: Int) -> Int {
        // TODO: Implement addition
        return 0
    }
    func subtract(_ a: Int, _ b: Int) -> Int {
        // TODO: Implement subtraction
        return 0
    }
}

class CalculatorTests: XCTestCase {
    var calculator: Calculator!

    override func setUp() {
        super.setUp()
        // TODO: Initialize calculator
    }

    override func tearDown() {
        // TODO: Deinitialize calculator
        super.tearDown()
    }

    func testAddition() {
        // TODO: Test add method
    }

    func testSubtraction() {
        // TODO: Test subtract method
    }
}

Task 1

Task 2

Task 3

Task 4

Task 5

Solution

iOS Swift

import XCTest
@testable import YourAppModule

class Calculator {
    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
    func subtract(_ a: Int, _ b: Int) -> Int {
        return a - b
    }
}

class CalculatorTests: XCTestCase {
    var calculator: Calculator!

    override func setUp() {
        super.setUp()
        calculator = Calculator()
    }

    override func tearDown() {
        calculator = nil
        super.tearDown()
    }

    func testAddition() {
        let result = calculator.add(2, 3)
        XCTAssertEqual(result, 5, "Addition should return the sum of two numbers")
    }

    func testSubtraction() {
        let result = calculator.subtract(5, 3)
        XCTAssertEqual(result, 2, "Subtraction should return the difference of two numbers")
    }
}

This solution creates a simple Calculator class with two methods: add and subtract. Each method returns the correct arithmetic result.

The CalculatorTests class inherits from XCTestCase. It uses setUp() to create a new calculator instance before each test and tearDown() to clean up after tests.

Two test methods check the calculator's behavior: testAddition verifies that adding 2 and 3 returns 5, and testSubtraction verifies that subtracting 3 from 5 returns 2. The XCTAssertEqual function compares expected and actual results, showing a message if the test fails.

This approach helps ensure the calculator works correctly and teaches how to write basic unit tests with XCTest.

Final Result

Completed Screen

-------------------------
| Simple Calculator Tests |
-------------------------
| [check] Test Addition Passed  |
| [check] Test Subtraction Passed|
-------------------------

Run tests in Xcode test navigator or command line.

See green checkmarks if tests pass.

See error messages if tests fail.

Stretch Goal

Add a test for multiplication method in Calculator and implement it.

💡 Hint

Create a multiply(_:_:) method in Calculator and write testMultiplication() using XCTAssertEqual.

Practice

1. What is the main purpose of the XCTest framework in iOS development?

easy

A. To manage app navigation between screens

B. To write automated tests that check app behavior

C. To design user interfaces visually

D. To optimize app performance during runtime

Solution

1. Step 1: Understand XCTest role

   XCTest is designed to help developers write tests that automatically verify if the app works as expected.

2. Step 2: Compare options with XCTest purpose

   Only To write automated tests that check app behavior describes writing automated tests, which matches XCTest's main use.

3. Final Answer:

   To write automated tests that check app behavior -> Option B

4. Quick Check:

   XCTest = Automated testing [OK]

Hint: XCTest is for testing, not UI or navigation [OK]

Common Mistakes:

• Confusing XCTest with UI design tools
• Thinking XCTest manages app navigation
• Assuming XCTest improves runtime speed

2. Which of the following is the correct way to declare a test method inside an XCTestCase subclass?

easy

A. func TestExample() { }

B. func exampleTest() { }

C. func testExample() { }

D. test func example() { }

Solution

1. Step 1: Recall XCTest method naming rules

   Test methods must start with 'test' and be declared as functions with no parameters.

2. Step 2: Check each option

   func testExample() { } uses 'func testExample() { }' which follows the naming convention. Others either have wrong order, capitalization, or syntax.

3. Final Answer:

   func testExample() { } -> Option C

4. Quick Check:

   Test methods start with 'test' [OK]

Hint: Test methods must start with 'test' keyword [OK]

Common Mistakes:

• Starting method name without 'test'
• Capitalizing 'Test' instead of 'test'
• Incorrect function syntax

3. What will be the result of this test method when run?

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

medium

A. Test passes successfully

B. Test fails with assertion error

C. Test causes a compile-time error

D. Test is ignored and not run

Solution

1. Step 1: Evaluate the calculation

   The code calculates 2 + 3 and stores 5 in 'result'.

2. Step 2: Check the assertion

   XCTAssertEqual compares 'result' with 5, which is true, so the assertion passes.

3. Final Answer:

   Test passes successfully -> Option A

4. Quick Check:

   2 + 3 equals 5, assertion passes [OK]

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

Common Mistakes:

• Assuming test fails if no explicit pass message
• Confusing compile errors with assertion failures
• Thinking test is skipped without reason

4. Identify the error in this test method:

func testDivide() {
  let result = 10 / 0
  XCTAssertEqual(result, 0)
}

medium

A. XCTAssertEqual syntax is incorrect

B. Missing return type in function declaration

C. Test method name does not start with 'test'

D. Division by zero causes runtime crash

Solution

1. Step 1: Analyze the division operation

   Dividing 10 by 0 causes a runtime error (crash) because division by zero is undefined.

2. Step 2: Check other parts

   XCTAssertEqual syntax is correct, method name starts with 'test', and return type is not needed for test methods.

3. Final Answer:

   Division by zero causes runtime crash -> Option D

4. Quick Check:

   Division by zero crashes app [OK]

Hint: Division by zero always crashes at runtime [OK]

Common Mistakes:

• Thinking XCTAssertEqual syntax is wrong
• Believing test method needs return type
• Ignoring runtime errors from invalid math

5. You want to test a function that returns an optional string. Which assertion correctly verifies the function returns a non-nil value?

func testOptionalString() {
  let result = getOptionalString()
  // Which assertion to use?
}

hard

A. XCTAssertNotNil(result)

B. XCTAssertEqual(result, "")

C. XCTAssertTrue(result == nil)

D. XCTAssertFalse(result != nil)

Solution

1. Step 1: Understand the goal

   We want to check that 'result' is not nil, meaning it contains a value.

2. Step 2: Match assertion to goal

   XCTAssertNotNil checks that the value is not nil, which fits perfectly. Other options either check for empty string or nil incorrectly.

3. Final Answer:

   XCTAssertNotNil(result) -> Option A

4. Quick Check:

   Use XCTAssertNotNil to check non-nil values [OK]

Hint: Use XCTAssertNotNil to confirm value exists [OK]

Common Mistakes:

• Using XCTAssertEqual with empty string instead of nil check
• Confusing XCTAssertTrue with wrong condition
• Using XCTAssertFalse with incorrect logic