0Pricing
Swift Academy · Lezione

Test e debug delle macro

Scrivere unit test per le espansioni delle macro usando assertMacroExpansion.

Test e debug delle macro è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Perché testare le macro?

Le macro generano codice al momento della compilazione. Gli unit test verificano il codice sorgente generato prima che raggiunga la produzione.

// The swift-syntax package ships SwiftSyntaxMacrosTestSupport
// with assertMacroExpansion for testing macro output

assertMacroExpansion

assertMacroExpansion riceve il codice sorgente di input e quello espanso previsto e verifica che coincidano.

import SwiftSyntaxMacrosTestSupport
import XCTest

final class StringifyMacroTests: XCTestCase {
  func testStringify() throws {
    assertMacroExpansion(
      "#stringify(1 + 2)",
      expandedSource: "(1 + 2, \"1 + 2\")",
      macros: ["stringify": StringifyMacro.self]
    )
  }
}

Testare le macro attached

Fornisca la struct o class decorata come input e il codice sorgente completamente espanso come output previsto.

assertMacroExpansion(
  "@AddID struct User { var name: String }",
  expandedSource: """
  struct User {
    var name: String
    var id = UUID()
  }
  """,
  macros: ["AddID": AddIDMacro.self]
)

Testare l'emissione della diagnostica

Verifichi che la macro emetta la diagnostica corretta, ovvero un avviso o un errore, quando viene usata in modo errato.

assertMacroExpansion(
  "@AddID class Foo {}",
  expandedSource: "class Foo {}",
  diagnostics: [
    DiagnosticSpec(message: "@AddID can only be applied to structs", line: 1, column: 1)
  ],
  macros: ["AddID": AddIDMacro.self]
)

Espandere le macro in Xcode

In Xcode, faccia clic con il pulsante destro del mouse su una chiamata di macro e selezioni Expand Macro per analizzare il codice generato direttamente nel file.

// Before expansion:
let (v, s) = #stringify(1 + 2)
// After:
let (v, s) = (1 + 2, "1 + 2")

Debug con print nelle macro

Usi context.diagnose o print su stderr per eseguire il debug della logica della macro durante lo sviluppo.

// In macro implementation:
print("[StringifyMacro] expanding: \(node.description)", to: &standardError)

Breakpoint nei test delle macro

Poiché le macro vengono eseguite nello stesso processo durante i test, può impostare breakpoint di Xcode nelle implementazioni delle macro durante le esecuzioni di test.

// Set a breakpoint in StringifyMacro.expansion()
// Run the test target — breakpoints are hit

Ispezione dell'albero di sintassi

Usi .debugDescription di SwiftSyntax per stampare l'intero albero di sintassi di un nodo di input durante il debug.

print(node.debugDescription)
// Prints the full SyntaxTree hierarchy

Testare più varianti degli argomenti

Scriva un test per ogni forma distinta degli argomenti, così da assicurarsi che tutti i percorsi del codice della macro vengano esercitati.

func testNoArgument() {
  assertMacroExpansion(
    "#stringify()",
    expandedSource: "#stringify()",
    diagnostics: [DiagnosticSpec(message: "Need an argument", line: 1, column: 1)],
    macros: ["stringify": StringifyMacro.self]
  )
}

Test di integrazione

Aggiunga un target app di test che usi effettivamente la macro. Confermi la compilazione e il comportamento a runtime.

// In test app:
let (val, src) = #stringify(Date.now)
XCTAssertEqual(src, "Date.now")

CI per i test delle macro

Esegua i test delle macro in CI come per qualsiasi altro pacchetto Swift: esegua swift test nella directory del pacchetto.

// CI command:
swift test --package-path MyMacros

Verifica rapida

Quale funzione verifica che una macro venga espansa nel codice sorgente previsto in un unit test?

Riepilogo della lezione

Testi le macro con assertMacroExpansion per verificare l'output corretto e con DiagnosticSpec per i casi di errore. Esegua il debug con l'anteprima dell'espansione in Xcode e con breakpoint nello stesso processo durante i test. Esegua swift test in CI.

Domande Frequenti

La lezione «Test e debug delle macro» è gratuita?

Sì — il testo completo di «Test e debug delle macro» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Test e debug delle macro»?

Scrivere unit test per le espansioni delle macro usando assertMacroExpansion. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Test e debug delle macro»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Ruoli delle macro: freestanding e attached
  2. Scrivere una macro di espressione freestanding
  3. Macro attached member per ridurre il boilerplate
  4. Test e debug delle macro
← Torna a Swift Academy