0Pricing
Swift Academy · Aula

Testes assíncronos e medição de desempenho

Teste funções assíncronas com async/await e faça medições com XCTMeasureOptions.

Testes assíncronos e medição de desempenho é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Testando funções assíncronas

Declare os métodos de teste como async throws para usar await diretamente nos corpos dos testes, sem código adicional desnecessário.

final class FetcherTests: XCTestCase {
  func testFetchReturnsUser() async throws {
    let user = try await UserService().fetchUser(id: 1)
    XCTAssertEqual(user.name, "Alice")
  }
}

setUp e tearDown assíncronos

Substitua setUp() async throws para realizar a inicialização assíncrona antes de cada teste.

override func setUp() async throws {
  try await super.setUp()
  sut = await AsyncService.make()
}

XCTestExpectation para APIs de retorno de chamada

Para APIs que usam retornos de chamada em vez de async/await, use XCTestExpectation e wait(for:timeout:).

func testCallback() {
  let exp = expectation(description: "data received")
  service.fetchWithCallback { data in
    XCTAssertNotNil(data)
    exp.fulfill()
  }
  wait(for: [exp], timeout: 5.0)
}

Invertendo expectativas

Uma expectativa invertida falha se IS cumprida — útil para verificar que um retorno de chamada NOT (não) é chamado.

let noCall = expectation(description: "should not fire")
noCall.isInverted = true
cancelledTask.onComplete { noCall.fulfill() }
wait(for: [noCall], timeout: 1.0)

XCTMeasure para medir desempenho

measure {} executa seu bloco 10 vezes e informa o tempo médio, o desvio padrão e a comparação com a referência.

func testSortPerformance() {
  let data = Array(0..<10_000).shuffled()
  measure {
    _ = data.sorted()
  }
}

XCTMeasureOptions

Configure o número de iterações e a métrica a ser medida (tempo, memória ou CPU).

func testParsePerformance() {
  let options = XCTMeasureOptions()
  options.iterationCount = 5
  measure(options: options) {
    _ = try? JSONDecoder().decode([Item].self, from: largeJSON)
  }
}

Medição de desempenho assíncrono

Use measure(metrics:options:block:) com um bloco assíncrono para medir operações assíncronas.

func testAsyncFetchPerformance() {
  measure {
    let exp = expectation(description: "done")
    Task {
      _ = try? await service.fetchAll()
      exp.fulfill()
    }
    wait(for: [exp], timeout: 10)
  }
}

Referências de desempenho

Depois de executar um teste de medição, defina uma referência no Xcode. As execuções futuras falharão se o desempenho regredir além do limite.

// Xcode: click the grey icon next to the measure test
// → "Set Baseline" to record the current average
// Subsequent runs compare against the baseline

Testando código isolado por ator

Acesse o estado isolado por ator nos testes usando await.

actor Counter { var value = 0; func increment() { value += 1 } }
final class CounterTests: XCTestCase {
  func testIncrement() async {
    let counter = Counter()
    await counter.increment()
    let val = await counter.value
    XCTAssertEqual(val, 1)
  }
}

Estrutura Swift Testing (Swift 6)

O Swift 6 inclui uma nova estrutura Testing com @Test, #expect e @Suite como alternativa moderna ao XCTest.

import Testing

@Suite struct MathTests {
  @Test func addition() {
    #expect(2 + 2 == 4)
  }
}

Combinando XCTest e Swift Testing

As duas estruturas podem coexistir no mesmo destino de testes durante a migração do XCTest para o Swift Testing.

import XCTest
import Testing
// Legacy XCTestCase tests alongside @Test functions
// Both run when the test target is executed

Verificação rápida

Qual API do XCTest mede o desempenho de um bloco de código e o compara com uma referência armazenada?

Recapitulação da lição

Marque os métodos de teste como async throws para usar await diretamente. Use XCTestExpectation para APIs de retorno de chamada. Faça medições com measure {} e defina valores de referência para detectar regressões. Teste atores com await. Explore a estrutura de testes do Swift com @Test e #expect para criar testes modernos.

Perguntas Frequentes

A aula “Testes assíncronos e medição de desempenho” é grátis?

Sim — o texto completo de “Testes assíncronos e medição de desempenho” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Testes assíncronos e medição de desempenho”?

Teste funções assíncronas com async/await e faça medições com XCTMeasureOptions. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Testes assíncronos e medição de desempenho”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configuração, desmontagem e métodos de teste do XCTestCase
  2. Família XCTAssert e asserções que lançam erros
  3. Mocking baseado em protocolos e injeção de dependências
  4. Testes assíncronos e medição de desempenho
← Voltar para Swift Academy