Swift Testing: The Complete Guide from Swift 6.0 to 6.2

Swift Testing represents a revolution in the Apple testing ecosystem. Designed natively for Swift, this modern framework progressively replaces XCTest with an expressive syntax, powerful macros, and perfect integration with Swift Concurrency. This comprehensive guide covers everything you need to know, from fundamentals to advanced features in Swift 6.2.

After more than 10 years of XCTest, Apple has completely rethought the testing approach. Swift Testing is not an evolution of XCTest — it's a complete rewrite, designed for modern Swift.

The main motivations:

The central philosophy: testing should not be a burden. Swift Testing makes writing tests as natural as writing production code.

Before diving into details, here's a quick comparison of the two approaches:

Swift Testing and XCTest can coexist in the same project. UI and performance tests remain XCTest-exclusive.

Swift Testing has evolved rapidly since its introduction:

First appearance of the framework in preview, allowing early adopters to test the approach.

Official release with Xcode 16. The framework becomes production-ready with:

Three major proposals integrated:

Significant evolutions with Xcode 26:

In active discussion:

For a Swift Package, add the test dependency:

In Xcode 16+, Swift Testing is automatically available. Simply create a file in your test target:

To develop with Swift Testing:

You can have XCTest and Swift Testing files in the same target:

Both frameworks run together via swift test or the Xcode Test Navigator.

The @Test macro marks a function as a test:

Unlike XCTest, no need to prefix with test. The function name is free.

Add a readable name for reports:

Swift 6.2 allows using backticks for expressive names:

The function name directly becomes the display name, without duplication.

Group related tests in a suite:

Suites can be nested:

#expect() is the main assertion. It accepts any boolean expression:

On failure, Swift Testing displays a rich contextual message showing actual values.

#require() stops the test immediately if the condition fails. Useful for preconditions:

#require() can also unwrap optionals:

To verify that a function throws an error:

Swift 6.1 allows retrieving the error for additional assertions:

Swift Testing natively supports async/await:

Use the .timeLimit trait to avoid blocking tests:

Parameterized tests run the same test with different inputs:

This test runs 5 times, once per argument.

For enums, use allCases:

Test all combinations of two sets:

To test input/output pairs:

Traits modify the behavior of a test or suite.

Conditionally enable or disable:

Document associated bugs:

Set a time limit:

Swift 6.2 allows evaluating conditions outside tests:

Tags allow categorizing and filtering tests.

Define your tags in an extension:

In the Test Navigator (⌘-6), click the tag icon to see your tests organized by tags rather than by file.

Use struct initialization for setup:

Each test receives a fresh instance of the suite, thus a clean database.

For logging or debugging:

Customize type display in reports:

For callback-based APIs:

Verify a callback is called a precise number of times:

Mark a test as having a known bug without disabling it:

The test runs, the failure is recorded but doesn't fail the suite.

Test Scoping Traits allow running before/after code without mutable global state.

Benefits:

Exit Tests allow verifying that code terminates the process (crash, precondition, fatalError).

Before Swift 6.2, testing a crash was nearly impossible. You had to create a separate CLI and use external tools. Now:

The code in the block runs in a separate process. Swift Testing verifies the process exit code.

Attachments allow attaching files to test results to facilitate diagnosis.

Attachments appear in Xcode and CI reports, greatly facilitating failure diagnosis.

Don't migrate everything at once. Recommended approach:

Before (XCTest):

After (Swift Testing):

Some features remain XCTest-exclusive:

Swift Testing works natively with Xcode Cloud. No special configuration required.

Swift Testing supports multiple report formats:

Xcode 26 introduces automatic detection of runtime issues in tests:

These issues appear as warnings or errors depending on your configuration.

Use descriptive English names:

Prefer multiple focused tests to one large test:

Each test must be independent:

Parallelize as much as possible (it's the default). For tests that can't be parallelized:

Swift Testing represents the future of testing on Apple platforms. Its progressive adoption, coexistence with XCTest, and rapid evolutions make it an obvious choice for any new Swift project.