Parameterized Testing in Swift: Cartesians vs Zipped Arguments

When verifying calculations, parsing logic, or validation rules across multiple inputs, writing separate test cases for each value is tedious. In XCTest, developers typically solved this by wrapping assertions inside a for-in loop. However, this approach had a major drawback: if the second input failed, the loop aborted, hiding failures from subsequent inputs.

The new Swift Testing framework introduces built-in parameterized testing via the @Test macro. It runs each input case independently, reporting individual successes and failures. To use this effectively, you need to understand the difference between Cartesian products and zipped arguments.

---

Cartesian Product: Testing Every Combination

If you pass multiple separate collections to the arguments parameter of the @Test macro, Swift Testing automatically generates a test case for every possible combination (the Cartesian product) of those inputs.

import Testing

// This test will execute 9 times (3 inputs * 3 expected multipliers)
@Test("Multiplication parity", arguments: [2, 8, 50], [3, 5, 9])
func verifyParity(value: Int, multiplier: Int) {
    let result = value * multiplier
    
    // Developer Thoughts: If any specific combination fails, 
    // the test navigator displays the exact arguments that triggered the failure.
    #expect(result.isMultiple(of: 2))
}

This is ideal when you need to verify that your code remains consistent across the entire matrix of input combinations.

---

Zipped Arguments: Testing Coupled Pairs

If your inputs are logically paired—for example, mapping a raw user input string to its expected normalized output—generating all combinations is incorrect. Instead, you want to test positionally matched pairs using zip:

import Testing

// This test will execute 3 times, matching inputs positionally
@Test("String normalization", arguments: zip(
    [" john ", "ALICE", "Bob"],
    ["john", "alice", "bob"]
))
func verifyNormalization(input: String, expected: String) {
    let normalized = input.trimmingCharacters(in: .whitespaces).lowercased()
    
    // Developer Thoughts: Since we zipped the arguments, 
    // the test only runs for " john " -> "john", "ALICE" -> "alice", etc.
    #expect(normalized == expected)
}

---

Summary

Swift Testing’s parameterized tests make it easy to run the same validation logic across multiple datasets. Use separate collections to test every possible combination of inputs, and use zip to run tests on specific pairs. Keep in mind that the built-in zip function handles up to two collections; for three or more paired arguments, define a custom structure to hold your test data.

References & Further Reading

• Swift Testing documentation on Swift.org
• Apple Developer Documentation on Test Arguments