Test di unità SCL per PLC TIA Portal
In questa pagina
Un test di unità in TIA Portal verifica un singolo blocco PLC (FB/FC) in isolamento: scrivi ingressi definiti (Arrange), lascia che il controllore esegua alcuni cicli (Act) e confronta le uscite con i valori attesi (Assert), su PLCSIM Advanced o su un PLC S7 reale, in modo automatico e ripetibile.
Framework di test di unità integrato per i blocchi TIA. Scrivi, esegui e valuta i test su un'istanza live di PLCSIM Advanced senza uscire dall'app.
Requisiti:
- Licenza Pro+ o superiore
- PLCSIM Advanced V3.0+ installato (licenza Siemens separata)
- Un progetto TIA con almeno un PLC aperto
Aprire l'area di lavoro dei test di unità
- Fai clic sull'icona Unit test (becher) nella barra delle attività all'estrema sinistra
- La barra laterale mostra quindi la vista Esplora unit test, l'albero delle suite
.tia-teststrovate. La sua barra del titolo mostra Esegui tutte le suite di test / Arresta esecuzione test, Riesegui i test non riusciti, Mostra solo i falliti e Apri Test Bench; Nuova suite di test, Aggiorna suite di test, Scegli cartella dei test, Cancella cartella dei test, Genera pipeline CI ed Esporta report di test si trovano nel menu … della barra del titolo. Ogni riga di suite e di caso ha un'azione Esegui in linea al passaggio del mouse. I risultati delle tue esecuzioni di test compaiono nella scheda Esecuzione del Test Bench (vedi Il Test Bench più sotto). - Facendo clic su una suite nell'albero la apri come Editor suite di test nell'area dell'editor; facendo clic su un caso di test apri la sua suite con quel caso già selezionato. L'editor mostra la stessa suite in tre viste alternabili, Visivo, JSON e SCL, scelte con il selettore a destra della sua intestazione; la vista attiva è evidenziata nel colore del tuo tema. L'intestazione contiene anche il blocco, il PLC e il tipo di connessione della suite, Convalida, Esegui (la freccia accanto apre le opzioni di esecuzione, vedi Opzioni di esecuzione più sotto), Salva e un menu … con Genera dai valori limite, Importa in TIA (vista SCL), Apri come testo JSON, Impostazioni di connessione e le azioni di contratto e snapshot.
- La vista Visivo è un editor in due parti: la parte superiore elenca ogni caso di test su una riga (stato, numero, nome, descrizione, ingressi, asserzioni, requisiti, cicli, priorità, tag e ultimo risultato); la parte inferiore modifica il caso selezionato. Sopra l'elenco, una casella di filtro restringe i casi in base a qualsiasi testo, e i menu a discesa Stato, Priorità e Requisito filtrano ulteriormente; accanto, Aggiungi (caso di test, caso teoria o casi generati dai valori limite), Duplica, Sposta su, Sposta giù e Rimuovi agiscono sulle righe selezionate. Trascina il divisore tra elenco ed editor per dare più spazio a una delle due parti, oppure comprimi l'editor del caso con la freccia a destra della sua prima riga (anche
Ctrl+Shift+J); entrambe le parti scorrono in modo indipendente. - L'editor del caso inizia con nome, cicli, timeout e priorità, seguiti dalla descrizione e dalle sezioni Input, Asserzioni, Passi, Controllo e Metadati (più Parametri per un caso teoria). Ogni sezione aggiunge righe con l'icona + nella sua intestazione, ogni riga mostra il tipo di dati della sua variabile accanto al nome e ogni riga ha la sua icona di rimozione a destra. Passi e Controllo restano chiuse finché sono vuote, e Metadati mostra i suoi valori nell'intestazione finché non la apri. Il menu a discesa degli operatori di un'asserzione è raggruppato (Confronto, Intervallo, Booleano, Testo, Bit, Aggregato, Snapshot); Array uguale e Uguaglianza profonda modificano il valore atteso in una piccola finestra JSON, e un'asserzione Snapshot offre una finestra Esclusioni per le variabili da escludere dalla baseline.
- Tastiera: nell'elenco dei casi,
Ctrl+Shift+Naggiunge un caso,Ctrl+Dduplica,Alt+Up/Alt+Downspostano,Deleterimuove (con una conferma quando il caso ha asserzioni),Ctrl+Enteresegue i casi selezionati (l'intera suite quando nessuno è selezionato),EnteroF2passa al campo del nome eEscapetorna all'elenco;Ctrl+1,Ctrl+2eCtrl+3passano tra Visivo, JSON e SCL.
Il Test Bench
Il Test Bench è l'area di lavoro in cui scegli un blocco, ne osservi l'interfaccia, esegui i suoi test e leggi i risultati. Aprilo in uno di questi modi:
- Riquadro comandi: Unit test: Apri Test Bench
- Apri Test Bench nella barra del titolo della vista Esplora unit test; la suite selezionata nell'albero è già scelta
- Fai clic sulla voce Unit test nella barra di stato dopo un'esecuzione; il Test Bench si apre sulla scheda Esecuzione
Intestazione. Da sinistra a destra:
| Elemento | Cosa fa |
|---|---|
| PLC | Scegli il PLC. Il menu offre anche Aggiorna elenco PLC mentre sei connesso a TIA Portal. |
| Blocco | Scegli il blocco da testare; mostra l'icona Siemens del tipo di blocco. Con la connessione a TIA Portal, l'elenco mostra i blocchi del tuo progetto; senza connessione mostra i blocchi usati dalle tue suite di test. |
| Suite | Scegli una suite di test; il numero tra parentesi è il suo numero di casi di test. Con un blocco scelto, l'elenco mostra le suite di quel blocco. Senza blocco, mostra le suite del PLC scelto o dell'intera cartella dei test, raggruppate per PLC e blocco, e scegliendo una suite il PLC e il blocco vengono impostati per te. Quando il blocco ha esattamente una suite, viene scelta per te. Quando apri o esegui una suite, per esempio dalla vista Esplora unit test, un Test Bench aperto passa a quella suite. |
| + (Nuova suite per questo blocco) | Crea una suite di test per il blocco scelto senza chiedere nulla e la apre nell'Editor suite di test accanto al Test Bench. La suite inizia con un caso di test vuoto, così aggiungi gli ingressi e le asserzioni che ti servono. |
| Connessione | Grigio Non connesso, blu Cartella di origine quando lavori offline da una cartella di blocchi esportati, oppure verde con la versione di TIA Portal e il nome del progetto connesso. Fai clic per Connetti a TIA Portal o Disconnetti da TIA Portal, Scegli cartella di origine… (oppure Cambia cartella di origine… e Rimuovi cartella di origine) e Apri dashboard PLCSIM. |
| Esegui | Esegue la suite scelta nell'intestazione. La freccia accanto apre le opzioni di esecuzione: tutte le suite, la suite o i suoi casi non riusciti, con copertura, test di mutazione o verifica del contratto, e le opzioni per i casi instabili e le baseline degli snapshot (vedi Opzioni di esecuzione più sotto). Arresta compare mentre un'esecuzione è in corso. |
| … | Apri la suite nell'editor, Impostazioni di connessione, Apri XML del blocco, Mostra mappa di copertura, Mostra i marcatori di mutazione, Esporta report di test… e Genera pipeline CI (apre la pagina Pipeline CI, vedi Generare una pipeline CI/CD dall'app). |
Una barra sottile sotto l'intestazione mostra l'avanzamento di un'esecuzione.
Test Bench stretto. Quando il Test Bench è stretto, l'intestazione sposta i suoi chip e pulsanti su altre righe invece di sovrapporli, e un nome lungo di PLC, blocco o suite termina con puntini di sospensione; passa il puntatore sopra per leggere il nome completo. Anche le schede di entrambe le colonne passano su una seconda riga quando una colonna è stretta, così ogni scheda resta raggiungibile, e allargando una colonna con il divisore vengono subito ridisposte.
Colonna del blocco (sinistra). Un riquadro mostra nome, tipo e linguaggio del blocco e da dove viene letto (TIA Portal, la tua cartella di origine o i file esportati del progetto). Sotto si trovano le schede Interfaccia, Limiti, Dipendenze e Spazio di indirizzamento. Non appena scegli un blocco, Interfaccia e Limiti si compilano da sole, anche senza TIA Portal quando è impostata una cartella di origine. Mentre un blocco viene letto, una barra di avanzamento scorre in cima al Test Bench e le schede indicano il passo corrente, per esempio "Caricamento dell'interfaccia di 'FB_Motor'…"; quando i valori limite non possono essere determinati, l'interfaccia resta visibile e Limiti mostra il motivo. Le Dipendenze richiedono più tempo e vengono lette solo quando fai clic su Analizza dipendenze nell'intestazione della colonna del blocco; Aggiorna analisi accanto rilegge il blocco.
Colonna dei risultati (destra). Le schede Esecuzione, Cronologia, Qualità e Tracciabilità, descritte nelle sezioni seguenti. Cronologia elenca le tue esecuzioni passate, confronta anche due esecuzioni e mostra gli andamenti; Qualità mostra i risultati di copertura e del test di mutazione; Tracciabilità mostra quali casi di test coprono ogni requisito e i loro ultimi risultati.
Prima di un'esecuzione. Il Test Bench esegue la suite salvata. Quando la suite è aperta nell'Editor suite di test con modifiche non salvate, Studio chiede se salvarla prima (Salva ed esegui). Quando l'editor mostra problemi che impediscono il salvataggio, l'esecuzione non parte e un messaggio indica la suite. Lo stesso vale per ogni esecuzione dall'Editor suite di test e per copertura, test di mutazione e verifiche del contratto.
Tastiera. Con il focus sul Test Bench, Ctrl+; seguito da S esegue la suite scelta nell'intestazione, e Ctrl+; seguito da Q arresta un test in esecuzione.
Dopo un riavvio. Il Test Bench si riapre con lo stesso PLC, blocco, suite e schede, e mostra l'esecuzione che mostrava prima.
Cambio di scheda. Quando passi dal Test Bench a una scheda di suite e viceversa, entrambi restano come erano: il blocco, i risultati dell'esecuzione e la suite non vengono ricaricati.
Esplora test
Esplora test mostra le suite di test del progetto TIA a cui sei connesso: ogni file di suite in .tia-tests compare come nodo di suite con i suoi casi di test come figli, ordinati nelle cartelle che hai creato (vedi Organizzare le suite di test in cartelle). Finché non è scelta alcuna cartella dei test e nessun progetto è connesso, la vista mostra "Connetti un progetto TIA o scegli una cartella dei test per caricare le tue suite di test."; quando una cartella è scelta, le sue suite compaiono automaticamente (una cartella scelta senza suite mostra "Ancora nessuna suite di test."; se la cartella scelta non esiste più, mostra "Cartella dei test selezionata non trovata: <percorso>").
Icone di stato (mostrate di nuovo dopo un riavvio):
- Superato: segno di spunta verde, test superato nell'ultima esecuzione
- Non riuscito: croce rossa, test non riuscito nell'ultima esecuzione
- Errore: avviso arancione, test terminato con un errore (eccezione, timeout, errore S7)
- Saltato: cerchio grigio barrato, test escluso dall'ultima esecuzione
- Non eseguito: cerchio grigio vuoto, nessun risultato salvato finora
Interazioni:
| Azione | Risultato |
|---|---|
| Fai clic su una suite (oppure selezionala e premi Invio) | Apre la suite come Editor suite di test nell'area dell'editor |
| Fai clic su un caso di test | Apre la sua suite nell'Editor suite di test con quel caso selezionato |
| Passa il puntatore su una suite, poi fai clic su Esegui suite nella sua riga | Esegue solo questa suite |
| Passa il puntatore su un caso di test, poi fai clic su Esegui singolo nella sua riga | Esegue solo questo caso di test |
| Esegui tutte le suite di test (barra del titolo della vista) | Esegue in sequenza tutte le suite visibili |
| Arresta esecuzione test (barra del titolo della vista, mentre un'esecuzione di test è in corso) | Annulla l'esecuzione corrente al successivo punto sicuro |
| Nuova suite di test / Aggiorna suite di test (menu … della barra del titolo) | Crea una nuova suite, oppure riesamina la cartella .tia-tests/ |
| Scegli cartella dei test / Cancella cartella dei test (menu … della barra del titolo) | Scegli in quale cartella si trovano le tue suite di test (quando è scelta una cartella l'elenco la segue, altrimenti il progetto connesso), oppure cancella di nuovo la selezione |
Una casella di filtro in cima alla vista Esplora unit test restringe l'albero per nome di suite e di caso, un interruttore Mostra solo i falliti nella barra del titolo nasconde tutto ciò che non è fallito, e un'azione Esegui singolo per caso esegue un solo caso.
Previsto per l'area di lavoro nell'app. È prevista un'azione Esegui solo le suite interessate (riesegue solo le suite il cui blocco sottostante è cambiato). Oggi sono disponibili, come sopra, le esecuzioni di una singola suite, di un singolo caso e di tutte le suite; dalla riga di comando,
tia-test-runner run --rerun-affectedesegue già solo le suite il cui blocco sottostante è cambiato (vedi Integrazione CI/CD).
Previsto: badge di modifica del blocco. Per la vista Esplora unit test è previsto un piccolo punto arancione accanto a una suite il cui blocco PLC sottostante è cambiato dall'ultima esecuzione, con il tooltip "Blocco modificato dall'ultima esecuzione".
Un caso di test che è risultato instabile nelle sue esecuzioni recenti (a volte superato, a volte fallito) porta un badge Instabile accanto al nome, con un tooltip che mostra quante volte è cambiato il suo risultato. Viene calcolato dalla cronologia delle esecuzioni, quindi compare quando un caso è stato sia superato sia fallito in esecuzioni recenti. Il badge scompare da solo quando il caso torna a un risultato stabile, così un test che hai corretto smette di essere segnalato dopo alcune esecuzioni coerenti, e un caso che ora fallisce ogni volta viene mostrato come un vero errore anziché come instabile.
Organizzare le suite di test in cartelle
Ordina le tue suite di test in cartelle, come i file nelle cartelle di un esplora file. Le cartelle sono elencate sopra le suite, mostrano un'icona di cartella e il numero di suite contenute, e si aprono e chiudono con un clic sulla freccia.
| Azione | Risultato |
|---|---|
| Nuova cartella (menu … della barra del titolo, oppure clic destro su una cartella) | Crea una cartella nella cartella selezionata, o nella cartella della suite selezionata. Se non è selezionato nulla, la cartella viene creata al livello superiore |
| Trascina una suite o una cartella su una cartella | La sposta in quella cartella. Rilasciala su un'area vuota della vista per riportarla al livello superiore |
| Sposta nella cartella... (clic destro su una suite o una cartella) | Sceglie la cartella di destinazione da un elenco, senza trascinare |
| Rinomina (clic destro su una cartella, oppure premi F2) | Rinomina la cartella |
| Elimina (clic destro su una cartella, oppure premi il tasto Canc) | Elimina la cartella insieme alle suite che contiene, dopo una conferma che indica quante suite vengono eliminate con essa |
| Nuova suite di test (clic destro su una cartella, oppure con una cartella selezionata) | Crea la nuova suite in quella cartella |
- Il nome di una suite deve essere univoco in tutte le cartelle. Studio rifiuta una seconda suite con lo stesso nome, anche in un'altra cartella.
- La cronologia delle esecuzioni, il badge Instabile e le esecuzioni approvate restano con una suite quando la sposti in un'altra cartella o rinomini la cartella.
- Le suite aperte si spostano con loro: un Editor suite di test aperto di una suite che sposti si riapre nella nuova posizione. Se la suite ha modifiche non salvate, Studio chiede prima.
- Spostare, rinominare ed eliminare non è possibile mentre è in corso un'esecuzione di test.
- Alcuni nomi di cartella sono riservati ai file che Studio scrive nella cartella dei test (per esempio
reports), e i nomi che iniziano con un punto o con due trattini bassi non sono ammessi. Studio ti avvisa quando un nome non può essere usato. - Le cartelle sono normali cartelle all'interno di
.tia-tests, quindi il controllo di versione le rileva, e anche una cartella che crei in Esplora risorse di Windows compare nella vista. - L'assistente IA può creare, rinominare ed eliminare cartelle e spostare suite per te, e può creare una nuova suite direttamente in una cartella che indichi.
Metadati del caso di test
L'editor del caso della vista Visivo termina con una sezione Metadati (chiusa per impostazione predefinita, sotto Controllo; la sua intestazione mostra i valori correnti). Fai clic sull'intestazione della sezione per aprirla e modificare i seguenti campi per ogni caso; la priorità è modificabile anche nella prima riga dell'editor del caso, e requisiti, priorità e tag compaiono come colonne dell'elenco dei casi:
| Campo | Scopo |
|---|---|
| Ordine | Ordine di esecuzione numerico. Lascialo vuoto per mantenere l'ordine naturale nella suite |
| Tag | Etichette (es. safety, regression) usate per i filtri nei report HTML, inserite come chip (vedi sotto) |
| Priorità | Uno tra Low / Normal / High / Critical. Determina l'ordinamento nei report |
| Responsabile | Responsabile in testo libero (nome del team, e-mail, ecc.) |
| Requisiti | ID dei requisiti (es. REQ-123, REQ-456) per la tracciabilità, inseriti come chip con suggerimenti dalla tua cartella dei test (vedi sotto) |
Dopo Convalida, ogni problema compare in una striscia sotto l'intestazione dell'editor come N problemi; aprila e fai clic su un problema per passare al caso e alla sezione interessati. Un caso con problemi porta anche un segno di avviso nella colonna di stato dell'elenco dei casi, e Salva ed Esegui restano disattivati finché gli errori bloccanti non sono corretti. Tutte le modifiche vengono salvate automaticamente con il resto della suite. Le suite create prima di questa versione si caricano con metadati predefiniti vuoti; non è necessaria alcuna migrazione.
ID dei requisiti e tag
Tag e Requisiti mostrano ogni voce come chip. Digita nella casella dopo i chip e premi Invio o una virgola per aggiungere una voce. Incolla un elenco separato da virgole o a capo per aggiungere un chip per voce. Per rimuovere un chip, fai clic sulla sua x. Da tastiera, Backspace nella casella vuota passa all'ultimo chip, i tasti freccia si spostano tra i chip, e Backspace o Elimina rimuove il chip che ha il focus.
Mentre digiti un ID di requisito, un elenco suggerisce gli ID che le suite di test salvate della tua cartella dei test usano già, ciascuno con il numero di casi di test e le suite che lo indicano, più gli ID che hai aggiunto a questa suite ma non hai ancora salvato. Così un requisito resta scritto allo stesso modo in ogni suite. I suggerimenti non includono le modifiche non salvate in altre suite aperte.
Un ID di requisito viene rifiutato, con il motivo sotto la casella, quando è vuoto, contiene caratteri di controllo o di formattazione invisibili, è più lungo di 256 caratteri, quando il caso di test indicherebbe più di 50 ID, oppure quando il caso lo indica già. Una suite che contiene già un ID del genere si apre comunque: il problema compare nella striscia dei problemi, e Salva ed Esegui restano disattivati finché non lo correggi.
Quando due ID differiscono solo per maiuscole e minuscole, spaziatura o tipo di trattino (per esempio REQ-1 e req-1), compare un avviso sotto i chip e nella striscia dei problemi. Se l'altra grafia è usata altrove nella tua cartella dei test, Usa REQ-1 sostituisce il tuo chip con quella. Studio non unisce mai i due da solo: copertura e report li contano come requisiti diversi finché non scegli una grafia.
I tag vengono suggeriti dalla suite corrente. Un tag più lungo di 64 caratteri, o più di 50 tag su un caso di test, mostra una nota, perché i report li abbreviano.
Il menu a discesa Requisito del filtro sopra l'elenco dei casi mostra gli ID di questa suite con il numero di casi di test per ciascuno, poi, sotto Altre suite nella cartella, gli ID usati solo da altre suite. Scegliendone uno compare "Nessun caso di questa suite copre ..." con Cancella filtro.
Nella chat IA puoi chiedere "quali ID di requisito esistono nella mia cartella dei test?"; l'assistente li elenca, e quando aggiunge requisiti ai casi di test segue le stesse regole e segnala le varianti di grafia.
Avanzamento live durante un'esecuzione
Mentre un test è in esecuzione, puoi seguirlo in diversi punti:
- Barra di stato: la voce Unit test mostra l'avanzamento, per esempio "Test 4/36". Al termine dell'esecuzione mostra il risultato, per esempio "36 superati" o "35 superati, 1 non riuscito". Passa il mouse sopra per il dettaglio completo, fai clic per aprire la scheda Esecuzione del Test Bench.
- Test Bench: una sottile barra di avanzamento scorre sotto l'intestazione, e la scheda Esecuzione si riempie man mano che ogni caso di test termina. La prima esecuzione dopo l'avvio di Studio apre il Test Bench sulla scheda Esecuzione; quando hai avviato l'esecuzione dall'Editor suite di test, il Test Bench si apre come scheda in background, così il tuo editor resta in primo piano.
- Vista Esplora unit test: le icone di stato si aggiornano live per ogni caso di test. La beuta di una suite in esecuzione si riempie man mano che i suoi casi di test terminano, così vedi l'avanzamento senza espandere la suite; passa il puntatore sulla beuta per vedere quanti casi sono completati. Mentre una suite o un caso di test è in esecuzione, il suo pulsante Esegui diventa Arresta esecuzione test, così puoi arrestare l'esecuzione di test dalla stessa riga.
- Arresta esecuzione test: annulla l'esecuzione di test corrente al successivo punto sicuro (la connessione S7 e l'istanza PLCSIM vengono sempre ripulite). Funziona anche mentre un'esecuzione di copertura o di mutazione è ancora in preparazione, per esempio mentre Studio chiede una password; l'esecuzione termina allora senza messaggio di errore. Se PLCSIM Advanced non risponde entro 30 secondi mentre Studio verifica la destinazione di tale esecuzione, l'esecuzione termina con un messaggio che lo indica.
- Una nuova esecuzione dopo l'arresto: quando arresti un'esecuzione di copertura o di mutazione, Studio rimuove prima le sue copie di test e, per una suite che usa S7 Native o OPC UA, ricarica il tuo progetto nell'istanza PLCSIM Advanced. Un'esecuzione che avvii nel frattempo attende finché non è finito, così le due non usano mai il progetto o l'istanza nello stesso momento.
Leggere i risultati nella scheda Esecuzione
La scheda Esecuzione del Test Bench mostra l'ultima esecuzione, ovunque tu l'abbia avviata (Test Bench, vista Esplora unit test, Editor suite di test, il CodeLens sopra un blocco o l'assistente IA). Con Eseguire tutti vengono mostrate insieme tutte le suite dell'esecuzione.
- Riga di intestazione: il nome della suite (oppure, per esempio, "Esegui tutti, 7 suite"), ora di inizio, durata, PLC, versione di TIA Portal, tipo di connessione e nome del computer. L'elenco a destra passa tra le esecuzioni di questa sessione; un'esecuzione aperta dalla cronologia è contrassegnata con "(cronologia)".
- Contatori: totale, superati, non riusciti, errori e saltati (con il numero di casi instabili messi da parte); un contatore a zero è mostrato senza colore. Accanto: Riesegui ripete la stessa esecuzione, Riesegui i test non riusciti ripete solo i suoi casi non riusciti, Esporta report… apre il modulo di esportazione per questa esecuzione (vedi Esportare un report), e Confronta con… ti porta alla scheda Cronologia per scegliere l'esecuzione con cui confrontarla.
- Filtri: Solo non riusciti, gli elenchi Suite, Blocco, Tag e Requisito, e una casella di testo che cerca in caso, suite, blocco e messaggio.
- Elenco dei casi: stato, nome del caso (con i contrassegni Instabile e Quarantena), la suite (quando l'esecuzione ha coperto più suite), durata e messaggio. Fai doppio clic su un caso per aprirlo nell'Editor suite di test. Le larghezze delle colonne che imposti vengono ricordate.
- Asserzioni: ogni asserzione del caso selezionato con Variabile, Operatore, Atteso, Effettivo e Stato. Quando uno snapshot non corrisponde più alla sua baseline, Approva baseline su quella riga accetta il nuovo risultato, e Approva baseline (N) sopra la griglia le accetta tutte dopo una conferma. Entrambi funzionano sull'esecuzione più recente della sessione.
- Timeline: un grafico di come ogni variabile di controllo è cambiata ciclo per ciclo, aggiornato live durante l'esecuzione. Ogni variabile ha la sua corsia, impilata una sotto l'altra, così le variabili con lo stesso valore non si coprono mai: un Bool passa tra FALSE e TRUE, un valore numerico, di tempo o di data è scalato sul proprio intervallo. L'indice a sinistra indica ogni corsia con il suo colore, tipo di dati e intervallo di valori registrato; i valori di tempo e data sono scritti come in TIA Portal, per esempio "T#0ms a T#500ms". Sposta il puntatore sul grafico per vedere il valore di ogni variabile in quel ciclo accanto al suo nome, e il numero di ciclo sotto l'indice. Con molte variabili di controllo, le corsie e l'indice scorrono insieme. Le variabili senza un tipo numerico, di tempo o Bool, come STRING, CHAR, DTL o DATEANDTIME, non ricevono una corsia e sono elencate sotto il grafico. Comprimi la sezione quando non ti serve. Una voce di controllo può anche indicare un membro di una struttura o un elemento di un array, per esempio
motorData.speedovalues[2]. Un membro di un timer, di un contatore o di un rilevamento di fronte, comeinstTimer.EToinstTimer.Q, riceve una propria corsia con il proprio tipo di dati. Un membro di un'altra istanza di blocco di sistema riceve una corsia quando i suoi valori registrati sono tutti TRUE o FALSE, tutti numeri o tutte durate, altrimenti è elencato sotto il grafico. Una voce che non è nell'interfaccia del blocco non viene registrata; i dettagli del caso nella scheda Esecuzione la elencano sotto "Variabili di controllo mancanti nell'interfaccia del blocco, non registrate nella timeline", e i report HTML e JUnit dell'esecuzione la indicano nell'output del caso di test. - Riga di approvazione: sotto la riga di intestazione, una volta memorizzata l'esecuzione, indica se l'esecuzione è approvata, da chi e quando, con Approva… o Revoca… (vedi Approvare un'esecuzione di test). Per un Esegui tutti riporta, per esempio, "3 di 7 esecuzioni approvate".
- Suite eliminate: quando una suite dell'esecuzione mostrata è stata eliminata, l'esecuzione resta visibile e l'intestazione dice "Suite eliminata. L'esecuzione resta nella cronologia."; l'elenco delle esecuzioni la contrassegna con "(suite eliminata)", e Riesegui i test non riusciti esclude le suite eliminate.
Esecuzioni dalla cronologia. Un'esecuzione aperta dalla scheda Cronologia mostra i valori letti durante quell'esecuzione. I valori attesi provengono dalla suite com'è ora, cosa che l'intestazione segnala con "Valori attesi dalla suite corrente". I valori che le esecuzioni più vecchie non hanno potuto memorizzare in forma leggibile compaiono come "non registrato".
Per raccogliere dati di controllo, aggiungi un array "watch": ["Var1", "Var2"] a un caso di test nel JSON della suite e imposta "cycles" a un valore maggiore di 1. Il campionamento è limitato a 100.000 cicli per caso di test. Gli stessi dati vengono anche rappresentati come grafico a serie temporali nei report HTML prodotti dallo strumento a riga di comando tia-test-runner (vedi Integrazione CI/CD).
I risultati dei test vengono memorizzati sul tuo computer: sopravvivono ai riavvii dell'app e ricompaiono automaticamente nella vista Esplora unit test.
Cronologia
La scheda Cronologia del Test Bench elenca ogni esecuzione di test memorizzata, dalla più recente (fino alle ultime 200), qualunque sia la suite eseguita. Ha tre modalità, che cambi con Esecuzioni, Confronta e Andamento nella sua riga superiore. Lo strumento a riga di comando tia-test-runner produce le stesse informazioni come report HTML e CSV (vedi Integrazione CI/CD).
Esecuzioni
- Colonne: per impostazione predefinita Avviato, Durata, Risultato, Approvazione, Suite, Blocco, PLC, Host e TIA, dopo un punto di stato. Il punto mostra il risultato dell'esecuzione: Superato, Non riuscito (anche quando un solo caso di test non è riuscito o ha avuto un errore), Errore (l'esecuzione si è fermata prima, per esempio perché la connessione è stata persa) o Annullato; passa il puntatore sopra per leggere il risultato. Approvazione mostra se l'esecuzione è approvata (passa il mouse sopra per vedere da chi e quando). La colonna Risultato mostra piccoli contatori colorati: superati sempre, non riusciti, errori e saltati solo quando presenti. Quando dei fallimenti instabili sono stati messi da parte, il contatore dei saltati riporta per esempio "2 (1 instabile)" con un bordo tratteggiato.
- Scelta delle colonne: fai clic su Colonne nella riga superiore e seleziona le colonne che vuoi. Si possono aggiungere Totale, Superati, Falliti, Errori, Saltati, File della suite e ID esecuzione; Reimposta colonne ripristina i valori predefiniti. Almeno una colonna resta sempre visibile. La tua scelta e le larghezze delle colonne vengono ricordate, anche per le colonne che nascondi e mostri di nuovo.
- Suite eliminate: quando il file di suite di un'esecuzione non si trova più nella cartella dei test, la colonna Suite riporta il suo nome seguito da "(suite eliminata)", approvata o no. Le esecuzioni di un'altra cartella dei test mantengono il loro nome semplice.
- Casella di filtro: restringe l'elenco per suite, blocco, PLC o host.
- Aggiorna: l'icona di aggiornamento o
F5ricarica l'elenco; si ricarica anche da solo dopo ogni esecuzione. - Aprire un'esecuzione: fai doppio clic su una riga o premi
Enterper mostrare quell'esecuzione nella scheda Esecuzione. - Selezionare più esecuzioni: usa
Ctrl,ShiftoCtrl+Acome in qualsiasi elenco, per esempio per confrontare due esecuzioni, esportare più report insieme o eliminare più esecuzioni contemporaneamente.
Clic destro su un'esecuzione (oppure premi Shift+F10):
| Azione | Risultato |
|---|---|
| Apri risultati | Mostra l'esecuzione nella scheda Esecuzione |
| Confronta con… | Ti permette di scegliere l'esecuzione con cui confrontarla (vedi Confronta più sotto) |
| Esporta report… | Apre il modulo di esportazione per questa esecuzione, o per tutte le esecuzioni selezionate (vedi Esportare un report) |
| Approva… | Approva questa esecuzione, o le esecuzioni selezionate che possono essere approvate (vedi Approvare un'esecuzione di test) |
| Revoca approvazione… | Revoca l'approvazione di questa esecuzione indicando un motivo |
| Elimina esecuzione… | Rimuove definitivamente l'esecuzione dalla cronologia dopo una conferma. Con più righe selezionate, la voce riporta per esempio Elimina 3 esecuzioni… ed elimina tutte le esecuzioni selezionate dopo un'unica conferma che le nomina. Un'esecuzione approvata non può essere eliminata finché la sua approvazione non viene revocata; le esecuzioni approvate tra quelle selezionate restano nella cronologia, e un messaggio le indica. Se la scheda Esecuzione o un confronto mostravano un'esecuzione eliminata, vengono svuotati |
Delete fa lo stesso di Elimina esecuzione… per le righe selezionate. L'eliminazione delle esecuzioni non legge nulla da TIA Portal.
La cronologia delle esecuzioni non rivela il percorso della cartella del tuo progetto, e le esecuzioni dello stesso progetto vengono comunque abbinate tra computer diversi.
Confronta
Il confronto mostra cosa è cambiato tra due esecuzioni.
- Due esecuzioni selezionate: seleziona due righe e fai clic su Confronta. L'esecuzione più vecchia diventa il riferimento, quella più recente l'esecuzione corrente. Confronta resta non disponibile finché non sono selezionate due esecuzioni.
- Confronta con…: nella scheda Esecuzione o nel menu di riga di un'esecuzione. La scheda Cronologia si apre con quell'esecuzione selezionata e la riga "Scegli l'esecuzione con cui confrontare …". Fai clic, doppio clic o premi
Entersull'esecuzione che vuoi come riferimento, e il confronto si apre. Studio attende sempre l'esecuzione che scegli dopo, anche quando prima era aperto un altro confronto, e Annulla in quella riga torna all'elenco delle esecuzioni senza confronto.
Il confronto mostra:
- Riferimento e Attuale affiancati, ciascuno con la sua ora di inizio, i conteggi di superati e non riusciti e la durata, e Scambia per invertirli.
- Contatori di riepilogo: Regressioni, Corretti, Nuovi, Rimossi e Stabili.
- Filtro: Tutti, Regressioni, Corretti, Nuovi o Rimossi restringe l'elenco dei casi.
- Elenco dei casi: ogni caso con la sua modifica (per esempio Regressione, Corretto o Ancora non riuscito), il suo messaggio e la variazione di durata, con "N di M casi" sotto.
Andamento
L'andamento mostra come si evolve una suite nel tempo.
- Suite e Caso: l'elenco delle suite è costruito dalla cronologia delle tue esecuzioni, quindi è compilato anche se non hai mai aperto la vista Esplora unit test. Quando due PLC hanno una suite con lo stesso nome, il PLC è mostrato tra parentesi. L'elenco dei casi proviene dalla suite scelta.
- Intervallo di tempo: Ultimi 30 giorni, Ultimi 90 giorni, oppure le tue date Da e A.
- Grafico Tasso di superamento per il PLC della suite scelta, grafico Durata per la suite, e la mappa di calore Cronologia del caso per il caso scelto, una cella per esecuzione, colorata in base al risultato e contrassegnata con un simbolo. Passa il mouse su una cella per vedere quando è iniziata l'esecuzione.
- L'icona di aggiornamento nella riga superiore ricarica i grafici.
Quando si apre l'andamento, parte dalla suite dell'esecuzione selezionata, altrimenti dalla suite scelta nell'intestazione del Test Bench, altrimenti dalla suite dell'esecuzione più recente.
Condividi
Condividi a destra della riga superiore offre, a seconda della modalità:
| Modalità | Condividi offre |
|---|---|
| Esecuzioni | Esporta report… per le esecuzioni selezionate (o l'esecuzione più recente), ed Esporta CSV… con le righe e le colonne che vedi al momento, incluso chi ha approvato ogni esecuzione |
| Confronta | Esporta report… per il confronto |
| Andamento | Esporta CSV… con i punti dell'andamento |
I file CSV vengono scritti in modo che un programma di fogli di calcolo non esegua mai una cella come formula.
Esportare un report
Esporta report… apre un piccolo modulo accanto al pulsante su cui hai fatto clic. Lo raggiungi da Condividi nella scheda Cronologia, dal menu di riga di un'esecuzione, dall'icona di esportazione nella scheda Esecuzione, da Esporta report di test… nel menu … del Test Bench, e dal riquadro comandi con Unit test: Esporta report di test (che apre la scheda Cronologia con l'esecuzione più recente selezionata).
- Formati: Report HTML e XML JUnit. Un confronto viene esportato solo come HTML.
- Ambito: Questa esecuzione, Esecuzioni selezionate (con il numero di esecuzioni selezionate) o Confronto (disponibile dopo aver confrontato due esecuzioni). Un ambito che non corrisponde alla tua selezione è disattivato e ti spiega il motivo.
- Output: la Cartella di output, relativa alla cartella dei report del tuo progetto TIA (per impostazione predefinita
report). La cartella deve trovarsi all'interno di quella cartella dei report; altrimenti il campo dice "Scegli una cartella all'interno della cartella dei report del progetto." ed Esporta resta non disponibile. Quando esporti più esecuzioni, ogni esecuzione riceve la propria sottocartella con il nome della sua ora di inizio, così nessun report ne sovrascrive un altro. L'esportazione più recente finisce sempre al livello superiore della sua cartella: se la cartella contiene già il report di un'altra esecuzione, quel report precedente viene spostato nella propria sottocartella sottorunse resta verificabile lì, e riesportare la stessa esecuzione sostituisce semplicemente il suo report. Se un'esportazione non riesce, la cartella resta com'era. - Personalizzazione: apri questa sezione per impostare un Titolo, un Piè di pagina e un Colore principale (un colore esadecimale come
#2563eb).
Fai clic su Esporta (o Esporta 3 report e così via), oppure premi Ctrl+Enter; Escape chiude il modulo. Finché non sei connesso a un progetto TIA, Esporta non è disponibile e il modulo lo segnala, perché i report vengono scritti nel progetto. Il report HTML dell'esecuzione esportata più recente si apre in Studio come pagina non appena è pronto, e un messaggio indica la cartella in cui sono stati scritti i file e, quando un report precedente è stato spostato, dove è finito. Fai clic su Apri cartella in quel messaggio per vedere i file in Esplora file. Il modulo ricorda formati, cartella e personalizzazione per la prossima esportazione.
Qualità: copertura e mutazione
La scheda Qualità del Test Bench mostra quanto a fondo i test di una suite esercitano il loro blocco. Appartiene alla suite scelta nell'intestazione del Test Bench; senza una suite lì, mostra la suite della tua esecuzione più recente. Ha due sezioni, che puoi chiudere e aprire; Studio ricorda quali sono chiuse.
Copertura. La riga sotto il titolo indica l'esecuzione a cui appartiene, e se quell'esecuzione ha misurato la copertura riga per riga. Fino a cinque barre mostrano cosa hanno raggiunto i test: Requisito, Interfaccia, Blocchi chiamati, e dopo un'esecuzione con strumentazione di copertura anche Istruzione e Ramo. Ogni barra mostra gli elementi coperti sul totale e una percentuale, oppure n/d quando il blocco non ha nulla di quel tipo. Apri una barra per vedere cosa non è stato raggiunto; per istruzioni e rami, fai clic su una riga per aprire il blocco a quella riga. Le icone nel titolo della sezione sono Aggiorna, Esporta copertura… (scrive un file Cobertura nella cartella dei report del tuo progetto TIA; il messaggio indica la cartella, dice dove è stato spostato un report precedente al suo interno e offre Apri cartella) ed Esegui con strumentazione di copertura.
Mutazione. Mostra l'ultimo risultato del test di mutazione della suite (vedi Test di mutazione più sotto), anche quando hai eseguito la suite normalmente dopo l'esecuzione di mutazione. Le icone nel titolo della sezione sono Aggiorna, Attiva/disattiva i marcatori di mutazione (spuntato mentre i marcatori sono mostrati nell'editor, la stessa impostazione di Mostra i marcatori di mutazione nel menu … del Test Bench) ed Esegui test di mutazione.
Avviare un'esecuzione da qui. Esegui con strumentazione di copertura ed Esegui test di mutazione eseguono la suite della sezione. Come ogni esecuzione dal Test Bench, chiedono di salvare prima la suite quando ha modifiche non salvate. Sono disattivati, con il motivo, quando non sei connesso a TIA Portal; per una suite CODESYS, entrambi richiedono solo il progetto CODESYS aperto in Studio (vedi Testare blocchi CODESYS). Entrambi funzionano per le suite che usano PLCSIM Advanced, S7 Native o OPC UA; per S7 Native e OPC UA l'indirizzo deve appartenere a un'istanza PLCSIM Advanced su questo computer (vedi Esecuzione del test di mutazione più sotto). Durante e dopo un'esecuzione del genere, il Test Bench resta sulla scheda Qualità ed entrambe le sezioni si aggiornano al termine dell'esecuzione.
Test di mutazione
Il test di mutazione risponde a una domanda a cui la copertura non sa rispondere: i tuoi test rilevano davvero un errore? Apporta una serie di piccole modifiche a una copia del tuo blocco (ad esempio trasforma un > in un >=, sostituisce un AND con un OR o rimuove un'assegnazione di uscita), esegue la tua suite di test esistente su ogni copia modificata e segnala le modifiche che i tuoi test non hanno notato. Una modifica rilevata dalla suite è un mutante "ucciso"; una modifica passata inosservata con tutti i test ancora verdi è un mutante "sopravvissuto", e indica una lacuna nei tuoi test.
Il blocco originale non viene mai toccato. Ogni modifica avviene su una copia temporanea che Studio elimina dopo ogni esecuzione.
Eseguire il test di mutazione
- Seleziona una suite di test nella vista Esplora unit test.
Assicurati di essere connesso a TIA Portal e che la tua suite venga eseguita su un'istanza PLCSIM Advanced su questo computer. Il test di mutazione carica copie modificate del tuo blocco, quindi non viene mai eseguito su un controllore reale:
- Una suite che usa PLCSIM Advanced viene eseguita sulla sua istanza come di consueto.
- Una suite che usa S7 Native o OPC UA viene eseguita solo se il suo indirizzo salvato appartiene esattamente a un'istanza PLCSIM Advanced accesa su questo computer. Studio lo verifica all'avvio dell'esecuzione e altrimenti rifiuta l'esecuzione indicandone il motivo, ad esempio quando la suite non ha un indirizzo S7 salvato o l'indirizzo appartiene a un controllore reale. Studio carica quindi le copie di test solo in quell'istanza, la porta in RUN e, al termine dell'esecuzione, vi carica di nuovo il tuo progetto. Se la CPU è protetta, Studio ne chiede la password come per qualsiasi caricamento. Se l'istanza richiede una cancellazione totale, Studio te lo chiede prima, come fa Carica nel dispositivo, e una cancellazione rifiutata termina l'esecuzione con un messaggio. Se il caricamento assegna all'istanza l'indirizzo configurato nel tuo progetto, l'esecuzione si interrompe con un messaggio che indica quell'indirizzo, così puoi impostarlo come indirizzo S7 della suite o modificare l'indirizzo nel progetto.
Lo stesso vale per Esegui con strumentazione di copertura.
- Avvia Esegui test di mutazione dal riquadro comandi.
- Studio esegue prima la suite una volta sul blocco non modificato. La suite deve prima essere superata (il test di mutazione misura se i tuoi test superati sono accurati, quindi ti chiede di correggere i casi non riusciti prima di proseguire). Poi genera i mutanti ed esegue la suite su ciascuno di essi.
Puoi anche avviarlo con Esegui test di mutazione nella sezione Mutazione della scheda Qualità, oppure scegliendo Test di mutazione nelle opzioni di esecuzione del Test Bench; il Test Bench resta quindi sulla scheda Qualità.
L'esecuzione può richiedere un po' di tempo, perché ogni mutante viene compilato, caricato e testato a turno. Puoi interromperla in qualsiasi momento e Studio elimina comunque le copie temporanee che ha creato.
Quando una copia non può essere rimossa. Se Studio non riesce a eliminare uno dei suoi blocchi di test temporanei dopo un'esecuzione di copertura o di mutazione, un avviso indica i blocchi di test rimasti; eliminali in TIA Portal prima del caricamento successivo. Per una suite che usa S7 Native o OPC UA, Studio in tal caso non ricarica il tuo progetto nell'istanza, perché i blocchi di test verrebbero caricati con esso: l'avviso indica anche l'istanza e il suo indirizzo, e l'istanza continua a eseguire il programma di test finché non elimini questi blocchi e carichi tu stesso il progetto nell'istanza.
Nomi molto lunghi. Se il nome del blocco o del suo blocco dati di istanza supera i 120 caratteri, Studio non può creare le sue copie di test: Esegui con strumentazione di copertura ti avvisa allora che la copertura delle istruzioni non è disponibile per il blocco, e il test di mutazione si interrompe dopo la prima esecuzione con un messaggio che ne indica il motivo.
Leggere i risultati
La sezione Mutazione della scheda Qualità del Test Bench mostra:
- Un punteggio di mutazione (la percentuale di mutanti rilevati dai tuoi test, escludendo quelli che non è stato possibile eseguire), con il numero di mutanti uccisi, sopravvissuti e nati morti.
- Un elenco Mutanti sopravvissuti, una riga per ogni lacuna: la riga, il tipo di modifica e cosa è stato modificato. Fai clic su una riga per passare direttamente a quella riga nel sorgente del blocco.
- Elenchi comprimibili dei mutanti uccisi e nati morti.
I mutanti sopravvissuti sono evidenziati anche nell'editor: le righe interessate ricevono una tinta rossa e un indicatore rosso nella barra laterale, con una descrizione comando che spiega la modifica non rilevata da alcun test. Usa Mostra i marcatori di mutazione nel menu … del Test Bench, Attiva/disattiva i marcatori di mutazione nel riquadro comandi oppure Attiva/disattiva i marcatori di mutazione nella sezione Mutazione della scheda Qualità per mostrarli o nasconderli.
Ogni modifica è descritta come una sostituzione, ad esempio "> sostituito da >=".
Cronologia dopo il test di mutazione. Un'esecuzione del test di mutazione lascia una sola esecuzione in Cronologia: quella del blocco non modificato. Le esecuzioni sulle copie modificate vengono rimosse non appena ogni copia è stata testata, quindi la scheda Qualità mostra la copertura e il punteggio di mutazione della stessa esecuzione, e le tendenze e il rilevamento dei test instabili non sono influenzati dagli errori testati.
Un punteggio alto significa che i tuoi test hanno rilevato quasi ogni errore. Un punteggio basso, o un lungo elenco di sopravvissuti, ti indica esattamente dove aggiungere o rafforzare i casi di test.
Impostazioni
- Numero massimo di mutanti per esecuzione stabilisce quante modifiche Studio prova in un'esecuzione. Un numero più alto trova più lacune ma richiede più tempo.
- Operatori di mutazione ti permette di scegliere quali tipi di modifica applicare: confronti relazionali, operatori logici, costanti e aritmetica, ed eliminazione di istruzioni. Sono tutti attivi per impostazione predefinita.
Tracciabilità dei requisiti
La scheda Tracciabilità del Test Bench mostra, per ogni ID requisito della tua cartella dei test, quali casi di test lo coprono e quali sono i loro ultimi risultati. Copre l'intera cartella dei test, qualunque PLC, blocco o suite mostri l'intestazione del Test Bench. Aprila dalla sua scheda accanto a Qualità, oppure esegui Unit test: Mostra tracciabilità dei requisiti dal riquadro comandi. Con un requisito scelto nel filtro Requisito dell'Editor suite di test, Mostra in Tracciabilità apre la scheda con quel requisito selezionato.
L'elenco dei requisiti. La tabella superiore elenca una riga per requisito con il suo stato, il numero di casi di test, un chip per risultato (ad esempio 2 Superati, 1 Non riuscito), le suite e l'ora dell'ultima evidenza. Le righe sono ordinate per stato, le più urgenti per prime:
| Stato | Significato |
|---|---|
| Non riuscito | Almeno un caso di test del requisito non è riuscito o è terminato con un errore nella sua ultima esecuzione |
| Non coperto | Il tuo elenco dei requisiti importato indica il requisito, ma nessun caso di test lo fa ancora |
| Non eseguito | Un caso di test del requisito non è stato eseguito nelle esecuzioni recenti della sua suite |
| Obsoleto | Un caso di test è cambiato dopo la sua ultima esecuzione, oppure è stata approvata una nuova baseline snapshot della sua suite; eseguilo di nuovo |
| Sconosciuto | L'ultima esecuzione è stata registrata prima che Studio potesse rilevare le modifiche; eseguilo di nuovo |
| Incompleto | Un caso di test è stato saltato o messo in quarantena come instabile |
| Superato | Ogni caso di test del requisito è stato superato nella sua ultima esecuzione |
Studio considera le ultime 20 esecuzioni di ogni suite. Quando esegui un solo caso di test o una selezione, quell'esecuzione vale solo per quei casi; gli altri casi mantengono il risultato della loro ultima esecuzione completa. Modificare la connessione di una suite (istanza PLCSIM, indirizzo IP, password) non rende obsoleti i risultati.
I casi di test di un requisito. Seleziona un requisito per vederne i casi di test nella sezione Casi sottostante: suite, caso, stato, ora di inizio dell'esecuzione che ha prodotto il risultato (contrassegnata "esecuzione parziale" quando sono stati eseguiti solo alcuni casi), se quell'esecuzione è approvata e il messaggio. Fai doppio clic su un caso, o premi Invio, per aprire quell'esecuzione nella scheda Esecuzione con il caso selezionato. Fai clic con il tasto destro su un caso per Mostra esecuzione, Apri nell'editor della suite e Copia ID requisito. Trascina il divisore per ridimensionare le sezioni, oppure premi Tab finché il divisore non ha lo stato attivo e usa i tasti freccia Su e Giù (con Maiusc per passi più grandi, Home e Fine per spostarlo fino in fondo). Comprimi la sezione Casi con la sua intestazione.
Filtro. Digita nella casella del filtro per cercare ID requisito, titoli, suite, casi e blocchi. Stato limita l'elenco a un solo stato. Casi non tracciati elenca i casi di test che non indicano alcun requisito, così puoi trovare i test a cui manca ancora un ID requisito. I conteggi a destra della riga superiore riassumono l'elenco, ad esempio "12 requisiti, 1 non riuscito, 2 non coperti". Aggiorna (F5) ricarica la scheda; si aggiorna anche da sola dopo un'esecuzione e quando salvi una suite.
Condivisione. Condividi a destra della riga superiore offre:
- Esporta CSV… scrive le righe che vedi al momento (una riga per requisito e caso di test, con l'approvazione dell'esecuzione che ha prodotto ogni risultato) in un file CSV per la tua documentazione di qualità. Le celle che un programma di fogli di calcolo eseguirebbe come formula vengono scritte come testo semplice.
- Esporta report HTML scrive un report di tracciabilità nella cartella dei report del tuo progetto TIA (la sottocartella
traceabilitydella cartella di output scelta l'ultima volta in Esporta report, oppurereport/traceabilityse non ne hai scelta una) e lo apre come pagina. Elenca ogni requisito con il suo stato e i suoi casi di test, i casi di test non tracciati, i problemi del tuo elenco dei requisiti e una legenda degli stati, con il titolo, il piè di pagina e il colore di accento usati l'ultima volta per un report. In seguito puoi verificare contia-test-runner verifyche nessuno abbia modificato i file. La voce è disponibile mentre sei connesso al progetto TIA.
La scheda, il requisito selezionato, il filtro di stato e l'opzione Casi non tracciati vengono mantenuti quando riavvii Studio.
Importare un elenco dei requisiti
Importa l'elenco dei requisiti del tuo progetto (ad esempio un'esportazione dal tuo strumento ALM o di gestione dei requisiti, o un foglio di calcolo salvato come CSV) per vedere quali requisiti non hanno ancora un test. Apri Elenco dei requisiti nella riga superiore della scheda Tracciabilità e scegli Importa elenco dei requisiti…, oppure esegui Unit test: Importa elenco dei requisiti... dal riquadro comandi, e seleziona il file.
- File: file CSV o di testo fino a 10 MB e 20,000 righe. Vengono letti file UTF-8, UTF-16 (il "testo Unicode" dei programmi di fogli di calcolo) e ANSI; le colonne possono essere separate da virgole, punti e virgola o tabulazioni. Salva l'elenco come UTF-8 per mantenere esatti i caratteri speciali.
- Colonne: la prima riga indica i nomi delle colonne. La colonna dell'ID requisito può chiamarsi
id,requirement,requirement id,req idoreq; una colonna facoltativa del titolotitle,nameosummary; una colonna facoltativa della descrizionedescription,textodetails. Le altre colonne vengono ignorate. Funziona anche un file con una sola colonna di ID e senza intestazione. - Prima di scrivere qualsiasi cosa, Studio controlla il file e mostra cosa ha trovato, ad esempio "124 requisiti trovati. 1 riga viene saltata.", insieme a eventuali problemi, e chiede Importa. Le righe con un ID vuoto o non valido vengono saltate, un ID duplicato mantiene la sua prima riga, e i titoli o le descrizioni troppo lunghi vengono accorciati. Un file che non può essere importato affatto (troppo grande, senza colonna ID, con una virgoletta non chiusa) viene rifiutato con il motivo.
- L'elenco viene salvato nella cartella dei test accanto alle tue suite (
.tia-tests/requirements.csv), così le accompagna nel controllo di versione e anche l'esecutore da riga di comando lo trova. Una nuova importazione lo sostituisce; il tuo file originale non viene mai modificato.
Con un elenco, la scheda Tracciabilità aggiunge una colonna Titolo, mostra come Non coperto i requisiti elencati senza un caso di test e contrassegna con "Non presente nell'elenco dei requisiti" gli ID requisito delle tue suite che l'elenco non contiene. Quando un ID è scritto in modo diverso nell'elenco e nelle suite (ad esempio REQ-1 e req-1), una nota sopra la tabella lo segnala. I problemi dell'elenco sono riassunti sopra la tabella, e gli ID dell'elenco vengono suggeriti quando digiti un ID requisito in un caso di test.
Apri l'elenco dei requisiti apre l'elenco salvato in un editor di testo. Se invece lo apri in un programma di fogli di calcolo, le celle che iniziano con =, +, - o @ vengono calcolate come formule; Studio mantiene tali ID, titoli e descrizioni esattamente come scritti e ti avvisa. Rimuovi elenco dei requisiti… sposta l'elenco nel cestino dopo una conferma; i requisiti che nessun caso di test indica scompaiono quindi dalla scheda.
Nella chat IA puoi chiedere "quali requisiti non riescono?" o "quali requisiti non hanno ancora un test?"; l'assistente legge gli stessi stati della scheda. Può anche controllare e importare per te un file di elenco dei requisiti; chiede la tua approvazione prima di sostituire l'elenco e prima di controllare un file al di fuori del tuo workspace. La rimozione dell'elenco spetta a te.
Approvare un'esecuzione di test
Con un piano Pro+ o Enterprise (anche durante la versione di prova), puoi approvare un'esecuzione di test per registrare che ne hai controllato e accettato il risultato, ad esempio prima di un test di collaudo in fabbrica. L'approvazione riporta il tuo account e l'ora, e può contenere un commento. Puoi approvare le tue esecuzioni. Ogni esecuzione può essere approvata una sola volta; per modificare un'approvazione, revocala e approva di nuovo.
Quali esecuzioni possono essere approvate. Un'esecuzione di un'intera suite che è terminata. Un'esecuzione annullata, un'esecuzione di solo alcuni casi di test e un'esecuzione la cui suite è stata modificata in seguito non possono essere approvate; esegui di nuovo la suite e approva la nuova esecuzione. Anche le esecuzioni registrate prima che l'approvazione fosse disponibile richiedono una nuova esecuzione. Quando un'esecuzione ha casi di test non riusciti, con errori o in quarantena, è obbligatorio un commento che spieghi perché il risultato viene accettato.
Approvare.
- Apri l'esecuzione nella scheda Esecuzione e fai clic su Approva… nella sua riga di approvazione, oppure fai clic con il tasto destro sull'esecuzione nella scheda Cronologia e scegli Approva…. Puoi anche eseguire Unit test: Approva esecuzione di test… dal riquadro comandi, che apre la scheda Cronologia con l'esecuzione selezionata o la più recente.
- Un piccolo modulo mostra le esecuzioni con i loro risultati e l'account con cui approvi ("Approvazione come …"). Se vuoi, inserisci un commento (fino a 1,000 caratteri, a capo consentiti).
- Fai clic su Approva o premi
Ctrl+Enter.
Per approvare più esecuzioni insieme, selezionale in Cronologia (fino a 50) e scegli Approva… su una di esse, oppure fai clic su Approva… nella scheda Esecuzione dopo un'esecuzione di tutte le suite. O vengono approvate tutte le esecuzioni o nessuna: se un'esecuzione non può essere approvata, il modulo ne indica il motivo accanto a quell'esecuzione e non viene registrato nulla.
Revoca. Fai clic su Revoca… nella scheda Esecuzione, scegli Revoca approvazione… sull'esecuzione in Cronologia, oppure esegui Unit test: Revoca approvazione dell'esecuzione di test…. Solo l'account che ha approvato l'esecuzione può revocarla. Inserisci il motivo (obbligatorio) e fai clic su Revoca approvazione. L'approvazione e il motivo restano nella cronologia dell'esecuzione, e l'esecuzione può essere approvata di nuovo.
Cosa significano gli stati.
| Stato | Significato |
|---|---|
| Approvato | L'esecuzione e la sua suite non sono cambiate dall'approvazione |
| Obsoleto | La suite è cambiata dopo l'approvazione; eseguila di nuovo e approva la nuova esecuzione |
| Approvato, suite eliminata | Il file della suite è stato eliminato dopo l'approvazione |
| Compromesso | L'esecuzione salvata non corrisponde più a ciò che è stato approvato |
| Revocato | L'approvazione è stata revocata; l'esecuzione può essere approvata di nuovo |
| Non approvato | Nessuno ha approvato l'esecuzione |
Nella scheda Esecuzione, passa il puntatore sullo stato per vedere chi ha approvato, quando, e ogni approvazione e revoca precedente dell'esecuzione.
Le esecuzioni approvate vengono conservate. Un'esecuzione approvata non può essere eliminata da Cronologia finché non ne revochi l'approvazione. L'eliminazione di una suite non elimina mai le sue esecuzioni; la conferma ti indica quante esecuzioni approvate della suite restano in Cronologia. Quando le esecuzioni vecchie vengono cancellate dal database dei risultati, quelle approvate vengono conservate.
Nei report. Il report HTML di un'esecuzione mostra il suo stato di approvazione com'era al momento dell'esportazione del report, con l'account, l'ora, il commento e, per un'approvazione revocata, il motivo. Il report JUnit XML contiene gli stessi dettagli, così il tuo sistema CI può mostrarli. tia-test-runner verify stampa l'approvazione di un report e fallisce se i suoi dettagli sono stati modificati dopo l'esportazione.
Buono a sapersi. L'approvazione viene registrata sul computer che contiene l'esecuzione, nel suo database locale dei risultati, per l'account con cui hai effettuato l'accesso. Rileva modifiche successive all'esecuzione, alla suite e all'approvazione stessa, ma non è una firma elettronica. Devi aver effettuato l'accesso con il tuo account; se Studio ti chiede di accedere di nuovo, fallo prima di approvare. Se Studio rifiuta di approvare o revocare a causa dell'ora, controlla l'ora di sistema del tuo computer. L'assistente IA può dirti se le esecuzioni sono approvate, ma solo tu puoi approvare o revocare.
Analisi del blocco (prima di eseguire i test)
Quando apri una suite, AnyAutomation Studio estrae l'interfaccia del blocco dal progetto TIA, così l'editor conosce i nomi e i tipi reali dei parametri e le griglie degli input e delle asserzioni possono essere validate rispetto a essi.
Per questo non serve avere TIA Portal aperto. Se non sei connesso a TIA Portal, Studio legge il blocco da una copia che hai esportato in precedenza (esportala da Esplora progetto). Se il blocco non è ancora stato esportato, Studio mostra un messaggio che ti chiede di esportarlo prima o di connetterti a TIA Portal, invece di lasciare vuota l'interfaccia. Lo stesso vale quando esegui una suite: senza il blocco esportato e senza una connessione, Studio indica il blocco, ti dice di esportarlo o di connetterti con Apri progetto TIA o Collega a TIA Portal in esecuzione, e non esegue nulla.
Per un blocco di una suite CODESYS, Studio legge l'interfaccia dal progetto CODESYS aperto, e il riquadro nella colonna Blocco mostra il nome di quel progetto. Analizza dipendenze elenca quindi i blocchi richiamati, le variabili globali e i tipi di dati usati dal blocco e dai suoi metodi; se Studio non è riuscito a leggere ogni oggetto del progetto, la scheda indica che l'elenco potrebbe essere incompleto. Con il progetto CODESYS chiuso, la colonna Blocco non analizza il blocco.
Scegli una cartella di origine. Scegli cartella di origine… nel menu di connessione dell'intestazione del Test Bench ti permette di indicare a Studio dove si trovano i tuoi blocchi esportati. Scegli la cartella che contiene i tuoi file di esportazione, e la struttura delle cartelle al suo interno non conta più: che i file siano direttamente nella cartella o in sottocartelle, Studio trova il file giusto per il blocco. Così puoi analizzare ed eseguire i test senza TIA Portal aperto. Una cartella di origine scelta viene ricordata, quindi è di nuovo pronta subito dopo un riavvio. Lo stesso menu offre quindi Cambia cartella di origine… e Rimuovi cartella di origine. Per risultati più puliti, scegli la cartella in cui hai esportato, non una cartella superiore di più progetti.
La colonna Blocco del Test Bench ha le schede Interfaccia, Limiti e Dipendenze. Scegli un blocco nell'intestazione e Interfaccia e Limiti si riempiono subito; le Dipendenze vengono lette quando fai clic su Analizza dipendenze. Riassumono:
- Interfaccia: tutti i parametri del blocco (Input, Output, InOut, Static, Temp) con i loro tipi; passa il puntatore su un tipo per vederne il valore predefinito. Strutture, tipi di dati PLC e multiistanze sono inizialmente compressi: fai clic su uno per espanderlo, oppure usa Espandi tutto e Comprimi tutto in cima alla scheda.
- Limiti: valori min/max/zero/uno generati automaticamente per tipo di parametro (con un'azione Genera casi limite che salva un caso parametrizzato come nuova suite)
- Dipendenze: blocchi richiamati, DB referenziati, UDT referenziati
Creare una nuova suite di test
- Fai clic su Nuova suite di test nella barra del titolo della vista Esplora unit test (oppure eseguilo dal riquadro comandi)
- Quando sei connesso a un progetto TIA con dei PLC, scegli il PLC, poi il blocco da testare: il nome della suite viene derivato automaticamente come
<Block>_Tests. (Solo quando non sono disponibili PLC rispondi invece a tre richieste di testo libero, una dopo l'altra: il Nome della suite, il Blocco da testare e il Nome PLC.) - La nuova suite viene scritta in
<projectDir>/.tia-tests/{name}.jsone compare nella vista Esplora unit test - L'Editor suite di test si apre con un caso di test vuoto,
Case_1. Aggiungi le variabili che ti servono con Aggiungi input e Aggiungi asserzione: ogni nuova riga parte vuota, e l'elenco del campo Variabile mostra ogni membro dell'interfaccia del blocco, compresi i membri di strutture, tipi di dati PLC e multiistanze; scegli una voce dall'elenco o digita il nome. Una nuova riga di input appartiene al caso non appena ha un nome; prima di allora, la sua icona di rimozione la scarta. Un nome già presente nell'elenco viene evidenziato in rosso, e la riga resta così puoi correggerlo. L'interfaccia del blocco viene letta dal progetto TIA, quindi le griglie degli input e delle asserzioni vengono validate rispetto ai nomi reali dei parametri. Un input che il caso non imposta mantiene il valore che ha nel PLC all'avvio del caso, quindi imposta ogni input da cui dipende il tuo test. Per partire invece da casi compilati con valori limite, usa Genera dai valori limite nel menu …. - Usa la modalità Visivo (master-detail basata su moduli) per aggiungere / rimuovere / duplicare casi di test tramite campi e griglie: Nome, Descrizione, Cicli, Tag, Priorità + griglia degli input Arrange + griglia delle asserzioni + elenco Watch. Passa in qualsiasi momento ad Apri come testo JSON per modificare il JSON grezzo. La vista SCL mostra il codice di test SCL generato ed è anch'essa modificabile (vedi Gestire suite e casi di test)
- Fai clic su Salva (
Ctrl+S) per salvare le modifiche
Rinominare una suite dal campo JSON name
Quando modifichi il campo name in cima al JSON della suite e premi Salva, il file viene rinominato su disco di conseguenza ({newName}.json), e il titolo dell'editor si aggiorna nello stesso passaggio. Se nella stessa cartella esiste già una suite con il nuovo nome, il salvataggio si interrompe con un errore e lascia intatti entrambi i file, così puoi scegliere un altro nome.
Il campo blockName è indipendente e continua a identificare il blocco TIA da testare; non è influenzato da una ridenominazione del nome.
Schema JSON della suite di test
Ogni file .tia-tests/*.json segue la stessa struttura. Campi di primo livello:
name- Tipo
- string
- Obbligatorio
- sì
- Scopo
- Identificatore della suite (deve corrispondere al nome del file senza
.json)
blockName- Tipo
- string
- Obbligatorio
- sì
- Scopo
- Nome esatto del blocco TIA (sensibile alle maiuscole)
plcName- Tipo
- string
- Obbligatorio
- sì
- Scopo
- Nome del PLC/CPU nel progetto TIA (ad es.
PLC_1)
config- Tipo
- object
- Obbligatorio
- sì
- Scopo
- Impostazioni di connessione + trasporto (vedi sotto)
testCases- Tipo
- array
- Obbligatorio
- sì
- Scopo
- Una voce per caso di test (vedi sotto)
wiring- Tipo
- object
- Obbligatorio
- no
- Scopo
- Quale variabile di blocco dati il programma chiamante passa a ciascun input, scritta lì dal test (vedi Collegare gli input al programma chiamante)
config (tutti i campi facoltativi, con i valori predefiniti indicati):
cycles- Predefinito
-
1 - Scopo
- Cicli PLC predefiniti per caso di test (sovrascrivibili per singolo caso tramite
act.cycles)
cycleWaitMs- Predefinito
-
100 - Scopo
- Durata di un ciclo di test su PLCSim Advanced, OPC UA e S7 Native (vedi Cosa significa un ciclo di test); con Passo-passo il tempo di ciclo fisso di ogni scansione. Non usato dalle suite CODESYS, che hanno il loro Intervallo del task (ms)
timeoutMs- Predefinito
-
5000 - Scopo
- Timeout fisso per caso di test
instanceDbName- Predefinito
-
"" - Scopo
- DB di istanza da leggere/scrivere; vuoto →
<blockName>_DB(convenzione Siemens)
preferFc- Predefinito
-
false - Scopo
- Tollera blocchi FC (senza DB di istanza); impostalo quando la destinazione è una funzione anziché un blocco funzionale
transport- Predefinito
-
"plcSimApi" - Scopo
-
"plcSimApi"per la Tag-API diretta di PLCSIM (il valore predefinito),"s7CommPlus"per connettersi direttamente a un controllore S7 reale (vedi Connessione tramite S7 Native)
s7IpAddress- Predefinito
-
192.168.0.1 - Scopo
- Destinazione della connessione S7, usata solo quando
preparationMode = "external"(PLC reale). Per le modalità basate su PLCSIM (userPreloaded,tiaTcpDownload) l'esecutore si connette invece aplcSimIp, indipendentemente dal trasporto
s7Port- Predefinito
-
102 - Scopo
- Porta S7 ISO-on-TCP. Il valore predefinito
102corrisponde a ogni impostazione predefinita Siemens; modificalo solo se il PLC è stato riconfigurato su una porta TCP non standard
s7User,s7PasswordKeyId- Predefinito
-
""/ null - Scopo
- Riferimento alle credenziali (la password viene impostata nella pagina Impostazioni di connessione e non viene mai scritta nel file della suite). Necessario solo quando il PLC richiede l'autenticazione dell'utente; la maggior parte dei progetti lo lascia vuoto
plcSimInstanceName- Predefinito
-
"TiaUnitTest" - Scopo
- Nome dell'istanza PLCSIM Advanced. Usato da entrambi i trasporti ogni volta che
preparationMode != "external"
plcSimIp- Predefinito
-
"192.168.0.100" - Scopo
- IP del Virtual Adapter di PLCSIM. Questa è la destinazione effettiva della connessione S7 per
s7CommPlus + userPreloaded/tiaTcpDownload: impostalo sull'IP che hai assegnato al Siemens PLCSIM Virtual Ethernet Adapter, non sull'IP del progetto PLC
preparationMode- Predefinito
-
"userPreloaded" - Scopo
-
userPreloaded(predefinito; presuppone che l'istanza PLCSIM sia già in esecuzione con il tuo progetto caricato),tiaTcpDownload(compila + carica dal progetto TIA aperto, vedi i prerequisiti sotto) oexternal(PLC reale; usas7IpAddress)
masterSecretPasswordKeyId- Predefinito
- null
- Scopo
- Riferimento alla password master-secret del progetto. Necessario per
tiaTcpDownloadsolo quando il progetto TIA usa la protezione della configurazione PLC riservata. La password viene impostata nella pagina Impostazioni di connessione e non viene mai scritta nel file della suite
autoConnectS7- Predefinito
-
true - Scopo
- Connette automaticamente S7 prima dell'avvio dell'esecuzione. Impostalo su
falsesolo in configurazioni avanzate in cui un altro client (WinCC, HMI personalizzata) mantiene già la sessione e l'esecutore deve leggere/scrivere attraverso di essa
keepInstanceAfterRun- Predefinito
-
false - Scopo
- Mantiene attiva l'istanza PLCSIM dopo l'esecuzione. Ha effetto solo in modalità
tiaTcpDownload;userPreloadedeexternalnon gestiscono mai il ciclo di vita dell'istanza
Ogni voce in testCases:
name- Tipo
- string
- Obbligatorio
- sì
- Scopo
- Nome dello scenario in PascalCase (ad es.
Start_FromIdle_Runs)
description- Tipo
- string
- Obbligatorio
- no
- Scopo
- Una frase su cosa e perché
arrange.inputs- Tipo
- object
- Obbligatorio
- sì
- Scopo
-
{ "MemberName": value, … }, scritto nel DB prima di Act
act.cycles- Tipo
- int
- Obbligatorio
- no (predefinito
config.cycles) - Scopo
- Cicli PLC tra Arrange e Assert; deve essere > 1 perché
watch[]si attivi. Si esclude a vicenda conact.steps(iloneOfdello schema rifiuta entrambi sullo stessoact)
act.timeoutMs- Tipo
- int
- Obbligatorio
- no (predefinito
config.timeoutMs) - Scopo
- Timeout per caso. Copre l'intera sequenza
stepsdall'inizio alla fine quandostepsè impostato
act.steps- Tipo
- array
- Obbligatorio
- no
- Scopo
- Sequenza ordinata facoltativa di passi
write/wait/asserteseguita tra Arrange e ilassertionsdi primo livello. Vedi Passi multifase sotto. Si esclude a vicenda conact.cycles
assertions- Tipo
- array
- Obbligatorio
- sì
- Scopo
-
[ { "variable": "X", "operator": "equal", "expected": v, "tolerance": t? }, … ]
watch- Tipo
- string[]
- Obbligatorio
- no
- Scopo
- Variabili campionate una volta per ciclo durante Act → grafico di serie temporale nei report HTML
tags- Tipo
- string[]
- Obbligatorio
- no
- Scopo
- Etichette libere
priority- Tipo
- string
- Obbligatorio
- no
- Scopo
-
"low"/"normal"(predefinito) /"high"/"critical"
requirements- Tipo
- string[]
- Obbligatorio
- no
- Scopo
- Collegamenti di tracciabilità
order- Tipo
- int
- Obbligatorio
- no
- Scopo
- Chiave di ordinamento fissa nella UI
Valori operator supportati: equal, notEqual, greaterThan, lessThan, greaterThanOrEqual, lessThanOrEqual, inRange (si aspetta expected: [min, max]), inRangeExclusive, approximately, isTrue, isFalse, contains, startsWith, endsWith, matches, bitsSet, bitsClear, arrayEquals, allEqual, anyEqual, noneEqual, deepEquals. Per i valori di data e ora (DT, DTL, LDT) gli operatori di uguaglianza, intervallo e ordinamento e approximately confrontano il punto nel tempo, quindi expected può essere un letterale come LDT#2024-05-17-08:30:15 o il numero di nanosecondi dal 1970, e il tolerance di approximately è espresso in nanosecondi. tolerance si applica a inRange, approximately, arrayEquals, allEqual, anyEqual, noneEqual e deepEquals (predefinito 0.0001), non a equal/notEqual; usa approximately per un'uguaglianza approssimata Real/LReal. expected è richiesto dallo schema per ogni asserzione (impostalo su un valore qualsiasi, come false, true o 0, per isTrue/isFalse, poiché l'esecutore lo ignora).
Sicurezza: i valori di esempio sono segnaposto. Quando l'editor non riesce a dedurre i nomi reali di Input/Output dall'interfaccia del blocco, l'esempio predefinito usa valori sicuri (
Enable: false,Running: false), così un'esecuzione con un clic non può attivare per errore motori, valvole o altre uscite su hardware reale. Controlla sempre ogni valorearrange.inputse ogni asserzione prima di indirizzare l'esecutore verso un PLC reale.
Importante:
watch[]è l'array diagnostico del caso di test, NON la tabella di controllo di TIA. Le variabili elencate inwatchvengono campionate una volta per ciclo PLC durante la fase Act (a condizione cheact.cycles > 1) e visualizzate come grafico di serie temporale nei report HTML. Ciò è indipendente dalla tabella di controllo esterna di TIA Portal o da qualsiasi sottoscrizione OPC UA.
Esempio completo
Una suite minima completa con un caso di test che impiega ogni blocco e usa watch[]:
{
"name": "FB_Motor_Tests",
"blockName": "FB_Motor",
"plcName": "PLC_1",
"config": {
"cycles": 1,
"timeoutMs": 5000,
"instanceDbName": "FB_Motor_DB",
"transport": "plcSimApi",
"autoConnectS7": true,
"preparationMode": "userPreloaded"
},
"testCases": [
{
"name": "Start_FromIdle_RunsWithinThreeCycles",
"description": "Asserting Run goes high after StartCmd is set; watch shows trajectory.",
"arrange": {
"inputs": {
"StartCmd": true,
"Reset": false,
"Speed": 50.0
}
},
"act": { "cycles": 5 },
"assertions": [
{ "variable": "Run", "operator": "equal", "expected": true },
{ "variable": "Speed_Act", "operator": "inRange", "expected": [49.5, 50.5] },
{ "variable": "Error", "operator": "isFalse", "expected": false }
],
"watch": ["Run", "Speed_Act", "StartCmd"],
"tags": ["happy-path", "smoke"],
"priority": "normal"
}
]
}
Dopo l'esecuzione, la scheda Esecuzione del Test Bench mostra superato/non riuscito per ogni asserzione, e il report HTML visualizza un grafico di serie temporale per le tre variabili watch lungo i 5 cicli. Per aggiungere altre variabili da osservare a un caso esistente, aggiungile all'array watch e aumenta act.cycles al numero più piccolo che dia una copertura utile (di solito 3-10).
Passi multifase (act.steps)
Quando un singolo Arrange seguito da Assert non basta (ad esempio reset → attesa → avvio → attesa → verifica), usa act.steps invece di act.cycles. Sono disponibili tre tipi di passo:
"write"- Campi obbligatori
-
inputs(object, stessa struttura diarrange.inputs) - Effetto
- Scrive i membri elencati in modo additivo sopra ciò che è già nel DB. I membri non elencati mantengono il loro valore.
"wait"- Campi obbligatori
-
ms(int,0..3 600 000) - Effetto
- Attesa asincrona. Il PLC continua a eseguire i cicli. Quando
watch[]non è vuoto econfig.cycleWaitMs > 0, le variabili osservate vengono campionate una volta ogniconfig.cycleWaitMsms per tutta la finestra di attesa. Con Passo-passo l'attesa esegue invece una scansione per ciclo di test.
"assert"- Campi obbligatori
-
assertions(array, stessa struttura delassertionsdi primo livello) - Effetto
- Punto di controllo per passo. Un errore interrompe subito il caso e segnala
Step <N> (assert): <reason>(a partire da 1).
Ordine delle operazioni:
arrange.inputsviene scritto una volta all'avvio del caso (non viene ripetuto tra i passi).- Ogni voce in
stepsviene eseguita nell'ordine di dichiarazione. - Dopo l'ultimo passo, il
assertions[]di primo livello viene eseguito come verifica finale. Le asserzioni per passo e quelle di primo livello sono indipendenti; entrambe devono essere superate. Lo schema richiedeminItems: 1sulassertionsdi primo livello, quindi scrivi almeno un'asserzione banale di primo livello anche quando ti affidi soprattutto alle asserzioni per passo. watch[]continua a campionare durante ogni passowait(alle condizioni sopra indicate); il grafico di serie temporale annota i confini tra i passi.
Limiti (imposti dall'esecutore):
| Limite | Valore |
|---|---|
| Passi per caso | 1024 |
Input per passo write | 256 |
Asserzioni per passo assert | 256 |
wait.ms | 0..3 600 000 (1 ora) |
Editor visivo: la vista di dettaglio del caso mostra una sezione Passi (facoltativi) con i pulsanti + Scrivi, + Attendi e + Verifica per aggiungere passi, i pulsanti ↑ / ↓ per riordinare ciascun passo e - per rimuoverlo. L'editor omette automaticamente cycles dal JSON serializzato ogni volta che la sezione Passi non è vuota (lo schema rifiuta la combinazione cycles + steps, quindi l'editor evita di produrla).
Compatibilità con le versioni precedenti: un caso senza steps esegue il percorso esistente a fase singola basato su cycles, senza alcuna modifica del comportamento. Le suite meno recenti non richiedono alcuna migrazione.
Esempio completo: avvio temporizzato del motore
StartCmd viene impostato dopo una finestra di reset 500 ms, poi attendiamo 2 s che l'FB raggiunga Run, più una verifica finale della velocità.
{
"name": "MotorStart_ReachesRun",
"description": "Reset, wait, start, wait, check Run.",
"arrange": { "inputs": { "Enable": true } },
"act": {
"timeoutMs": 10000,
"steps": [
{ "type": "write", "inputs": { "Reset": true } },
{ "type": "wait", "ms": 500 },
{ "type": "write", "inputs": { "Reset": false, "StartCmd": true } },
{ "type": "wait", "ms": 2000 },
{ "type": "assert", "assertions": [
{ "variable": "Run", "operator": "isTrue", "expected": true }
]
}
]
},
"assertions": [
{ "variable": "Speed_Act", "operator": "greaterThan", "expected": 1000 }
],
"watch": ["Run", "Speed_Act"]
}
Se il assert per passo non riesce (ad esempio Run non è diventato true entro 2 s), l'esecutore emette Step 5 (assert): variable Run is not true e interrompe il caso. Se tutte le asserzioni per passo vengono superate ma il Speed_Act > 1000 di primo livello non riesce, il caso non riesce con il messaggio dell'asserzione di primo livello.
Nel dubbio, scrivi prima un semplice caso Arrange + cycles ≥ N + Assert. Convertilo in una sequenza steps solo quando la forma semplice non riesce a esprimere la temporizzazione da cui il test dipende davvero.
Aprire una suite esistente
- Dalla vista Esplora unit test: fai clic sulla suite nell'albero (si apre nell'Editor suite di test); facendo clic su uno dei suoi casi di test si apre la suite con quel caso selezionato
- Da Apertura rapida: premi
Ctrl+Pe digita il nome del file della suite sotto.tia-tests/
Dove vengono salvate le suite di test?
Le suite di test si trovano in una cartella nascosta chiamata .tia-tests direttamente accanto al file del tuo progetto TIA (*.ap21, *.ap20, …), oppure in cartelle che crei al suo interno (vedi Organizzare le suite di test in cartelle). Le suite per i blocchi CODESYS si trovano nello stesso tipo di cartella accanto al file del progetto CODESYS, usata quando nessun progetto TIA è connesso. Una cartella dei test scelta con Scegli cartella dei test vale per entrambi. L'assistente IA scrive nella stessa cartella. Se non hai ancora scelto una cartella dei test, la vista Suite di test mostra "Scegli una cartella dei test per caricare le tue suite di test." Scegli prima una cartella.
Scegli tu stesso la cartella: nella barra del titolo della vista Esplora unit test, fai clic su Scegli cartella dei test e seleziona la cartella in cui si trovano i tuoi test. Quando è scelta una cartella, la vista Esplora unit test segue quella cartella: cambiare progetto non la modifica; senza una cartella scelta, segue il progetto TIA connesso. La scelta viene ricordata, così i tuoi test compaiono di nuovo al prossimo avvio dell'app, anche senza una connessione TIA. Ti aiuta anche a recuperare i test di una configurazione precedente: basta scegliere la cartella in cui si trovano. Cancella cartella dei test (visibile solo mentre è scelta una cartella) annulla di nuovo la selezione; se la cartella scelta non esiste più, la vista mostra "Cartella dei test selezionata non trovata".
L'IA può leggere, elencare e modificare questi file delle suite di test direttamente tramite l'interfaccia della chat. Chiedi all'assistente dove sono salvate le tue suite: ti indica la cartella e se deriva dalla tua scelta o dal progetto TIA. Se vuoi le suite da un'altra parte, ad esempio nel tuo workspace Git, chiedigli di usare quella cartella; ti chiede conferma e poi funziona come Scegli cartella dei test. Le suite già salvate non vengono spostate.
Eseguire i test
- Assicurati che PLCSIM Advanced V3.0+ sia installato
- Apri il Test Bench e scegli il PLC, il blocco e la suite nella sua intestazione (oppure seleziona la suite nella vista Esplora unit test)
- Eseguila: fai clic su Esegui nell'intestazione del Test Bench, su Esegui suite nella riga di una suite nella vista Esplora unit test, su Esegui tutte le suite di test nella barra del titolo della vista, oppure usa un'azione del menu contestuale
- Segui l'avanzamento in tempo reale nella barra di stato e nella scheda Esecuzione del Test Bench
- Al termine dell'esecuzione, le icone di stato nella vista Esplora unit test si aggiornano e i risultati vengono salvati
L'esecutore automaticamente:
- Crea un'istanza PLCSIM Advanced (nome configurabile nel JSON della suite)
- La accende e compila il progetto PLC corrente
- Connette un client S7 all'istanza
- Scrive gli input di test, attende il numero di cicli configurato, legge le uscite, valuta le asserzioni
- Chiude la connessione S7 e annulla la registrazione dell'istanza
Opzioni di esecuzione
La freccia accanto a Esegui, nell'intestazione del Test Bench e nell'intestazione dell'Editor suite di test, apre le opzioni di esecuzione. Sono divise in quattro parti:
- Ambito: cosa eseguire. Nel Test Bench: Tutte le suite (ogni suite nella cartella dei test del progetto), Suite (la suite scelta nell'intestazione) o Casi non riusciti (i casi non riusciti nell'ultima esecuzione). Nell'Editor suite di test: Suite, Casi non riusciti o Casi selezionati (le righe selezionate nell'elenco dei casi; preimpostato quando sono selezionate delle righe). Un caso theory viene eseguito con tutte le sue righe di parametri. Ogni voce mostra quante suite o quanti casi esegue.
- Modalità: Standard, Copertura, Test di mutazione o Contratti di interfaccia. La copertura e il test di mutazione richiedono una connessione a TIA Portal e una destinazione PLCSIM Advanced, direttamente oppure tramite S7 Native o OPC UA all'indirizzo di un'istanza PLCSIM Advanced su questo computer (una suite CODESYS richiede solo il suo progetto CODESYS aperto in Studio); la verifica dei contratti di un blocco TIA richiede una connessione a TIA Portal. Queste tre modalità eseguono una sola suite.
- Opzioni (solo esecuzioni Standard):
- Riesecuzione di conferma dei casi instabili: un caso che non riesce ma che nelle esecuzioni recenti è stato sia superato sia non riuscito viene eseguito ancora una volta; se allora viene superato, conta come superato.
- Metti in quarantena i casi instabili: un caso che non riesce ma che è stato instabile nelle esecuzioni recenti viene segnalato come saltato (in quarantena) anziché non riuscito.
- Aggiorna le baseline snapshot: sostituisce le baseline snapshot salvate con i valori di questa esecuzione. Studio ti chiede prima una conferma. Non disponibile per le suite che si connettono tramite S7 Native.
- Mantieni l'istanza PLCSim dopo l'esecuzione: lascia in esecuzione l'istanza PLCSIM Advanced dopo l'esecuzione. Solo per le suite che caricano il progetto tramite TCP.
- Destinazione: dove viene eseguita la suite, ad esempio "PLCSim Advanced, PLC_SIM1 (192.168.0.5)". Modifica apre le impostazioni di connessione della suite.
Una voce non disponibile è disattivata; passa il puntatore sopra di essa per vederne il motivo. Avvia con il pulsante in basso (ad esempio Esegui suite o Esegui 2 casi) oppure premi Ctrl+Enter; Escape chiude senza eseguire. Tab sposta tra le parti, i tasti freccia tra le voci di una parte.
Cosa ricorda Esegui. Un semplice clic su Esegui esegue la suite con la tua ultima scelta di Riesecuzione di conferma dei casi instabili e Metti in quarantena i casi instabili; la stessa scelta vale per le esecuzioni dalla vista Esplora unit test, dal riquadro comandi e dalla scheda Esecuzione. Aggiorna le baseline snapshot e Mantieni l'istanza PLCSim dopo l'esecuzione valgono solo per l'esecuzione che avvii dalle opzioni. Se l'ultima volta hai eseguito con Copertura o Test di mutazione dalle opzioni, quel pulsante Esegui diventa Esegui (copertura) o Esegui (test di mutazione) e ripete la modalità; scegli una volta Standard per tornare alle esecuzioni normali. Passa il puntatore su Esegui per vedere la scelta attuale.
Scegliere un trasporto
Il trasporto determina come le letture e le scritture dei test viaggiano tra AnyAutomation Studio e il PLC. Lo imposti nel JSON della suite tramite config.transport (vedi lo schema sopra):
- PLCSim Advanced (
plcSimApi): accesso diretto tramite la PLCSim API di Siemens, più veloce e non richiede una sessione S7 attiva. È il valore predefinito. I valori di ogni tipo di ora e data, compresi DTL, LDT e LTIMEOFDAY, vengono scritti e letti da input, uscite, merker e blocchi dati con la loro dimensione esatta, così un indirizzo adiacente non viene mai toccato. I valori DT, DTL e LDT vengono riletti come letterali, ad esempioLDT#2024-05-17-08:30:15.123456789. - OPC UA: si connette al server OPC UA di un PLC, reale o simulato. Vedi Connessione tramite OPC UA.
- S7 Native: si connette direttamente a un controllore S7 reale, lo stesso tipo di connessione usato dalla vista PLC / OPC UA. Sceglilo quando vuoi eseguire una suite su hardware S7-1200 / S7-1500 reale. Vedi Connessione tramite S7 Native per i campi da compilare e la richiesta di conferma prima di un'esecuzione live. Incluso in Unit test (piano Pro+), anche durante la prova gratuita.
- CODESYS: esegue una suite per un blocco funzionale o una funzione CODESYS nella simulazione CODESYS o sul soft PLC CODESYS Control Win del tuo computer. È l'unico trasporto di una suite CODESYS. Vedi Testare blocchi CODESYS.
Ogni suite ha una destinazione indipendente. Per S7 Native, la suite possiede il proprio indirizzo IP, porta, nome utente e password; non c'è una ricerca condivisa dalla vista PLC / OPC UA.
Scegli il trasporto e tutto il resto della connessione nella pagina Impostazioni di connessione della suite, descritta nella sezione successiva. Puoi comunque modificare i valori direttamente nel JSON della suite tramite Apri come testo JSON nell'Editor suite di test.
Impostazioni di connessione
Ogni suite ha la propria pagina delle impostazioni di connessione. Aprila in uno di questi modi:
- fai clic sul tipo di connessione nell'intestazione dell'Editor suite di test, oppure scegli Impostazioni di connessione nel suo menu …;
- scegli Impostazioni di connessione nel menu … del Test Bench, per la suite scelta nella sua intestazione;
- fai clic con il tasto destro su una suite di test nella vista Esplora unit test e scegli Impostazioni di connessione;
- fai clic su Modifica accanto alla destinazione nelle opzioni di esecuzione;
- esegui Unit test: Impostazioni di connessione dal riquadro comandi e scegli la suite.
La pagina si apre in una scheda chiamata Connection: seguita dal nome della suite. È composta da quattro parti:
- Trasporto: PLCSim Advanced, OPC UA o S7 Native. Per PLCSim Advanced anche la Modalità di preparazione: Precaricato dall'utente o Download TCP (vedi Modalità di preparazione PLCSIM); Esterno (PLC reale) non è ancora disponibile. Una suite per un blocco CODESYS offre solo CODESYS (vedi Test dei blocchi CODESYS).
- La destinazione del trasporto scelto:
- PLCSim Advanced: Istanza (propone le istanze che PLCSIM Advanced conosce), Indirizzo IP, Modalità di rete, Controllo del ciclo (vedi Controllo del ciclo passo-passo più avanti), Attesa ciclo (ms), Connessione automatica e Mantieni l'istanza dopo l'esecuzione. Scegli una Modalità di rete (TCPIPSingleAdapter, TCPIPMultipleAdapter o Softbus) se PLCSim ha difficoltà ad avviarsi su un computer con più di una scheda di rete; (lascia invariato) mantiene l'impostazione attuale di PLCSim.
- OPC UA: i campi del server e Attesa ciclo (ms), vedi Connessione tramite OPC UA.
- S7 Native: i campi del controllore e Attesa ciclo (ms), vedi Connessione tramite S7 Native.
- Segreto principale (download TCP): solo per il download TCP, vedi Esecuzione su un progetto protetto.
- Isolamento: la Modalità è Basata sul tempo (predefinita) o Isolata (ogni caso di test parte da uno stato noto). La Modalità di reset (Nessuno, Valori predefiniti o Reset memoria) si applica alle esecuzioni isolate; Reset memoria richiede PLCSim Advanced. Una suite CODESYS ha i propri valori predefiniti, vedi Impostazioni di connessione di una suite CODESYS. Quando la suite contiene qualcosa che un'esecuzione isolata non supporta ancora (stub, casi in più passi, osservazioni della timeline, asserzioni snapshot), la pagina lo elenca sotto Isolamento.
Mentre la pagina è aperta, cambiare il trasporto conserva ciò che hai inserito per gli altri trasporti, così puoi tornare indietro senza reinserirlo. Il salvataggio memorizza nella suite solo le impostazioni del trasporto scelto.
Password. La pagina non mostra mai una password, ma solo se ne è memorizzata una: Impostato (memorizzato), Impostato (solo questa sessione), Non disponibile, inseriscila di nuovo o (non impostato). Per S7 Native, Non impostata, si applica la password predefinita o Non disponibile, si applica la password predefinita significa che la suite non ha una password propria e viene usata la password predefinita che hai salvato con Salva come predefinito per questo indirizzo, questa porta e questo utente. Fai clic su Modifica per inserire una nuova password, poi scegli Memorizza (archivio segreti del sistema operativo) per conservarla su questo computer per le esecuzioni successive, oppure Solo questa sessione per conservarla fino alla chiusura di Studio. Cancella rimuove la password al salvataggio; Annulla revoca Modifica o Cancella. Una password che non modifichi resta invariata al salvataggio. Se cambi l'indirizzo del server, la porta o l'utente di una connessione, Studio chiede di nuovo la password. Quando il trasporto scelto non usa più una password memorizzata, la pagina mostra Rimosso al salvataggio perché il trasporto non lo utilizza e il salvataggio la rimuove da questo computer. Le password non vengono mai scritte nel file della suite, così puoi condividere o fare il commit di una suite senza esporle.
Testa connessione verifica le impostazioni della pagina prima che tu le salvi. Il risultato compare accanto al pulsante:
- PLCSim Advanced richiede una connessione a TIA Portal. La verifica ti dice se PLCSIM Advanced Runtime Manager è in esecuzione e se l'istanza esiste. L'esecuzione accende l'istanza. significa che l'istanza esiste ma è spenta; l'esecuzione la avvia. Con Download TCP un'istanza che non esiste ancora va bene (L'esecuzione crea l'istanza.); con Precaricato dall'utente viene segnalata come problema, perché l'esecuzione avvierebbe un'istanza vuota.
- OPC UA si connette una volta al server e segnala Raggiungibile (il certificato del server non viene verificato). insieme all'indice dello spazio dei nomi rilevato. Una connessione aperta nella scheda Spazio di indirizzamento resta com'è. Come un'esecuzione di test, la verifica accetta il certificato del server senza chiedere.
- S7 Native non ha alcuna verifica. Un'esecuzione ti chiede una conferma prima di connettersi a un controllore reale; un indirizzo che appartiene a un'istanza PLCSIM Advanced su questo computer non richiede conferma.
Salvataggio. Salva (o Ctrl+S) scrive le impostazioni nella suite. Salva come predefinito le conserva anche come punto di partenza per le nuove suite: ogni suite che crei in seguito, dal Test Bench, dal riquadro comandi o dall'assistente, parte con questa connessione. Per S7 Native conserva anche la password come password predefinita per lo stesso indirizzo, la stessa porta e lo stesso utente, memorizzata su questo computer o solo per questa sessione, come hai scelto per la password. Ogni suite con quell'indirizzo, quella porta e quell'utente che non ha una password propria viene poi eseguita con essa; la password propria di una suite ha sempre la precedenza. Le altre password non vengono conservate. Se cancelli la password e poi usi Salva come predefinito, la password predefinita viene rimossa; la riga di stato lo indica. Una suite che non ha una password propria e viene eseguita con la password predefinita la mantiene quando lì usi Salva come predefinito. Annulla scarta le modifiche e chiude la pagina. Un campo con un problema viene contrassegnato con il motivo e Salva resta disabilitato finché non viene corretto.
Se la suite è aperta anche nell'Editor suite di test con modifiche non salvate, l'editor le conserva e le salva insieme alla nuova connessione al prossimo salvataggio. Se il file della suite cambia su disco mentre la pagina ha modifiche non salvate, una barra offre Ricarica (prendi le impostazioni dal file) o Mantieni le mie modifiche.
Che cosa significa un ciclo di test
Il numero di cicli di un caso di test e i suoi passi di attesa contano cicli di test. Che cosa sia un ciclo di test dipende dalla connessione della suite:
- PLCSim Advanced con Controllo del ciclo Temporizzato (predefinito), OPC UA e S7 Native: un'attesa di Attesa ciclo (ms) in tempo reale (100 ms come predefinito) mentre il controllore funziona liberamente. Quante scansioni del programma rientrano in un ciclo di test dipende dal tempo di scansione del controllore.
- PLCSim Advanced con Passo-passo: esattamente una scansione del programma con il Tempo di ciclo per scansione (ms) fisso, vedi Controllo del ciclo passo-passo più avanti.
- CODESYS: un ciclo del programma di test, la cui durata è impostata da Intervallo del task (ms) (vedi Impostazioni di connessione di una suite CODESYS).
Un passo di attesa dura il suo tempo diviso per la durata di un ciclo di test, arrotondato per eccesso: un passo di attesa di 250 ms con un ciclo di 100 ms dura 3 cicli di test. Scegli Passo-passo quando un test verifica fronti, sequenze di passi, contatori o un numero esatto di scansioni. Mantieni Temporizzato per la logica che dipende dalla data o dall'ora del giorno e per le esecuzioni lunghe, e usa un valore adeguato di Attesa ciclo (ms) su OPC UA e S7 Native, dove i singoli passi non sono disponibili.
Controllo del ciclo passo-passo
Per una suite su PLCSim Advanced con Precaricato dall'utente o Download TCP, la parte della pagina dedicata alla destinazione ha anche Controllo del ciclo:
- Temporizzato (predefinito): la CPU simulata funziona liberamente e un ciclo di test è un'attesa di Attesa ciclo (ms) in tempo reale. Quante scansioni del programma rientrano in un ciclo dipende dal tempo di scansione dell'istanza.
- Passo-passo: l'esecuzione trattiene l'istanza tra due scansioni e le fa eseguire esattamente una scansione per ciclo di test. Il campo sottostante si chiama allora Tempo di ciclo per scansione (ms) e imposta il tempo di ciclo fisso di ogni scansione, da 1 a 6000 ms. Cicli, passi di attesa e temporizzatori del programma mantengono il loro significato, e fronti, sequenze di passi e contatori danno lo stesso risultato a ogni esecuzione. Un passo di attesa di 250 ms con un tempo di ciclo di 10 ms esegue 25 scansioni.
Che cosa tenere presente con Passo-passo:
- Tempo reale. Un'esecuzione dura almeno il numero di cicli moltiplicato per il tempo di ciclo, di solito di più, perché ogni scansione attende Studio. Assegna ai casi di test lunghi un Timeout adeguato.
- Valori in millisecondi dei temporizzatori. PLCSim non mantiene ogni scansione esatta al microsecondo, quindi il tempo trascorso
ETdi un temporizzatore, o qualsiasi differenza di tempo in millisecondi, può indicare 1 ms in più di quanto suggerisca il numero di scansioni: un test di un temporizzatore su 5 scansioni di 100 ms indica in alcune esecuzioni 401 invece di 400. La differenza cresce lentamente con il numero di scansioni. Il conteggio delle scansioni, l'ordine degli eventi e i valori che dipendono dalle scansioni sono esatti. VerificaETe le differenze di tempo con una tolleranza di 1 ms, più circa 1 ms ogni 50 scansioni per le esecuzioni lunghe, oppure verifica invece l'uscitaQdel temporizzatore, i bit di passo o il numero di cicli. - Orologio della CPU simulata. L'orologio dell'istanza resta fermo mentre l'istanza è trattenuta, quindi rimane indietro rispetto al tempo reale di altrettanto. Testa la logica che dipende dalla data o dall'ora del giorno con Temporizzato.
- Valori congelati. Mentre un'esecuzione fa avanzare l'istanza a passi, i monitor di PLC / OPC UA, le tabelle di controllo e le viste online di TIA Portal mostrano i valori dell'ultima scansione; cambiano solo da una scansione all'altra. Studio te lo ricorda quando un'esecuzione di questo tipo si avvia.
- Un utente alla volta. Un'esecuzione Passo-passo non si avvia mentre Simulazione hardware usa l'istanza o mentre un'altra esecuzione la fa avanzare a passi, anche un'esecuzione dello strumento da riga di comando, e Simulazione hardware non può connettersi a un'istanza che un'esecuzione fa avanzare a passi.
- Non combinabile con la modalità di test isolata: Salva resta disabilitato, con una nota sotto Controllo del ciclo e Isolamento. Le esecuzioni di copertura e di mutazione usano sempre cicli temporizzati. Le suite su OPC UA, S7 Native o CODESYS non offrono questa scelta.
- Snapshot. Passare una suite da Temporizzato a Passo-passo o viceversa cambia ciò che misura, quindi registra di nuovo le sue baseline snapshot dopo il cambio.
Quando l'esecuzione termina, fallisce o viene interrotta, l'istanza torna da sola al funzionamento normale, anche se Studio si chiude durante l'esecuzione. Se un'istanza resta comunque trattenuta, per esempio perché un altro programma l'ha fatta avanzare a passi, la sua scheda nella dashboard di PLCSim Advanced mostra lo stato Congelato e una riga che indica chi la trattiene. Fai clic su Riprendi funzionamento normale sulla scheda, oppure esegui PLCSim: Riprendi funzionamento normale dal riquadro comandi, e conferma. Un'esecuzione che fa ancora avanzare l'istanza si interrompe allora con un errore al passo successivo. Puoi anche chiedere all'assistente di riprendere il funzionamento normale; prima ti chiede conferma.
Connessione tramite OPC UA
Una suite di test può essere eseguita su un PLC tramite OPC UA, oltre che su PLCSim Advanced. Apri le Impostazioni di connessione della suite (vedi Impostazioni di connessione) e scegli OPC UA sotto Trasporto.
Per una connessione OPC UA devi indicare:
- URL endpoint: l'indirizzo del server OPC UA del PLC, per esempio
opc.tcp://192.168.0.5:4840. - Modalità di sicurezza: Nessuna, Firma o Firma e crittografia. Scegli la modalità che il tuo server è configurato ad accettare; Firma e crittografia offre la protezione più alta.
- Autenticazione: Anonimo oppure Nome utente e password. Quando scegli Nome utente e password, inserisci le credenziali che il tuo PLC si aspetta. La password è memorizzata in modo sicuro sul tuo computer e non viene mai scritta nel file di test, così puoi condividere o fare il commit di una suite senza esporla.
- Indice dello spazio dei nomi: lascialo vuoto e Studio rileva automaticamente lo spazio dei nomi corretto sul controllore; questo è il caso normale. Imposta un numero solo per un server insolito in cui il rilevamento automatico non lo trova.
- Attesa ciclo (ms): la durata di un ciclo di test, 100 ms come predefinito (vedi Che cosa significa un ciclo di test).
La prima volta che ti connetti a un server il cui certificato AnyAutomation Studio non considera ancora attendibile, una richiesta ti chiede di confermare la connessione. Scegli Connetti comunque per considerare attendibile questo server e proseguire; la richiesta non compare più per quel server all'esecuzione successiva.
Rendi le variabili del PLC raggiungibili tramite OPC UA. Perché i test possano leggere e scrivere le tue variabili, i blocchi dati che toccano devono essere accessibili tramite il server OPC UA del PLC. Abilita l'accesso OPC UA per i blocchi dati interessati nel tuo progetto TIA Portal e caricalo nel PLC prima di eseguire la suite. Le variabili non esposte non possono essere lette né scritte e i casi di test interessati falliranno.
Esplorare lo spazio di indirizzamento
Nella scheda Spazio di indirizzamento della colonna Block del Test Bench puoi esplorare ciò che offre un server OPC UA prima di scrivere o eseguire test. La prima riga della scheda contiene l'indirizzo del server. Quando la suite scelta nell'intestazione viene eseguita tramite OPC UA, il suo indirizzo è già inserito; altrimenti lo è l'ultimo indirizzo che hai usato.
- Qualsiasi server: inserisci un indirizzo come
opc.tcp://192.168.0.5:4840. La seconda riga ti permette di scegliere Modalità di sicurezza dei messaggi (Nessuna, Firma, Firma e crittografia) e Autenticazione (Anonimo, oppure Nome utente e password con Nome utente e Password). Una password inserita qui viene usata solo per questa connessione e non viene salvata. - Il server della tua suite OPC UA: quando l'indirizzo è quello della suite nell'intestazione, la seconda riga mostra invece Impostazioni della suite; passaci sopra con il mouse per vedere la sicurezza e l'accesso che la suite usa. Studio si connette con questi e con la password salvata per quella suite, senza chiedere. Se per essa non è salvata alcuna password, o il server rifiuta il nome utente o la password, Studio chiede la password direttamente in questa riga; viene usata solo per questa sessione e mai salvata.
Fai clic su Connetti o premi Enter in un campo qualsiasi; Disconnetti termina la connessione. Lo spazio di indirizzamento viene mostrato come un albero che puoi espandere per scorrere i nodi disponibili e vedere quali variabili sono raggiungibili. Usalo per confermare il nome di una variabile e che sia esposta tramite OPC UA, così i tuoi casi di test puntano agli elementi giusti. Le variabili strutturate (tipi di dati PLC, strutture e array) mostrano il nome del loro tipo di dati, per esempio typMotor o Array of Bool, e si aprono sui loro membri, così puoi scendere fino all'elemento che un caso di test legge o scrive. In un caso di test, indirizza un tale elemento con il suo percorso, per esempio DB_Motor.Setpoints[3] o DB_Motor.StartTimer.Q.
Accanto al suo tipo di dati, ogni variabile mostra il valore attuale, per esempio CPU 1516F-3 PN/DP per il modello di CPU o [false, true] per un array. I valori vengono letti quando apri un ramo. Fai clic su Aggiorna valori nella prima riga della scheda per rileggere tutti i valori mostrati. Un valore di qualità incerta viene mostrato nel colore di avviso; una variabile il cui valore non può essere letto resta vuota. La scheda mostra un'istantanea, non valori live. Per osservare i valori che cambiano, usa PLC / OPC UA.
Creare ed eseguire test tramite OPC UA
Una volta impostata la connessione, le suite OPC UA si comportano esattamente come le suite PLCSim. Crei i casi di test allo stesso modo, li esegui con le stesse azioni Esegui suite di test / Esegui tutte le suite di test, osservi lo stesso avanzamento live e ottieni gli stessi risultati e la stessa cronologia delle esecuzioni. L'unica differenza è dove si connettono i test, e non hai bisogno di TIA Portal aperto per crearli o eseguirli.
Per pipeline e CI, una suite configurata per OPC UA viene eseguita anche nella pipeline generata. Poiché la password OPC UA non è memorizzata nel file di test, fornisci la password OPC UA all'esecuzione della pipeline, così il server di build può connettersi senza che nessuno sia presente.
Connessione tramite S7 Native
Una suite di test può essere eseguita anche direttamente su un controllore S7 reale tramite S7 Native. Apri le Impostazioni di connessione della suite (vedi Impostazioni di connessione) e scegli S7 Native sotto Trasporto. Questo tipo di connessione è incluso in Unit test (piano Pro+), anche durante la prova gratuita.
Per una connessione S7 Native devi indicare:
- Indirizzo IP: l'indirizzo del controllore, per esempio
192.168.0.10. Scrivi un indirizzo IPv4 come quattro numeri senza zeri iniziali; la pagina non accetta una forma come192.168.0.010. - Porta: la porta TCP del controllore. Il valore predefinito è
102, adatto alla maggior parte dei controllori. Cambiala solo se il tuo controllore è stato impostato su una porta diversa. - Nome utente (facoltativo): necessario solo se il tuo controllore richiede l'accesso di un utente. La maggior parte dei progetti lo lascia vuoto.
- Password: la password che il tuo controllore si aspetta. È memorizzata in modo sicuro sul tuo computer e non viene mai scritta nel file di test, così puoi condividere o fare il commit di una suite senza esporla.
- Attesa ciclo (ms): la durata di un ciclo di test, 100 ms come predefinito (vedi Che cosa significa un ciclo di test).
Usa Salva come predefinito nella pagina per rendere questi valori il punto di partenza per le nuove suite, così non devi inserirli di nuovo ogni volta. La password viene conservata come password predefinita per lo stesso indirizzo, la stessa porta e lo stesso utente, così le nuove suite su quel controllore vengono eseguite senza doverla reinserire.
Creare ed eseguire test tramite S7 Native
Una volta impostata la connessione, crei i casi di test come faresti per una suite PLCSim e li esegui con le stesse azioni Esegui suite di test / Esegui tutte le suite di test. L'unica differenza è dove si connettono i test: una suite S7 Native si connette direttamente al controllore che hai indicato, scrive gli ingressi del test nel controllore in funzione e verifica lì i risultati.
Poiché un'esecuzione scrive su hardware in funzione, una richiesta ti chiede di confermare prima che inizi. Quando esegui più suite S7 Native insieme, per esempio con Esegui tutte le suite di test, la richiesta compare una sola volta ed elenca le suite che vanno su un controllore reale con i loro indirizzi. Confermala solo quando l'impianto è in uno stato di test sicuro, e l'esecuzione inizia. Se annulli la richiesta, nessuna suite dell'esecuzione viene avviata.
Quando l'indirizzo di una suite appartiene a un'istanza PLCSIM Advanced su questo computer, per quella suite non c'è alcuna richiesta. Studio lo verifica di nuovo subito prima che la suite si avvii: se nel frattempo l'istanza è stata arrestata, quella suite e le successive non vengono eseguite e un messaggio ti chiede di avviare di nuovo l'esecuzione. Un'istanza PLCSIM Advanced su un altro computer conta come controllore reale.
Puoi eseguire i test anche su un controllore di sicurezza (F). La richiesta di conferma ti avvisa che la destinazione potrebbe essere un controllore di sicurezza e che devi assicurarti che il controllore possa essere manipolato in sicurezza e che l'impianto sia in uno stato di test sicuro prima di proseguire. Non c'è alcun blocco automatico: decidi tu se confermare o annullare.
Area di lavoro di simulazione
Previsto per l'area di lavoro nell'app. È prevista una vista Simulazione dedicata per gestire le istanze PLCSim Advanced direttamente da AnyAutomation Studio. Le funzionalità che offrirebbe sono descritte qui sotto.
Una vista Simulazione per gestire le istanze PLCSim Advanced mostrerebbe:
- Versione API, modalità di accesso online (PLCSim / TCP/IP singolo / TCP/IP multiplo), opzione di temporizzazione rigorosa del moto e porta del Runtime Manager.
- Una riga Scheda virtuale che mostra lo stato permanente della scheda Ethernet virtuale Siemens PLCSIM (Pronta / APIPA / Disabilitata / Non installata / Nessun IPv4), il suo indirizzo IPv4 e un pulsante di aggiornamento. Se la scheda resta bloccata nell'intervallo APIPA 169.254.x.y, i caricamenti non saranno affidabili; assegna un indirizzo IPv4 statico nelle impostazioni di rete di Windows.
- Ogni istanza PLCSim registrata con pulsanti di azione in linea: Accendi, Run, Stop, Reset memoria, Spegni, Impostazioni, Rete, Elimina. Ogni riga mostra l'indirizzo IP configurato; se l'istanza ha più di un'interfaccia con un IP, vengono elencati come
X1: 192.168.0.1, X2: 10.0.0.5. - Una casella combinata PLC TIA per ogni scheda di istanza: scegli il PLC di TIA Portal su cui si basa l'istanza. Usala quando l'istanza PLCSim è stata caricata con uno snapshot compilato da un PLC TIA diverso da quello con cui è registrata (per esempio: un'istanza chiamata
PLC_2che contiene in realtà il programma diPLC_1). Senza una scelta esplicita, l'app abbina per nome e, se nel progetto c'è un solo PLC, ripiega su quello, il che basta per la maggior parte delle configurazioni ma produce un albero delle variabili vuoto quando i nomi non coincidono. La scelta viene ricordata per ogni istanza. - Un pulsante Nuova istanza che chiede un nome e un tipo di CPU.
- Un riquadro Esplora variabili che si connette a qualsiasi istanza elencata e mostra tutte le variabili esposte dal programma in esecuzione, filtrabili per nome, area (Ingresso / Uscita / Merker / Blocco dati) e tipo di dati. L'aggiornamento automatico può essere attivato per osservare i valori live. Ogni variabile scrivibile ha un pulsante matita che apre una finestra di scrittura adatta al tipo (interruttore per Bool, input numerico con intervallo specifico per interi e numeri in virgola mobile, campo di un carattere per Char/WChar). Le variabili String sono di sola lettura. Le variabili struct e array sono elencate con i loro membri ed elementi interni come righe espandibili, così puoi cercare, osservare e modificare direttamente singoli campi come
OUT[5]oDI10.Channel; i pulsanti della barra degli strumenti Espandi tutto e Comprimi tutto espandono o comprimono l'intero albero in una volta. Le variabili strutturate di ingresso/uscita il cui layout deriva da una definizione di tipo del progetto (per esempio un bloccoMixerIOin%I0.0dichiarato comeArray[0..63] of Byte) si aprono in righe di membri con nome quando l'app è connessa al progetto TIA Portal che le definisce, permettendoti di scrivereIN.MixerIO[12]dalla stessa finestra che gestisce il resto dell'albero. - Una sezione Istanze salvate in fondo che elenca ogni istanza PLCSim Advanced salvata sulla memory card SIMATIC virtuale. L'intestazione mostra un contatore con il numero totale di istanze salvate; l'elenco mostra fino a tre righe alla volta e scorre se ce ne sono di più, così l'area di simulazione sopra resta visibile. Fai clic su Carica per registrarne di nuovo una e riprenderla; PLCSim riprende automaticamente il tipo di CPU, l'immagine di I/O e il programma memorizzati. Fai clic su Elimina (con conferma) per rimuovere la cartella salvata.
La scelta della vista verrebbe ricordata tra una sessione e l'altra, e il cambio lascia intatti tutti gli editor di suite aperti.
Modalità di preparazione PLCSIM
La modalità di preparazione determina come il runner porta online il tuo progetto prima dell'esecuzione dei test. La scegli nella pagina Impostazioni di connessione della suite, oppure nel JSON della suite tramite config.preparationMode:
- Lo carico io (
userPreloaded, consigliato): il runner si aspetta un'istanza PLCSIM che hai già avviato e caricato manualmente tramite TIA Portal. Salta compilazione e caricamento e si connette direttamente per eseguire i test. È l'opzione più rapida se lavori a ripetizione sullo stesso progetto. - Download TCP automatico (
tiaTcpDownload): il runner compila il progetto, avvia una nuova istanza PLCSIM e carica tramite TCP attraverso il PLCSIM Virtual Adapter. Nessuna interazione manuale con TIA Portal necessaria. Basta eseguire. - PLC reale (senza PLCSim) (
external): salta completamente il ciclo di vita di PLCSim e preparerebbe un'esecuzione su hardware S7 in funzione senza alcuna istanza PLCSim. Questa modalità di preparazione non è ancora disponibile per le esecuzioni nell'app. È un'opzione separata e prevista, e non è la stessa cosa della connessione S7 Native: per eseguire oggi su un controllore reale, scegli invece il tipo di connessione S7 Native (vedi Connessione tramite S7 Native e Esecuzione dei test su un PLC reale).
Prima di usare Download TCP automatico: devono essere soddisfatti quattro prerequisiti, altrimenti l'esecuzione fallisce con un errore di trasporto generico: (1) il PLCSIM Virtual Adapter deve essere installato e avere un indirizzo IPv4 statico che corrisponde a plcSimIp della suite; (2) il progetto deve essere aperto in TIA Portal: il runner avvia una compilazione del progetto aperto prima del caricamento; (3) se il progetto abilita Protect confidential PLC configuration data (protezione dei dati di configurazione riservati del PLC), devi fornire la password del master secret nella pagina Impostazioni di connessione della suite (vedi Esecuzione su un progetto protetto); (4) qualsiasi istanza PLCSIM esistente con lo stesso nome viene eliminata e ricreata a ogni esecuzione, quindi le altre applicazioni collegate a quell'istanza perdono la loro sessione.
Esecuzione dei test su un PLC reale
Puoi eseguire i test direttamente su hardware S7-1200 / S7-1500 in funzione usando una connessione S7 Native, senza alcun coinvolgimento di PLCSim:
- Assicurati che l'impianto sia in uno stato di test sicuro: attuatori isolati o interbloccati, nessun carico di produzione sul PLC, operatori informati.
- Nella pagina Impostazioni di connessione della suite, scegli S7 Native sotto Trasporto e inserisci l'indirizzo IP del controllore, la porta e (solo se il controllore lo richiede) nome utente e password. Vedi Connessione tramite S7 Native per i dettagli.
- Esegui la suite dalla vista Esplora unit test.
- Prima che i test raggiungano il controllore, una richiesta ti chiede di confermare l'esecuzione su hardware in funzione, una sola volta per l'intera esecuzione. Confermala quando l'impianto è in uno stato di test sicuro, e l'esecuzione inizia.
Alcune cose da sapere sulle esecuzioni su un controllore in funzione:
- Credenziali errate: se il controllore rifiuta l'accesso perché la password manca o è errata, Studio chiede la password S7 ed esegue di nuovo la suite. La password che inserisci viene usata per le suite successive sullo stesso controllore senza chiedere di nuovo, e sostituisce una password errata salvata per la suite. Se annulli, l'esecuzione si interrompe subito con un messaggio che ti invita a controllare nome utente e password, invece di fallire più tardi con un poco chiaro "variabile non trovata". Studio chiede al massimo tre volte per suite.
- Esecuzioni in blocco: Esegui tutte le suite di test esegue anche le suite S7 Native. Confermi una sola volta prima dell'avvio dell'esecuzione, per tutte le suite che vanno su un controllore reale.
- Il controllore deve essere in funzione: un'esecuzione su un controllore in funzione verifica prima lo stato operativo del controllore e si interrompe se non è in RUN, così nulla viene scritto mentre il programma non è in esecuzione.
Controllori di sicurezza (F). Quando esegui i test in modo interattivo, puoi usare come destinazione un controllore di sicurezza (F): la richiesta di conferma ti avvisa che la destinazione potrebbe essere un controllore di sicurezza e che devi assicurarti che il controllore possa essere manipolato in sicurezza e che l'impianto sia in uno stato di test sicuro, e decidi tu se confermare o annullare. Le esecuzioni assistite dall'IA sono diverse: l'assistente non esegue di sua iniziativa test sulla logica di sicurezza, quindi avvii sempre tu un'esecuzione su un controllore di sicurezza.
Test dei blocchi CODESYS
I blocchi funzionali e le funzioni di un progetto CODESYS si possono testare come i blocchi TIA, nella simulazione CODESYS o sul soft PLC CODESYS Control Win sul tuo computer. Ti servono un piano Pro+, CODESYS installato sullo stesso computer e il progetto CODESYS aperto nella barra laterale CODESYS (vedi CODESYS). CODESYS Control Win deve essere in esecuzione solo quando testi su di esso.
Creare una suite
- Nell'albero di progetto CODESYS, fai clic con il tasto destro su un blocco funzionale o una funzione e scegli Crea suite di test di unità.
- Conferma o modifica il nome proposto per la suite.
Studio legge l'interfaccia del blocco, crea la suite di test con un caso di test vuoto e la apre nell'Editor suite di test. La suite viene salvata nella cartella .tia-tests accanto al file del progetto CODESYS, o nella cartella di test che hai scelto, e compare nella vista Esplora unit test. Aggiungi ingressi e asserzioni come per qualsiasi altra suite.
Impostazioni di connessione di una suite CODESYS
La pagina Impostazioni di connessione di una suite CODESYS offre un solo trasporto, CODESYS, con la sezione Destinazione CODESYS. In Esegui su scegli dove vengono eseguiti i test:
- Simulazione: la simulazione CODESYS, senza alcun dispositivo o runtime. Una nuova suite parte con questa scelta. La simulazione esegue anche progetti il cui dispositivo è configurato per un altro controllore.
- CODESYS Control Win su questo computer: il soft PLC sul tuo computer. L'esecuzione sostituisce l'applicazione in esecuzione su di esso.
- Altro dispositivo: non disponibile in questa versione.
I campi della sezione:
- Gateway e Porta del gateway (solo CODESYS Control Win): il gateway attraverso cui Studio raggiunge CODESYS Control Win, per impostazione predefinita
localhoste1217. È accettato solo un runtime su questo computer. - Intervallo del task (ms): la frequenza con cui viene eseguito il programma di test, per impostazione predefinita 10 ms. Un passo di attesa di un caso di test dura il numero di cicli corrispondente.
- Utente del runtime (solo CODESYS Control Win): l'utente di CODESYS Control Win con cui l'esecuzione effettua l'accesso.
La sezione Isolamento stabilisce come i casi di test della suite si rapportano tra loro. Con Isolata e la modalità di reset Valori predefiniti, ogni caso di test parte da una copia ripristinata del blocco; una suite che non ha ancora un'impostazione si comporta così, e Convalida te lo segnala. Nuova istanza per caso dà a ogni caso di test una propria istanza del blocco, così la sua inizializzazione viene eseguita di nuovo; usala per un blocco funzionale che memorizza un riferimento a se stesso, perché una copia lo gestisce in modo errato. Basata sul tempo e la modalità di reset Nessuna mantengono lo stato tra i casi di test. Una nuova istanza per caso viene rifiutata quando le istanze di una suite richiederebbero troppa memoria.
La password del runtime non viene salvata con la suite. Studio la chiede alla prima esecuzione di una sessione e la conserva finché Studio non viene chiuso; se CODESYS Control Win la rifiuta, Studio la richiede all'esecuzione successiva. La simulazione non richiede password.
Testa connessione verifica la destinazione scelta senza caricare nulla: per la simulazione ti dice se il progetto può essere eseguito lì, per CODESYS Control Win effettua l'accesso e mostra il dispositivo e la versione del runtime. Se un'esecuzione venisse rifiutata, la riga ti dice perché, ad esempio quando il dispositivo del tuo progetto non corrisponde a CODESYS Control Win; in quel caso scegli Simulazione.
Eseguire i test
Fai clic con il tasto destro sul blocco nell'albero di progetto CODESYS e scegli Esegui test di unità, oppure esegui la suite di test dalla vista Esplora unit test o dal Test Bench come al solito. Studio copia il progetto salvato, aggiunge un programma di test alla copia e lo compila. Nella simulazione la build di test viene eseguita subito, senza chiedere, perché non è coinvolto alcun dispositivo. Su CODESYS Control Win Studio ti chiede prima di confermare, perché la build di test sostituisce l'applicazione in esecuzione su di esso. Il tuo progetto non viene modificato. Risultati, cronologia, andamenti e report compaiono come per qualsiasi altra esecuzione. Se la build di test ha errori di compilazione, l'esecuzione li segnala con l'oggetto a cui appartengono.
La finestra di dialogo di esecuzione mostra la destinazione sotto TARGET, ad esempio "CODESYS simulation" o "CODESYS Control Win on this computer" con il nome del progetto CODESYS aperto, e non offre Modifica per essa. Senza un progetto CODESYS aperto, o con un gateway su un altro computer, Esegui suite resta disattivato e la finestra di dialogo ne indica il motivo.
Dopo un'esecuzione su CODESYS Control Win, il soft PLC continua a eseguire la build di test. Carica di nuovo il tuo progetto dalla vista CODESYS, oppure riavvia CODESYS Control Win per avviare di nuovo la sua applicazione di avvio.
Cosa le suite CODESYS non supportano ancora
- Programmi come blocco in test; blocchi funzionali e funzioni di test.
- Collegamento degli ingressi.
- Un'asserzione snapshot in un passo; inseriscila nelle asserzioni finali del caso di test.
- Array e strutture interi come valori verificati; verifica i loro elementi o membri.
- Un controllore CODESYS diverso dalla simulazione e da CODESYS Control Win su questo computer.
Se un file di suite contiene già una di queste parti, Studio la mantiene quando salvi. Convalida mostra un avviso per ogni parte; fai clic su un avviso relativo a una parte che solo la vista JSON mostra, e la vista JSON si apre su quella parte. Esegui si ferma prima di chiedere la password del runtime e indica la parte. Quando esegui più suite insieme, Studio le verifica prima tutte, così non viene eseguito nulla finché una suite CODESYS contiene ancora una parte di questo tipo.
Controllo e snapshot. Controllo registra le variabili elencate una volta per ciclo, subito dopo la chiamata del blocco, e le mostra sulla timeline del Test Bench. Una struttura o un array compare come singoli elementi. L'asse del tempo è il numero di ciclo moltiplicato per l'Intervallo del task della suite. Un'asserzione Snapshot confronta tutte le uscite e le variabili in-out di un caso di test, e il valore di ritorno di una funzione, con una baseline approvata; la prima esecuzione registra la baseline, anche quando un'altra verifica del caso di test fallisce, e l'output del caso di test lo segnala. Approva baseline, Approva baseline snapshot e Aggiorna le baseline snapshot accettano una modifica che desideri. Una variabile esclusa dallo snapshot in Excludes può comunque essere in Controllo: resta sulla timeline e non viene confrontata. Entrambi funzionano in ogni modalità di isolamento.
Un caso di test registra al massimo 100,000 cicli e 256 variabili, un caso di test con uno snapshot al massimo 1,000 cicli, e un'esecuzione al massimo 300,000 valori. Convalida avvisa di questi limiti dove può, ed Esegui si ferma con un messaggio prima di caricare qualsiasi cosa. Studio non omette mai valori per restare entro un limite, quindi riduci i cicli o le variabili osservate.
Stub. Uno stub sostituisce, per un caso di test, una funzione o un blocco funzionale che il blocco testato chiama. Seleziona il caso di test, apri Stub e scegli Aggiungi stub. Scegli il blocco; Studio suggerisce i blocchi che il blocco testato chiama. Con Aggiungi valore imposti ciò che lo stub restituisce: Ret_Val per il valore di ritorno di una funzione, oppure il nome di un'uscita o di una variabile in-out, anche un elemento come stData.iSpeed o aValues[1]. Viene scritta solo l'uscita o l'elemento che indichi: tutto il resto resta com'è, quindi una variabile in-out mantiene il valore del blocco chiamante in tutti gli altri elementi, e una funzione senza valore restituisce il valore predefinito del suo tipo. Uno stub sostituisce il codice principale di un blocco: metodi, azioni e proprietà di un blocco funzionale continuano a eseguire il proprio codice. I casi di test senza lo stub eseguono il codice originale. La modifica esiste solo nella copia di test del tuo progetto; il tuo progetto resta invariato.
Puoi creare stub per funzioni e blocchi funzionali del tuo progetto scritti in testo strutturato. I blocchi di libreria, i programmi, i blocchi in altri linguaggi e il blocco testato stesso non possono essere sostituiti da stub, e ogni valore deve adattarsi alla sua uscita. Convalida indica cosa non può essere eseguito e avvisa quando il blocco testato non sembra chiamare un blocco sostituito da stub, anche quando ne chiama solo un metodo, nel qual caso lo stub non ha effetto. Esegui si ferma con lo stesso messaggio prima di caricare qualsiasi cosa. Dopo un'esecuzione, la scheda Esecuzione del Test Bench mostra sopra le verifiche quali blocchi sono stati sostituiti da stub nel caso di test selezionato. Puoi anche chiedere all'assistente di impostare gli stub; indica i blocchi sostituiti quando ti chiede di confermare.
Copertura. Fai clic con il tasto destro su una suite di test CODESYS nella vista Esplora unit test e scegli Esegui con strumentazione di copertura, oppure avviala dalla scheda Qualità del Test Bench o dalla finestra di dialogo di esecuzione; non serve una connessione a TIA Portal. Studio chiede la stessa conferma e la stessa password del runtime di Esegui, conta nella copia di test quali righe e rami del blocco testato vengono eseguiti, inclusi i suoi metodi, azioni e accessori di proprietà, e poi mostra Istruzione e Ramo accanto a Interfaccia e Blocchi chiamati nella scheda Qualità. Ogni riga indica l'oggetto a cui appartiene, ad esempio FB_Pump/Start; fai clic per aprire l'implementazione di quell'oggetto alla riga, e la heatmap di copertura colora le righe nell'editor. Export Coverage… scrive un file Cobertura con una voce per oggetto nella cartella dei report accanto al progetto CODESYS. I blocchi chiamati dal blocco testato e il suo blocco funzionale base non vengono conteggiati. Un blocco, un metodo o un'azione in un linguaggio grafico, codice con salti o etichette, la gestione delle eccezioni con __TRY, i pragma condizionali e un oggetto chiamato GVL_AaCov nel tuo progetto fermano l'esecuzione prima di caricare qualsiasi cosa, con l'oggetto e il motivo. Se i contatori non possono essere riletti dopo l'esecuzione, Studio lo segnala e mantiene i risultati dei test, ma non mostra una copertura parziale. Il tuo progetto resta invariato.
Test di mutazione. Fai clic con il tasto destro su una suite di test CODESYS nella vista Esplora unit test e scegli Esegui test di mutazione, oppure avvialo dalla scheda Qualità del Test Bench, dalla finestra di dialogo di esecuzione o dal riquadro comandi; non serve una connessione a TIA Portal. L'esecuzione usa la destinazione della suite: la simulazione CODESYS, oppure CODESYS Control Win su questo computer, mai un altro dispositivo. Su CODESYS Control Win Studio chiede la stessa conferma e la stessa password del runtime di Esegui. Poi esegue la suite una volta con la copertura. Ogni caso di test deve essere superato; altrimenti Studio ti dice quanti falliscono e si ferma. Poi modifica il blocco testato, i suoi metodi, azioni e accessori di proprietà un piccolo passo alla volta, solo nelle righe raggiunte dai tuoi casi di test, ed esegue la suite contro ogni modifica: una modifica che fa fallire un caso di test, o fermare l'applicazione, è uccisa, una modifica che ogni caso di test continua a superare è sopravvissuta, e una modifica che non compila è nata morta. Una modifica richiede circa cinque secondi. La scheda Qualità mostra il punteggio di mutazione e le modifiche, ciascuna con oggetto e riga, ad esempio FB_Pump/Start, line 4; fai clic su una per aprire l'implementazione di quell'oggetto alla riga, e i marcatori di mutazione mostrano le modifiche sopravvissute nell'editor di quell'oggetto. Quante modifiche fa un'esecuzione (al massimo 100 per CODESYS) e di quali tipi si imposta in Impostazioni > Unit test, come per i blocchi TIA. Un blocco, un metodo o un'azione in un linguaggio grafico, codice con salti o etichette, i pragma condizionali, uno stub sul blocco testato stesso e i casi di test che leggono più di 20,000 valori fermano l'esecuzione prima della prima modifica, con il motivo, così non ottieni mai un punteggio parziale. Prima della prima modifica Studio esegue anche il blocco non modificato ancora una volta nello stesso modo; se lì un caso di test fallisce, o un ciclo del blocco dura così a lungo che CODESYS Control Win ferma l'applicazione, l'esecuzione si ferma con il motivo invece di contare ogni modifica come uccisa. Se hai modificato il blocco o la suite dopo l'esecuzione con copertura, o hai aggiunto un metodo, un'azione o una proprietà al blocco, Studio ti chiede di eseguire di nuovo la suite con la copertura. Un caso di test con una verifica snapshot ha prima bisogno della sua baseline salvata: esegui la suite una volta normalmente e controlla la baseline. Se un'esecuzione potrebbe durare più di 55 minuti, Studio non la avvia e ti chiede di ridurre il numero di modifiche. Se durante l'esecuzione un valore non può essere letto, l'esecuzione si ferma senza punteggio invece di contare la modifica come uccisa. Nella simulazione, un ciclo che dura troppo a lungo ferma l'applicazione solo dopo alcuni secondi, quindi una modifica che rallenta soltanto il blocco può sopravvivere lì anche se su CODESYS Control Win verrebbe uccisa. Dopo un'esecuzione su CODESYS Control Win, l'applicazione di test viene rimossa di nuovo; se premi Arresta, la modifica in esecuzione in quel momento può restare su CODESYS Control Win fino all'esecuzione successiva. Arresta termina l'esecuzione senza punteggio. Il tuo progetto resta invariato.
Fixture e hook. Una suite di test può nominare ingressi riutilizzabili (fixture) che un caso di test riprende, e un caso di test può impostare valori prima di iniziare e dopo la fine. I valori di un caso di test prevalgono su quelli della sua fixture, e i valori dopo la fine vengono impostati anche quando una verifica è fallita. Li modifichi nella vista JSON dell'Editor suite di test, oppure chiedi all'assistente.
Contratti di interfaccia. Approva contratto di interfaccia e Verifica contratti di interfaccia funzionano come per i blocchi TIA, senza una connessione a TIA Portal. La verifica legge dal progetto CODESYS aperto il blocco, i suoi blocchi funzionali base e le strutture del progetto che usa, anche quando un membro contiene un array di tale struttura o un puntatore o riferimento a essa, così una modifica incompatibile in uno qualsiasi di essi compare con il suo percorso. Enumerazioni e alias contano solo per il nome, e un tipo di dati o un blocco funzionale base di una libreria resta escluso dalla verifica. Il progetto CODESYS deve essere aperto in Studio.
L'assistente crea una suite CODESYS con una sua azione dedicata. Può anche aggiungere e modificare casi di test, impostare l'isolamento e le fixture, verificare e approvare il contratto di interfaccia, approvare una baseline snapshot ed eseguire la suite, anche con nuove baseline o con copertura, ed eseguire test di mutazione, ogni modifica dopo che l'hai confermata. Può anche elencare i blocchi, le variabili globali e i tipi di dati che un blocco CODESYS usa.
Esecuzione su un progetto protetto
Se nel tuo progetto TIA è attivata "Protect confidential PLC configuration data" (proteggi i dati di configurazione riservati del PLC), la modalità di download TCP automatica richiede la password master secret del progetto:
- Nella pagina Impostazioni di connessione della suite, scegli PLCSim Advanced e la modalità di preparazione Download TCP
- In Segreto principale (download TCP), fai clic su Modifica e inserisci la password master secret del progetto
- Scegli Memorizza (archivio segreti del sistema operativo) perché ogni esecuzione successiva la usi senza chiedere, oppure Solo questa sessione per conservarla finché Studio non viene chiuso, poi fai clic su Salva
- Esegui la suite
La pagina mostra quindi Impostato (memorizzato) o Impostato (solo questa sessione). Lascialo così per mantenere la password salvata; Cancella la rimuove quando salvi. Se all'avvio di un'esecuzione non è disponibile alcuna password, Studio la chiede e la conserva per la sessione corrente.
La password non viene mai scritta nel file della suite, in alcun log o in alcun file di impostazioni, e gli altri utenti Windows del computer non possono leggerla.
Collegare gli ingressi al programma chiamante
Molti blocchi non vengono chiamati con valori fissi ma con variabili di un blocco dati, ad esempio "idb_FB_MotorControl"(bStart := "dbMotorControl".Control.Start, ...). Il programma chiamante passa queste variabili al blocco in ogni ciclo. Un valore che un test scrive direttamente nei dati propri del blocco verrebbe sostituito dal ciclo successivo, e il test segnalerebbe un errore o un risultato errato. Il collegamento indica al test da dove il programma chiamante prende ciascun ingresso, così il test scrive lì i suoi valori e il blocco li riceve nello stesso modo in cui li riceve in produzione.
Impostare il collegamento
- Apri la suite di test nell'Editor suite di test e seleziona un caso di test. Nella parte inferiore, la tabella INPUTS del caso ha una colonna Scritto in accanto al valore di ogni ingresso. L'intestazione della tabella indica il DB di istanza del blocco e quanti ingressi sono collegati.
- Verifica il DB di istanza con Choose Instance DB... nell'intestazione della tabella. Indica il blocco dati che il programma chiamante usa per questa istanza del blocco; puoi anche digitarne il nome.
- Per ogni ingresso passato dal programma, fai clic su Choose from DB... nella sua riga, scegli il blocco dati e poi la variabile al suo interno. Le variabili dello stesso tipo dell'ingresso sono elencate per prime. Puoi anche digitare la variabile nel campo Scritto in, ad esempio
"dbPlant".rcp.rTempSet, e un elemento di un array come"dbRecipes".Recipe[3].rQtyAfunziona allo stesso modo. Clear wiring lo rimuove di nuovo; un ingresso senza collegamento viene scritto nel DB di istanza come prima. - Salva la suite. Il collegamento appartiene alla suite: lo stesso ingresso viene scritto nella stessa variabile in ogni caso di test, così lo imposti una volta e lo vedi in ogni caso.
Cosa devi sapere
- Gli ingressi che il programma alimenta con un valore fisso, un calcolo o una variabile temporanea non possono essere pilotati da un test. Lasciali non collegati e fuori dai tuoi casi di test; il valore impostato dal programma resta valido.
- Una volta collegato il blocco, i valori iniziali dichiarati non lo raggiungono più. In ogni caso di test scrivi tutti gli ingressi da cui quel caso dipende.
- I valori collegati restano nel blocco dati da un caso di test al successivo. Gli ingressi che reagiscono a un fronte di salita, come un comando di avvio, richiedono una sequenza esplicita in passi multifase: scrivi FALSE, attendi, scrivi TRUE.
- Prima dell'avvio dell'esecuzione, Studio legge i valori attuali di tutte le variabili collegate e li ripristina al termine dell'esecuzione, così il programma chiamante prosegue con i valori che aveva prima del test.
- Se una variabile collegata non viene trovata nel controllore, l'esecuzione si ferma prima del primo caso di test e indica la variabile. Verifica il nome del blocco dati, il percorso della variabile e, via OPC UA, che il blocco dati sia accessibile per OPC UA.
- Dal DB di istanza vengono ancora lette solo le uscite. Collegare un'uscita non ha effetto sull'esecuzione.
- L'assistente può impostare il collegamento per te: cerca nel progetto come viene chiamato il blocco, collega ogni ingresso di conseguenza e ti dice quali ingressi il programma fissa (vedi Suite di test create dall'IA).
Fai clic su Convalida nell'Editor suite di test per verificare ogni nome di variabile e ogni collegamento rispetto al blocco, maiuscole e minuscole comprese. I problemi sono elencati sopra l'elenco dei casi, e Salva ed Esegui restano non disponibili finché non vengono corretti. Una suite di test con un collegamento non valido non si avvia.
Gestire suite e casi di test
- Rinomina una suite modificando il campo JSON
namein cima alla suite e premendo Salva: il file viene rinominato sul disco di conseguenza (vedi Rinominare una suite dal campo JSONname). Per eliminare una suite, fai clic con il tasto destro su di essa nella vista Esplora unit test e scegli Elimina. Per ordinare le suite, usa le cartelle (vedi Organizzare le suite di test in cartelle). - Modifica un caso di test nella modalità Visivo dell'Editor suite di test: ogni riga di un caso ti permette di rinominarlo, modificarne la descrizione, usare Duplica, rimuoverlo e riordinare i suoi passi multifase con Sposta su / Sposta giù.
- Modifica il codice di test SCL generato nella vista SCL dell'Editor suite di test: rinomina i casi di test, cambia le assegnazioni dei valori di ingresso, modifica, aggiungi o rimuovi verifiche di asserzione, e aggiungi o elimina interi blocchi di casi di test. Le modifiche confluiscono automaticamente nei casi di test: le viste Visivo e JSON le mostrano subito, e i dettagli dei casi che il testo SCL non mostra (descrizione, cicli, passi multifase, tolleranza, lista di controllo, tag, priorità, responsabile, requisiti) vengono mantenuti. Il blocco runner alla fine viene gestito automaticamente; le modifiche a esso non hanno effetto. Se il testo non corrisponde più alla struttura del blocco di test, compare un messaggio di errore con il numero di riga, e Salva e Importa in TIA sono bloccati finché non viene corretto. Passando a un'altra scheda dell'editor si scarta il testo SCL non ancora applicato; le modifiche già applicate vengono mantenute.
- Le impostazioni di connessione valgono per suite. Il trasporto, il nome dell'istanza PLCSim, l'indirizzo IP, il tempo di attesa del ciclo, la destinazione S7 Native (IP, porta, utente, password) e il comportamento di connessione automatica si trovano tutti nel blocco
configdel file della suite. Vengono salvati con la suite, così la prossima volta che la apri sono in vigore gli stessi valori. Le password sono salvate su questo computer; il file della suite non contiene mai una password. (La pagina Impostazioni di connessione della suite li modifica senza toccare il JSON, vedi Impostazioni di connessione.) - Fai clic su Convalida nell'Editor suite di test per verificare ogni nome di variabile e ogni collegamento della suite di test rispetto al blocco, maiuscole e minuscole comprese. I problemi sono elencati sopra l'elenco dei casi, e Salva ed Esegui restano non disponibili finché non vengono corretti.
- Quando un caso di test fallisce, il suo messaggio compare nella colonna Messaggio della scheda Esecuzione, e la sezione Asserzioni contrassegna l'asserzione fallita accanto ai valori Expected e Actual. Fai doppio clic sul caso per aprirlo nell'Editor suite di test.
- Se un file di suite viene modificato esternamente (o rinominato tramite il campo JSON
namedescritto sopra), l'editor aperto si ricarica automaticamente, a meno che tu non abbia modifiche non salvate, nel qual caso le tue modifiche vengono mantenute.
Risoluzione dei problemi
- Le icone di stato non si aggiornano dopo un'esecuzione: assicurati che la suite sia salvata e che il suo file si trovi nella cartella
.tia-tests(o nella cartella di test che hai scelto). - Azione di esecuzione non disponibile: deve essere aperto un progetto TIA, e il documento della suite attiva deve essere JSON valido.
- Esplora test è vuoto: la directory di lavoro non ha ancora una cartella
.tia-tests/. Fai clic su Nuova suite di test per creare la prima; la cartella viene creata automaticamente. - Errori di PLCSIM: verifica che PLCSIM Advanced V3.0+ sia installato e dotato di licenza. La versione esatta viene rilevata automaticamente in fase di esecuzione. Un errore durante un'esecuzione indica l'istanza, cosa stava facendo l'esecuzione, lo stato operativo dell'istanza e se il blocco dati è noto all'istanza. Quando dice che il blocco potrebbe non essere stato caricato, carica il programma nell'istanza (oppure usa la modalità di preparazione Download TCP) e porta l'istanza in RUN.
- "TIA Portal is online with PLC …": un'esecuzione o un'analisi del blocco deve leggere il blocco da TIA Portal, cosa non possibile mentre TIA Portal è online con quel PLC. Vai offline in TIA Portal e avvia di nuovo.
- Esecuzione con un progetto aperto offline: mentre un progetto è aperto con Apri progetto TIA (Offline), le esecuzioni di test e l'analisi del blocco del Test Bench leggono il blocco da quel progetto, poi dal suo file esportato, anche quando Studio è connesso anche a TIA Portal. Se nessuno dei due ha il blocco, l'esecuzione si ferma con un messaggio che indica il progetto offline: verifica che la suite indichi un PLC e un blocco di quel progetto, oppure esporta il blocco.
- Acquisire il traffico TLS per il supporto (avanzato): se il supporto chiede una cattura Wireshark di una connessione S7 Native cifrata, imposta la variabile d'ambiente
SSLKEYLOGFILEsu un percorso di file assoluto prima di avviare l'app (ad esempiosetx SSLKEYLOGFILE "C:\Temp\s7-keys.log"), poi riavvia. Imposta la preferenza TLS di Wireshark (Pre)-Master-Secret log filename sullo stesso file. Finché questa opzione è attiva, a ogni connessione viene scritto un avviso nel log dell'app, così non dimentichi di rimuoverla. In funzionamento normale lascia la variabile vuota.
Suite di test create dall'IA (Pro+)
La chat IA può preparare, perfezionare e (facoltativamente) eseguire per te suite di test di unità SCL complete. Richiede una licenza Pro+ o superiore.
Skill per scrivere test di unità (chat principale)
- Apri Chat IA e scegli la skill Write Unit Tests dal selettore delle skill, oppure chiedi semplicemente: "scrivi test di unità per FB_MotorControl"
- L'assistente legge l'interfaccia del blocco, calcola i valori limite, pianifica i casi di test e riassume il piano nella chat (niente enormi blocchi JSON)
- Quando è pronto a scrivere la suite, nella chat compare una scheda di conferma. Fai clic su Consenti per permettere all'assistente di salvare la suite in
.tia-tests/, oppure scegli Consenti in questa sessione dalla scheda per non ricevere più richieste per il resto della sessione di chat - Se hai chiesto all'assistente di eseguire anche la suite, una seconda scheda chiede conferma prima dell'esecuzione stessa. I risultati tornano nella chat come riepilogo superato/fallito, e l'assistente si offre di perfezionare i casi falliti
- L'assistente non sovrascrive mai una suite: quando il nome che chiedi è già occupato, anche con maiuscole diverse, o un file di suite con quel nome non può essere letto, chiede un altro nome
- La vista Esplora unit test rileva automaticamente la nuova suite: aprila, controllala in modalità Visivo o come testo JSON ed eseguila tu stesso quando vuoi
- Puoi anche chiedere all'assistente di "aprire quella suite" dopo che è stata creata; la suite si apre nell'Editor suite di test senza che tu debba passare alla vista Esplora unit test
Lasciare che l'assistente modifichi una suite aperta
Quando una suite di test è aperta nell'Editor suite di test, puoi chiedere all'assistente nella chat IA di modificarla, ad esempio "aggiungi un test di overflow per Counter_Value" o "restringi la tolleranza su tutte le asserzioni REAL a 0.01".
- L'assistente legge la suite aperta e prepara la sua modifica in attesa di revisione. L'editor mostra una barra: "AI edits are staged for review. Keep them to apply, or Undo to discard."
- Fai clic su JSON nell'editor per confrontare la suite prima e dopo la modifica; il confronto si apre alla prima modifica.
- Se l'assistente fa più modifiche di seguito, si sommano e compaiono tutte nello stesso confronto.
- Fai clic su Mantieni per applicare tutte le modifiche in attesa (poi salva la suite come al solito), oppure su Annulla per scartarle tutte.
Quando l'assistente modifica direttamente la suite mentre c'è una modifica in attesa, ad esempio aggiunge un caso di test o cambia le impostazioni, quella modifica viene salvata e aggiunta anche alla versione in attesa, così Mantieni non la annulla. Se non si adatta alla versione in attesa, ad esempio perché la modifica in attesa ha rinominato il caso, l'assistente ti chiede prima di mantenere o annullare la modifica in attesa.
L'assistente verifica nomi e tipi delle variabili rispetto al blocco reale, così le discrepanze vengono individuate prima che tu mantenga una modifica. Evita di digitare nella suite mentre c'è una modifica in attesa: Mantieni applica la versione della suite dell'assistente. La scheda della suite passa in primo piano quando l'assistente prepara una modifica, così vedi Mantieni e Annulla; se la scheda non può mostrarli, l'assistente ti chiede di aprirla. La connessione di una suite non viene modificata in questo modo, vedi Lasciare che l'assistente configuri la connessione.
Scegliere quali strumenti dell'assistente possono agire. Nella chat IA, Apri personalizzazioni, Autorizzazioni strumenti elenca gli strumenti dei test di unità come gruppo unit-tests. Per ogni strumento che scrive o esegue (ad esempio creare o eliminare una suite, modificare una suite aperta o eseguire una suite) puoi scegliere di ricevere una richiesta ogni volta, consentirlo sempre o negarlo sempre; uno strumento negato resta bloccato anche quando la chat approva gli strumenti automaticamente. Gli strumenti che leggono soltanto non chiedono mai.
Controllare i casi di test creati dall'IA
I casi di test scritti dall'assistente non portano alcun badge AI visibile nell'albero di Esplora test o nell'editor Visivo; compare solo un badge Theory (N rows) per i casi parametrizzati.
Controlla i casi di test creati dall'IA come faresti con la pull request di un collega: leggi ogni asserzione, verifica la plausibilità dei valori attesi, poi esegui sul simulatore prima di puntarli su hardware reale.
Lasciare che l'assistente configuri la connessione
Puoi chiedere all'assistente di cambiare il modo in cui una suite di test si connette ed esegue, ad esempio "esegui questa suite via S7 Native sulla mia istanza PLCSIM Advanced a 192.168.0.20" o "imposta il timeout a 10 secondi". Una scheda di conferma elenca ogni impostazione che sta per salvare con il suo nuovo valore. Dopo Consenti, la modifica viene salvata come nella pagina Impostazioni di connessione, così la suite, una pagina Impostazioni di connessione aperta e l'Editor suite di test mostrano i nuovi valori. Se la pagina Impostazioni di connessione della suite ha modifiche non salvate, l'assistente ti chiede prima di salvarle o scartarle, e mentre è in corso un test attende la fine dell'esecuzione.
L'assistente può anche verificare la connessione di una suite nello stesso modo di Testa connessione prima di avviare un'esecuzione. La connessione predefinita con cui partono le nuove suite resta una tua impostazione. Via S7 Native o OPC UA l'assistente esegue i test solo su un'istanza PLCSIM Advanced su questo computer, mai su un controllore reale: un'esecuzione su un controllore reale la avvii sempre tu dal Test Bench.
L'assistente non vede né inserisce mai una password. Quando un nuovo indirizzo, una nuova porta o un nuovo utente ne richiedono una, la password salvata della destinazione precedente viene rimossa e l'assistente ti chiede di inserire quella nuova nella pagina Impostazioni di connessione.
Dal piano Pro+ l'assistente può anche creare, avviare e indirizzare l'istanza PLCSIM Advanced su cui viene eseguita una suite, vedi PLCSIM Advanced.
L'assistente sa quali impostazioni usa ciascun tipo di connessione. Per S7 Native gli servono solo l'indirizzo IP della CPU e la porta (102 per impostazione predefinita); non ci sono rack o slot da impostare. Se chiedi un'impostazione che il tipo di connessione scelto non usa, l'assistente ti dice che la suite non la conserva.
Quando crei con l'assistente una suite per un'istanza PLCSIM Advanced e alcuni membri del blocco non sono accessibili da HMI/OPC UA/Web API, l'assistente ti avvisa: PLCSIM Advanced non può raggiungere quei membri. Suggerisce quindi di passare la suite a S7 Native o di attivare l'accessibilità di quei membri in TIA Portal.
Su quali destinazioni l'assistente può eseguire i test
L'assistente esegue una suite solo su una simulazione sul tuo computer:
- Le suite che usano PLCSIM Advanced vengono eseguite sull'istanza indicata.
- Le suite che usano S7 Native o OPC UA vengono eseguite solo quando il loro indirizzo appartiene a un'istanza PLCSIM Advanced su questo computer che è in RUN o STOP, con PLCSIM Advanced impostato su una modalità di rete TCP/IP. Un'istanza che ha ottenuto il suo indirizzo da un'esecuzione precedente dell'assistente non conta, perché l'assistente ha scelto quell'indirizzo da solo. Studio lo verifica autonomamente prima di ogni esecuzione.
- Qualsiasi altro indirizzo conta come controllore reale. L'assistente non esegue la suite e ti chiede di avviare tu l'esecuzione dal Test Bench, dove la confermi.
Eseguire solo alcuni casi. Puoi chiedere all'assistente di eseguire solo alcuni casi di test di una suite di test, ad esempio "esegui solo StartReachesNominalSpeed e NoEnableStaysStopped". L'esecuzione è la stessa di Casi selezionati nell'Editor suite di test, e Cronologia la mostra come esecuzione parziale. Un nome di caso che non esiste viene rifiutato prima che parta qualcosa, con i nomi più simili.
L'assistente non avvia un'esecuzione mentre è in corso un altro test, e non ferma mai un'esecuzione avviata da te.
La scheda di conferma di un'esecuzione indica il tipo di connessione, la destinazione e, per un'esecuzione parziale, i casi selezionati. Dopo un'esecuzione, chiedi all'assistente quali casi sono falliti: può elencare ogni caso con il suo messaggio di errore e il valore atteso ed effettivo di ogni asserzione fallita.
Puoi anche chiedere di un singolo caso di test, ad esempio "perché StopWhileRunningStops fallisce?". L'assistente legge quel caso senza caricare l'intera suite e mostra i suoi risultati nelle esecuzioni recenti: da quale esecuzione fallisce, se la suite è cambiata da allora e se il caso è instabile, cioè viene superato e fallisce alternativamente.
Protezione Safety (F-CPU)
La creazione di test con l'IA è limitata per i blocchi Safety:
- Creazione dei test: l'assistente si rifiuta di creare test per un blocco F-CPU senza una tua conferma esplicita nella conversazione. Senza tale conferma, non viene scritto alcun test
- Esecuzione dei test in corso: l'assistente non può eseguire test sui blocchi Safety. Punto, nessuna deroga. La verifica dei blocchi Safety richiede una metodologia certificata (TÜV/CE), non un'esecuzione generata dall'IA. Se vuoi eseguire un test su un blocco Safety, avvia tu l'esecuzione da Esplora test
Licenze
La skill Write Unit Tests e gli strumenti dei test di unità nella chat IA richiedono Pro+ o superiore. Con un piano inferiore, la skill mostra un messaggio di licenza prima che venga effettuata qualsiasi chiamata all'IA.
Integrazione CI/CD
Lo strumento da riga di comando tia-test-runner esegue le tue suite di test di unità SCL su un server di build, senza interfaccia utente e senza clic manuali. Indicagli un progetto TIA Portal: trova le suite in .tia-tests/, le esegue, scrive report leggibili dalle macchine e restituisce un codice di uscita su cui la tua pipeline può agire. Apre TIA Portal in modalità headless (senza finestra), così funziona senza problemi su un agente di build; passa --show-ui per seguirlo sullo schermo durante il debug. È una funzionalità Pro+ (Pro+ e superiori); l'agente ha bisogno di un file di licenza CI che salvi da Studio (vedi Licenza per la CI più sotto).
Lo strumento da riga di comando tia-test-runner
Lo strumento viene distribuito come tia-test-runner.exe ed espone nove verbi. tia-test-runner --help e tia-test-runner <verb> --help elencano le opzioni sull'agente.
run- File di licenza necessario
- Sì
- Cosa fa
- Esegue le suite di test di un progetto TIA o di un progetto CODESYS salvato, registra i risultati sull'agente e scrive i report
validate- File di licenza necessario
- No
- Cosa fa
- Controlla la presenza di errori nei file delle suite e, con
--config, nel file di configurazione, senza eseguire nulla
verify- File di licenza necessario
- No
- Cosa fa
- Controlla che i file di report di un'esecuzione non siano cambiati da quando l'esecuzione li ha scritti e mostra l'approvazione dell'esecuzione
compare- File di licenza necessario
- Sì
- Cosa fa
- Scrive un report HTML che confronta due esecuzioni registrate
trend- File di licenza necessario
- Sì
- Cosa fa
- Esporta come CSV la cronologia superato/non superato di un PLC, di una suite o di un caso
flaky- File di licenza necessario
- Sì
- Cosa fa
- Elenca i casi di una suite che nelle esecuzioni recenti alternano tra superato e non superato
traceability- File di licenza necessario
- Sì
- Cosa fa
- Controlla la tracciabilità dei requisiti e fa fallire la build in presenza di requisiti non superati o non testati (vedi Gate di tracciabilità dei requisiti più sotto)
check-contracts- File di licenza necessario
- Sì
- Cosa fa
- Confronta l'interfaccia di ogni blocco in test con il suo contratto memorizzato, senza TIA e senza PLCSim, e fa fallire la build in caso di modifica incompatibile
version- File di licenza necessario
- No
- Cosa fa
- Stampa la versione del runner, del suo motore, della build, di .NET e del sistema operativo, ad esempio per una richiesta di supporto
compare, trend, flaky e traceability leggono i risultati che run ha registrato sullo stesso agente con lo stesso utente Windows.
Opzioni per ogni verbo:
| Opzione | Significato |
|---|---|
--log-level <LEVEL> | Quanto registra il runner nel log: Verbose, Debug, Information, Warning (predefinito), Error o Fatal. Le righe di log vanno nell'output degli errori, così l'output normale contiene solo i risultati. |
--log-file <PATH> | Scrive il file di log in questo percorso invece che nel file di log giornaliero sotto %LocalAppData%\AnyAutomation\Logs (vengono conservati gli ultimi 14). |
--lang <LANGUAGE> | Lingua dei titoli della guida: en (predefinita), de, fr o it (l'italiano mostra l'inglese). I risultati sono sempre in inglese. |
--ansi, --no-ansi | Forza o disattiva l'output a colori. |
--license-offline <PATH> | Il file di licenza CI (vedi Licenza per la CI). |
Un livello di log o una lingua sconosciuti, --ansi e --no-ansi insieme, oppure un --log-file che non può essere scritto terminano con il codice di uscita 3.
Esecuzione dei test: run
Un'esecuzione tipica:
tia-test-runner run ^
--project "C:\Projects\Plant\Plant.ap20" ^
--out-dir "C:\Projects\Plant\.tia-tests\reports\ci" ^
--license-offline "C:\agent\anyautomation-ci.json"
Il runner trova le suite nella cartella .tia-tests accanto al file di progetto, apre il progetto TIA (senza finestra), esegue tutte le suite una dopo l'altra e scrive i report. Apre il progetto anche quando tutte le suite girano su OPC UA o S7 Native, quindi chiudi il progetto in Studio prima di avviare il runner sullo stesso computer.
Dove vanno i report. I report finiscono sempre in una cartella all'interno di .tia-tests\reports della cartella di progetto. Un --out-dir relativo viene calcolato a partire da quella cartella, quindi --out-dir ci scrive in .tia-tests\reports\ci accanto al file di progetto, ovunque venga eseguito il comando. Un percorso assoluto deve trovarsi all'interno di .tia-tests\reports; qualsiasi altra cartella termina l'esecuzione con il codice di uscita 3 prima che i test inizino. Una cartella lungo il percorso che è un collegamento o una junction verso un altro posto viene rifiutata allo stesso modo.
Opzioni di run:
| Opzione | Significato |
|---|---|
--project <PATH> | File di progetto TIA (ad esempio .ap20) o un progetto CODESYS salvato (.project). Obbligatorio, a meno che non lo imposti il file di configurazione. Un percorso di rete (\server...) non è accettato. |
--out-dir <PATH> | Cartella per i report all'interno di .tia-tests\reports della cartella di progetto; un percorso relativo viene calcolato da lì (vedi sopra). Obbligatoria, a meno che non la imposti il file di configurazione. |
--suite-filter <PATTERN> | Esegue solo le suite il cui nome file (senza .json) corrisponde al modello. * sta per qualsiasi testo, ? per un carattere, tutto il resto è preso alla lettera, maiuscole e minuscole sono equivalenti. Se nessuna suite corrisponde, termina con il codice di uscita 3. |
--plc <NAME> | Esegue solo le suite di questo PLC (maiuscole e minuscole sono equivalenti). Se non c'è alcuna suite di questo PLC, termina con il codice di uscita 3. --rerun-affected controlla le modifiche di questo PLC. |
--tag <TAG> | Esegue solo i casi di test che portano questo tag (ripetibile, uno qualsiasi dei valori, maiuscole e minuscole sono equivalenti, al massimo 256). I tag di un caso theory valgono per tutte le sue righe di parametri. |
--priority-min <LEVEL> | Esegue solo i casi di test con almeno questa priorità: Low, Normal, High o Critical. Qualsiasi altro valore termina con il codice di uscita 3. |
--owner <NAME> | Esegue solo i casi di test di questo responsabile (maiuscole e minuscole sono equivalenti). |
--rerun-affected | Esegue solo le suite il cui blocco è cambiato dall'ultima esecuzione in cui tutto è stato superato. Richiede --plc, sulla riga di comando o nel file di configurazione; senza, l'esecuzione termina con il codice di uscita 3. Se non è cambiato nulla, l'esecuzione termina con il codice di uscita 0. Solo progetti TIA. |
--report-format <FORMAT> | junit, html o cobertura, ripetibile, al massimo 16. Predefinito: JUnit e HTML. Con la copertura, Cobertura viene aggiunto automaticamente. |
--brand-title <TEXT>, --brand-footer <TEXT>, --brand-color <#RRGGBB>, --brand-logo <PATH> | Titolo, piè di pagina, colore principale e logo del report HTML. Il logo deve essere un file PNG, JPG o SVG di al massimo 500 KB; un logo mancante o inutilizzabile termina l'esecuzione con il codice di uscita 2 prima che venga eseguita la prima suite. Un colore non scritto come #RRGGBB viene ignorato. |
--report-classname-pattern <PATTERN> | Classname del report JUnit (vedi Classname dei report più sotto). |
--fail-fast | Si ferma al primo caso di test non superato: i casi restanti di quella suite vengono riportati come saltati con il nome del caso non superato e le suite successive non vengono eseguite. Anche una suite che non può essere eseguita ferma l'esecuzione. In una suite CODESYS l'esecuzione si ferma dopo la suite, perché i suoi casi girano come un unico programma. |
--timeout-minutes <N> | Limite di tempo dell'intera esecuzione, da 1 a 10080 (una settimana). Predefinito 60. Raggiungerlo termina l'esecuzione con il codice di uscita 4. |
--cycle-wait-ms <MS> | Attesa di ciclo di ogni suite in millisecondi, da 0 a 3600000, invece del valore salvato nella suite. In passo-passo è il tempo di ciclo fisso di ogni scansione, da 1 a 6000. |
--cycle-mode <MODE> | timed o single-step per le suite su PLCSim Advanced, invece dell'impostazione salvata nella suite (vedi Controllo del ciclo passo-passo). Una suite che non può essere eseguita in passo-passo, ad esempio una suite OPC UA o una in modalità di test isolata, ferma l'esecuzione con il codice di uscita 3. Una suite la cui istanza PLCSim è occupata da un'altra esecuzione passo-passo non viene eseguita e conta come errore; l'esecuzione prosegue con la suite successiva. |
--attach | Si collega a un TIA Portal già in esecuzione invece di aprire il file di progetto. Solo progetti TIA. |
--show-ui | Apre TIA Portal con la finestra visibile invece che senza finestra. Utile per seguire un'esecuzione durante il debug in locale. Solo progetti TIA. |
--update-snapshots | Registra di nuovo le baseline degli snapshot invece di confrontarle. Non disponibile per le suite S7 Native (codice di uscita 3). |
--opcua-password <VALUE> | Password per una suite OPC UA con accesso tramite nome utente (mai registrata nel log). In alternativa usa la variabile d'ambiente ANYAUTOMATION_OPCUA_PASSWORD. |
--s7-password <VALUE> | Password per una suite S7 Native con password (mai registrata nel log). In alternativa usa la variabile d'ambiente ANYAUTOMATION_S7_PASSWORD. |
--codesys-password <VALUE> | Password dell'utente runtime di una suite CODESYS (mai registrata nel log). In alternativa usa la variabile d'ambiente ANYAUTOMATION_CODESYS_PASSWORD. Non serve nella simulazione CODESYS. |
--quarantine | Declassa un caso non superato a un salto non bloccante quando è stato instabile nelle esecuzioni recenti, così un errore instabile non rompe la build (vedi Test instabili e quarantena). |
--quarantine-window <N> | Quante esecuzioni recenti esaminare per rilevare l'instabilità (predefinito 10). |
--quarantine-min-flips <N> | Numero minimo di cambi tra superato e non superato in quella finestra perché un caso conti come instabile (predefinito 1). |
--flaky-confirm | Esegue ancora una volta un caso instabile non superato; se il secondo tentativo riesce, il caso conta come superato. |
--retry-max <N> | Quante volte ripetere una suite dopo un errore di infrastruttura come una connessione persa (0 lo disattiva; predefinito 3). |
--retry-delay-ms <MS> | Attesa tra questi tentativi in millisecondi (predefinito 5000). |
--coverage | Misura la copertura dei requisiti, dell'interfaccia e dei blocchi chiamati, scrive un report Cobertura e stampa una tabella di copertura per suite. Solo progetti TIA. |
--coverage-min-requirement <PCT>, --coverage-min-interface <PCT>, --coverage-min-called-block <PCT> | Copertura minima in percentuale (da 0 a 100). Impostarne una attiva --coverage. Un valore sotto il minimo termina l'esecuzione con il codice di uscita 7, se non è fallito nient'altro. |
--ci-env-capture | Registra nei report i dettagli del job CI (vedi Acquisizione dei dettagli dell'ambiente CI). |
--skip-version-check | Salta il controllo della versione di TIA Portal. |
--config <PATH> | Legge i valori predefiniti da un file di configurazione (vedi File di configurazione YAML più sotto). |
Una suite che richiede una password non fornita né dall'opzione né dalla variabile d'ambiente termina l'esecuzione con il codice di uscita 3.
Switch. Uno switch come --fail-fast, --coverage o --quarantine può anche ricevere true o false, ad esempio --fail-fast false. Così si disattiva un'impostazione che il file di configurazione attiva.
Filtrare i casi di test. --tag, --priority-min e --owner usano i tag, la priorità e il responsabile che imposti sui casi di test (vedi Metadati dei casi di test) e si combinano: un caso deve soddisfarli tutti. Gli altri casi vengono riportati come saltati. Una suite in cui nessun caso corrisponde viene saltata per intero, con una riga Skipped <suite>: no test case matches the case filters., e non scrive alcun report. Se nessun caso di nessuna suite corrisponde, l'esecuzione termina con il codice di uscita 3 prima che i test inizino, così un filtro scritto male non può far passare una build.
Suite CODESYS sul server di build. Passa il progetto CODESYS salvato con --project (ad esempio --project "C:\Projects\Line\Line.project") e tieni le sue suite nella cartella .tia-tests accanto. Ogni suite gira sul target salvato in essa: nella simulazione CODESYS, che non richiede alcun dispositivo né runtime, oppure su CODESYS Control Win sul server di build. Metti --out-dir sotto .tia-tests\reports della cartella di progetto, come per TIA. Le opzioni di copertura, --attach, --show-ui e --rerun-affected valgono solo per i progetti TIA e terminano un'esecuzione CODESYS con il codice di uscita 3.
Cosa stampa l'esecuzione. Una riga per suite ([1/3] Running ...), le tabelle di copertura quando richieste, una tabella di ogni caso messo in quarantena e una riga di riepilogo con i conteggi di superati, non superati, in errore, saltati e in quarantena e il codice di uscita. Un caso in quarantena viene sempre elencato, mai nascosto.
Cosa scrive l'esecuzione. L'esecuzione più recente si trova sempre al livello superiore di --out-dir: junit.xml per il reporter di test della tua CI, il report HTML autonomo e personalizzato report.html, cobertura.xml quando è stata richiesta la copertura, un riepilogo summary.json e i file di integrità manifest.json e checksums.txt. Ogni esecuzione precedente si sposta in una propria sottocartella sotto runs con il proprio manifest e, non appena la cartella contiene più di un'esecuzione, aggregate-summary.json le conta tutte. Con più suite in una sola chiamata, i file al livello superiore appartengono all'ultima suite, quindi pubblica **/junit.xml per ottenere tutte le suite. L'id di esecuzione che serve a compare è la voce run_id in manifest.json o summary.json.
Codici di uscita di run (il contratto con la pipeline):
| Codice | Significato |
|---|---|
0 | Tutti i test superati (anche quando --rerun-affected non ha trovato nulla da eseguire) |
1 | Almeno un caso di test non è stato superato o è terminato con un errore |
2 | Errore di esecuzione: nessuna licenza valida, impossibile aprire TIA o il progetto, un'altra esecuzione usa la stessa cartella dei report, una suite non ha potuto essere eseguita, impossibile scrivere i report, PLCSim si è fermato tre volte di seguito, una versione di TIA non supportata (a meno di --skip-version-check), un logo di branding inutilizzabile |
3 | Errore di argomento o di configurazione: un'opzione mancante o errata, un file di configurazione illeggibile, una cartella dei report fuori da .tia-tests\reports, nessuna suite corrispondente, nessuna suite del --plc, --rerun-affected senza --plc, nessun caso di test che corrisponda ai filtri sui casi, un file di suite non valido, una suite che non può essere eseguita come richiesto |
4 | È stato raggiunto il limite di tempo di --timeout-minutes |
5 | Annullato con Ctrl+C (un secondo Ctrl+C termina subito il runner) |
7 | Copertura sotto un valore --coverage-min-... |
Controllare le suite senza eseguirle: validate
tia-test-runner validate --project "C:\Projects\Plant\Plant.ap20" --config "C:\Projects\Plant\runner.yaml"
| Opzione | Significato |
|---|---|
--project <PATH> | Il file di progetto TIA, il progetto CODESYS salvato o la cartella di progetto. Obbligatorio. |
--suite-filter <PATTERN> | Controlla solo le suite corrispondenti, come per run. |
--config <PATH> | Controlla anche il formato del file di configurazione, con un avviso per ogni chiave sconosciuta (vedi File di configurazione YAML). |
Ogni problema viene stampato con file, riga e un breve codice, gli avvisi contrassegnati con WARNING, poi una riga come 3 suites OK, config OK. Non viene scritto nulla e non serve alcun file di licenza, quindi è adatto a un hook pre-commit. Codici di uscita: 0 nessun errore (avvisi ammessi), 3 un errore, un percorso errato o nessuna suite trovata quando non è indicato --config, 5 Ctrl+C.
Controllare i report archiviati: verify
tia-test-runner verify --manifest "C:\Projects\Plant\.tia-tests\reports\ci\manifest.json"
--manifest <PATH> (obbligatorio) indica il manifest.json di una cartella dei report. Il runner ricalcola il checksum di ogni file elencato e stampa Integrity OK (n files) oppure l'elenco dei file modificati o mancanti, e l'approvazione dell'esecuzione con una nota se i dettagli dell'approvazione sono stati modificati in seguito. Il controllo mostra che i file non sono cambiati da quando l'esecuzione li ha scritti; è un elenco di checksum, non una firma, quindi non mostra chi li ha scritti. Codici di uscita: 0 invariati, 1 file modificati o mancanti oppure approvazione modificata, 2 il manifest manca o non può essere letto, 3 un percorso errato, 5 Ctrl+C. Non serve alcun file di licenza, quindi i verbali di collaudo archiviati possono essere controllati anche anni dopo.
Confrontare due esecuzioni: compare
tia-test-runner compare ^
--baseline 3f2a9c1e-0b6d-4d1e-9a51-2c7e8f4b6a10 ^
--current 8c41d7b2-5e93-4a0f-b2c6-91d3e7a5f024 ^
--out-dir "C:\Projects\Plant\compare"
--baseline e --current sono id di esecuzione (il run_id del manifest.json o del summary.json di ciascuna esecuzione, in maiuscolo o minuscolo, con o senza parentesi graffe); --out-dir è la cartella per il report. Il runner scrive compare-<first 8 characters of the baseline id>-<first 8 of the current id>.html con i propri manifest.json e checksums.txt e stampa i conteggi di regressioni, casi corretti, nuovi e rimossi. verify controlla la cartella come qualsiasi cartella dei report. Usa una cartella dedicata: una cartella che contiene già un altro report, ad esempio i report di un'esecuzione, viene rifiutata con il codice di uscita 3 e il messaggio suggerisce una cartella compare al suo interno. Viene rifiutata anche una cartella scritta da compare di una versione precedente; scegline una nuova. Le regressioni non fanno fallire il passaggio; il codice di uscita è 0 ogni volta che il report è stato scritto, 2 quando un id di esecuzione è sconosciuto o il report non ha potuto essere scritto, 3 per un id che non è un id di esecuzione valido o un percorso errato, 5 per Ctrl+C.
Cronologia superato/non superato come CSV: trend
tia-test-runner trend --plc PLC_1 --suite FB_Motor --from 2026-10-01 --to 2026-11-01 --out-file trend.csv
| Opzione | Significato |
|---|---|
--plc <NAME> | Il PLC di cui vengono esportate le esecuzioni. Obbligatorio. |
--suite <NAME> | Esporta la cronologia di questa suite invece dell'intero PLC. |
--case <NAME> | Esporta il risultato di questo caso in ogni esecuzione (richiede --suite). |
--from <DATE> | Primo momento incluso, ad esempio 2026-10-01 o 2026-10-01T06:00:00. Senza, l'intera cronologia. |
--to <DATE> | Ultimo momento incluso, predefinito adesso. Una data da sola include l'intera giornata, quindi --to 2026-11-01 termina con l'ultima esecuzione del 1° novembre; un orario include le esecuzioni iniziate in quel momento. Gli orari senza fuso orario valgono come UTC. |
--out-file <PATH> | Il file CSV. Obbligatorio. |
Il CSV ha una riga per esecuzione con la percentuale di superamento, i conteggi dei casi superati, non superati, in errore e saltati e la durata; per un caso, una riga per esecuzione con il suo risultato (PASS, FAIL, ERROR, SKIP o NOT_RUN). Codici di uscita: 0 scritto, 2 la cronologia non ha potuto essere letta o il file non ha potuto essere scritto, 3 un'opzione errata, 5 Ctrl+C.
Controllo del contratto delle interfacce dei blocchi: check-contracts
tia-test-runner check-contracts --project "C:\Projects\Plant\Plant.ap20"
| Opzione | Significato |
|---|---|
--project <PATH> | Il file di progetto TIA, il progetto CODESYS salvato o la cartella di progetto. Obbligatorio. Una cartella di progetto che non esiste termina con il codice di uscita 3. |
--suite-filter <PATTERN> | Controlla solo le suite corrispondenti, come per run. |
--approve-contracts | Registra le interfacce attuali come nuovi contratti invece di confrontare. |
Per ogni suite il runner legge il file del blocco esportato dalla cartella di esportazione salvata nella suite (una cartella di esportazione relativa viene letta dalla cartella di progetto), confronta la sua interfaccia con il contratto memorizzato della suite e stampa una tabella Contract drift delle modifiche incompatibili. Una suite senza contratto memorizzato ne riceve uno al primo controllo. Codici di uscita: 0 nessuna modifica incompatibile, una prima acquisizione o --approve-contracts, 8 una modifica incompatibile, 3 un percorso errato, nessuna suite, un file di suite non valido o un blocco non esportato, 2 nessuna licenza valida, 5 Ctrl+C.
Informazioni sulla versione: version
tia-test-runner version stampa la versione del runner, del suo motore, della connessione TIA installata con esso (riga Bridge, "not found next to the runner" quando manca), della build, di .NET e del sistema operativo. Non richiede alcun file di licenza e non avvia nulla.
Gate di tracciabilità dei requisiti
tia-test-runner traceability controlla la tracciabilità dei requisiti sull'agente di build e fa fallire la pipeline quando ci sono requisiti non superati o senza test. Legge i risultati dei test che il verbo run ha registrato sullo stesso agente e l'elenco dei requisiti della cartella dei test, se esiste.
tia-test-runner traceability ^
--project "C:\Projects\Plant\Plant.ap20" ^
--runs-from "C:\Projects\Plant\.tia-tests\reports\ci" ^
--out-dir "C:\Projects\Plant\.tia-tests\reports\ci\traceability" ^
--fail-on failed,uncovered
| Flag | Significato |
|---|---|
--project <PATH> | File di progetto TIA Portal o la sua cartella. Obbligatorio. |
--runs-from <DIR> | Usa solo le esecuzioni i cui report si trovano in questa cartella, normalmente il --out-dir del passaggio run precedente. Un percorso relativo viene calcolato da .tia-tests\reports della cartella di progetto, come il --out-dir di run; un percorso assoluto può puntare ovunque, ad esempio ai report di esecuzione scaricati da un job CI. Consigliato: senza, potrebbe contare un risultato registrato da un'altra pipeline o da un altro branch sullo stesso agente. |
--fail-on <LIST> | Quali stati dei requisiti fanno fallire la build: uno qualsiasi tra failed, uncovered, notRun, outdated, incomplete oppure none. Predefinito failed,uncovered. outdated copre anche i requisiti la cui ultima esecuzione è stata registrata prima che le modifiche potessero essere rilevate. |
--requirements <PATH> | Un elenco dei requisiti da usare al posto di quello della cartella dei test, ad esempio un elenco esportato dal tuo strumento ALM durante la build. |
--suite-filter <PATTERN> | Controlla solo le suite il cui nome file corrisponde al modello, le stesse suite che run --suite-filter esegue (ad esempio Conveyor*). I requisiti citati solo dalle altre suite vengono esclusi; i requisiti del tuo elenco che nessuna suite cita contano comunque come non testati. |
--run-window <N> | Quante delle ultime esecuzioni di ogni suite considerare (da 1 a 100, predefinito 20). |
--format <text|json> | Output come tabella (predefinito) o come JSON. Con json, l'output standard contiene solo il documento JSON, così uno script può leggerlo direttamente. |
--json-file <PATH> | Scrive il documento JSON anche in un file. |
--out-dir <DIR> | Scrive il report HTML di tracciabilità e il suo manifest di integrità in questa cartella. Usa una cartella dedicata, ad esempio traceability all'interno della cartella dei report dell'esecuzione, non la cartella di un report di esecuzione stesso. Come per run, la cartella si trova all'interno di .tia-tests\reports della cartella di progetto e un percorso relativo viene calcolato da lì; qualsiasi altra cartella termina il gate con il codice di uscita 3. |
--brand-title, --brand-footer, --brand-color, --brand-logo | Branding del report HTML, come per run. |
La tabella elenca ogni requisito con il suo stato, il numero di casi di test, l'evidenza più recente e il titolo, seguiti da un riepilogo come "12 requirements: 1 failed, 2 uncovered, 0 not verified". Oltre ai codici di uscita di run, il verbo restituisce:
| Codice | Significato |
|---|---|
1 | Un requisito non è stato superato (quando failed è in --fail-on) |
3 | Problema di input: ad esempio un errore nell'elenco dei requisiti, un file di suite che non può essere letto, un --suite-filter che non corrisponde a nessuna suite o nessun report di esecuzione nella cartella --runs-from |
9 | Un requisito non ha alcun caso di test (quando uncovered è in --fail-on) |
10 | Un requisito non è verificato: non eseguito, obsoleto o incompleto (quando scelto in --fail-on) |
Restituisce 2 anche quando i risultati non possono essere letti, il report non può essere scritto o manca il file di licenza, e 5 per Ctrl+C. Gli avvisi sull'elenco dei requisiti vengono stampati ma non fanno mai fallire la build. Come run, il verbo richiede il file di licenza CI.
Test instabili e quarantena
Un test instabile (flaky) è un test che in alcune esecuzioni viene superato e in altre no senza che il blocco in test sia effettivamente cambiato, di solito per un effetto di temporizzazione o dell'ambiente. Per vedere quali casi di una suite sono instabili nella sua cronologia recente:
tia-test-runner flaky --suite-file "C:\Projects\Plant\.tia-tests\FB_Motor.json" --out-file flaky.csv
Stampa una tabella di ogni caso instabile con quante volte ha alternato tra superato e non superato e la sua sequenza di risultati recenti, separata da virgole, ad esempio Pass, Fail, Pass. Aggiungi --window <N> per cambiare quante esecuzioni recenti vengono esaminate (predefinito 10, al massimo 1000) e --out-file <CSV> per scrivere l'elenco anche come CSV con le colonne Case, FlipCount e RecentStatuses. Quando nessun caso è instabile, il runner stampa "No flaky tests in the last N runs." e scrive comunque il CSV, con la sola riga di intestazione, così un file di una chiamata precedente viene sostituito. Un --window superiore a 1000 legge le ultime 1000 esecuzioni. I casi instabili non fanno mai fallire il passaggio: il codice di uscita è 0 a meno che la cronologia non possa essere letta o il file non possa essere scritto (2) o il percorso --out-file sia errato (3). Indica --suite-file esattamente come il percorso della suite con cui sono state registrate le esecuzioni.
Aggiungi --quarantine a un run per evitare che gli errori instabili rompano la build: un caso che non viene superato nell'esecuzione attuale ma è stato instabile nella cronologia recente viene declassato a un salto non bloccante e riportato come quarantined (flaky) nell'output JUnit e nel riepilogo dell'esecuzione, mentre gli errori reali e stabili fanno ancora fallire la build. Regolalo con --quarantine-window e --quarantine-min-flips. In Studio, la quarantena è l'opzione Metti in quarantena i casi instabili di Esegui (vedi Opzioni di esecuzione). La quarantena non nasconde mai un caso declassato: ognuno viene elencato prima del riepilogo dell'esecuzione.
Classname dei report
Per impostazione predefinita, i valori JUnit classname seguono il modello {PlcName}.{BlockName}, che la maggior parte dei visualizzatori di test CI raggruppa in un albero leggibile. Sostituiscilo con --report-classname-pattern usando qualsiasi combinazione di questi segnaposto:
{PlcName}: il nome del PLC/della CPU{BlockName}: il blocco in test{SuiteName}: il nome della suite di test{ProjectName}: il nome del progetto
Esempio: --report-classname-pattern "{ProjectName}/{PlcName}/{SuiteName}".
Acquisizione dei dettagli dell'ambiente CI
Passa --ci-env-capture per registrare un piccolo insieme fisso di variabili CI nella provenienza dell'esecuzione, così i report mostrano quale pipeline, quale commit e quale agente hanno prodotto ciascuna esecuzione. L'acquisizione è opt-in: non viene registrato nulla se non lo richiedi. Lo strumento riconosce GitHub Actions, Jenkins, Azure DevOps e GitLab CI (e un marcatore generico CI); viene letto solo un insieme consentito di identificatori (ID di esecuzione/build, SHA del commit, branch/ref, nome del workflow/job, nome dell'agente/runner), ciascuno troncato a una lunghezza sicura.
File di configurazione YAML
Per tenere le righe di comando lunghe fuori dalla tua pipeline, metti i valori predefiniti di run in un file YAML e passa --config <PATH>. La pagina Pipeline CI di Studio scrive un file di questo tipo come runner.yaml. Esempio:
project: C:\Projects\Plant\Plant.ap20
out_dir: C:\Projects\Plant\.tia-tests\reports\ci
suite_filter: FB_*
report_formats:
- junit
- html
timeout_minutes: 45
cycle_mode: single-step
ci_env_capture: true
Chiavi. Ogni chiave è il nome di un'opzione di run senza i trattini iniziali e con trattini bassi al posto dei trattini: project, out_dir, suite_filter, tags (elenco, per --tag), plc, rerun_affected, priority_min, owner, report_formats (elenco, per --report-format), brand_title, brand_footer, brand_color, brand_logo, report_classname_pattern, fail_fast, timeout_minutes, cycle_wait_ms, cycle_mode, attach, show_ui, ci_env_capture, skip_version_check, quarantine, quarantine_window, quarantine_min_flips, flaky_confirm, retry_max, retry_delay_ms, coverage, coverage_min_requirement, coverage_min_interface, coverage_min_called_block. Solo sulla riga di comando: le password, --update-snapshots, --license-offline e le opzioni per ogni verbo. Sulla riga di comando --cycle-mode ignora maiuscole e minuscole, ma nel file cycle_mode deve essere scritto esattamente timed o single-step; qualsiasi altra grafia termina con il codice di uscita 3.
Una chiave scritta male viene segnalata e ignorata.
runevalidate --configstampano un avviso per ogni chiave che non conoscono e indicano la chiave corretta più vicina, ad esempio "Unknown runner-config key 'reportformat', did you mean 'reportformats'? The key is ignored." L'esecuzione prosegue.
Quale valore prevale:
- Un valore sulla riga di comando prevale sul file, e il file prevale sull'impostazione salvata nella suite (per
cycle_wait_msecycle_mode). - Un elenco sulla riga di comando (
--tag,--report-format) sostituisce l'elenco del file. - Anche uno switch sulla riga di comando prevale:
--fail-fast falsedisattivafail_fast: truedel file. --timeout-minutessulla riga di comando prevale sempre, anche con il valore 60.- Un
projectobrand_logorelativo nel file viene letto dalla cartella del file, unout_dirrelativo da.tia-tests\reportsdella cartella di progetto. Gli altri percorsi relativi sulla riga di comando, come--projecto--brand-logo, vengono letti dalla cartella corrente del comando;--out-dirviene sempre letto da.tia-tests\reports.
Un file che non è YAML valido, è troppo grande o contiene un valore del tipo sbagliato termina con il codice di uscita 3.
Jenkins (pipeline dichiarativa)
pipeline {
agent { label 'tia-windows' }
stages {
stage('Checkout') {
steps { checkout scm }
}
stage('Unit Tests') {
steps {
bat 'tia-test-runner run --project "%WORKSPACE%\\Plant.ap20" --out-dir "%WORKSPACE%\\.tia-tests\\reports\\ci" --ci-env-capture'
}
}
}
post {
always {
junit '.tia-tests/reports/ci/**/junit.xml'
archiveArtifacts artifacts: '.tia-tests/reports/ci/**/*.html', allowEmptyArchive: true
}
}
}
GitHub Actions
name: TIA Unit Tests
on: [push]
jobs:
unit-tests:
runs-on: [self-hosted, windows, tia]
steps:
- uses: actions/checkout@v4
- name: Run SCL unit tests
run: tia-test-runner run --project "${{ github.workspace }}\Plant.ap20" --out-dir "${{ github.workspace }}\.tia-tests\reports\ci" --ci-env-capture
- name: Publish test report
if: always()
uses: dorny/test-reporter@v1
with:
name: TIA Unit Tests
path: .tia-tests/reports/ci/**/junit.xml
reporter: java-junit
- name: Upload HTML report
if: always()
uses: actions/upload-artifact@v4
with:
name: tia-html-report
path: .tia-tests/reports/ci/**/*.html
Azure DevOps
pool:
name: tia-windows
steps:
- checkout: self
- script: tia-test-runner run --project "$(Build.SourcesDirectory)\Plant.ap20" --out-dir "$(Build.SourcesDirectory)\.tia-tests\reports\ci" --ci-env-capture
displayName: Run SCL unit tests
- task: PublishTestResults@2
condition: always()
inputs:
testResultsFormat: JUnit
testResultsFiles: '$(Build.SourcesDirectory)/.tia-tests/reports/ci/**/junit.xml'
testRunTitle: TIA Unit Tests
- publish: $(Build.SourcesDirectory)\.tia-tests\reports\ci
artifact: tia-html-report
condition: always()
GitLab CI
unit-tests:
tags: [tia-windows]
script:
- tia-test-runner run --project "$CI_PROJECT_DIR\Plant.ap20" --out-dir "$CI_PROJECT_DIR\.tia-tests\reports\ci" --ci-env-capture
artifacts:
when: always
paths:
- .tia-tests/reports/ci/
reports:
junit: .tia-tests/reports/ci/**/junit.xml
Generare una pipeline CI/CD dall'app
Invece di scrivere a mano i file di configurazione, lascia che li generi AnyAutomation Studio. Studio produce due file pronti per il commit per un progetto TIA: un runner.yaml che contiene i valori predefiniti della riga di comando e un file di pipeline per il sistema CI che scegli. Li configuri nella pagina Pipeline CI, che mostra i file finiti mentre compili il modulo.
Apri la pagina. Esegui Genera pipeline CI dal riquadro comandi, dal menu … della vista Esplora unit test o dal menu … del Test Bench. La pagina si apre per il progetto TIA a cui sei connesso. Senza connessione, Studio ti chiede prima di scegliere il file di progetto. Ogni progetto ha la propria pagina, intitolata Pipeline CI: <progetto>; eseguendo di nuovo il comando torni a essa.
Compila il modulo. La parte sinistra della pagina ha queste sezioni:
| Sezione | Cosa imposti |
|---|---|
| Progetto | Il file di progetto (mostrato, non modificabile), una Cartella del repository facoltativa (vedi sotto), il Nome PLC (mentre sei connesso al progetto, il campo suggerisce i suoi PLC e inserisce il primo quando è vuoto), un Filtro suite facoltativo, Attesa ciclo (ms), Controllo del ciclo (Impostazione della suite, Temporizzato o Passo-passo; Passo-passo vale per le suite su PLCSim Advanced, rende l'attesa di ciclo il tempo di ciclo fisso di ogni scansione, da 1 a 6000 ms, e fa fallire l'esecuzione per una suite su un altro trasporto) e Acquisisci ambiente CI. |
| Report | Report HTML e XML JUnit (almeno uno), la Cartella di output dei report all'interno della cartella dei report del progetto .tia-tests\reports (vuota significa tia-test-results; la pipeline pubblica i report da lì), il Modello nome classe e, sotto Branding, Titolo, Piè di pagina e Colore principale del report HTML. |
| Destinazione CI | Il sistema CI: GitHub Actions, GitLab CI, Azure DevOps o Jenkins, e un'Etichetta dell'agente facoltativa che sceglie l'agente di build (vedi la nota sugli agenti di build più sotto). |
| Trigger | Branch di push e Branch di pull request facoltativi (separati da virgole) e una Pianificazione (cron). Lascia vuoti tutti e tre per avviare la pipeline a mano. |
| Matrice di build | Celle parallele facoltative, vedi Matrice di build più sotto. |
| Copertura | Pubblica la copertura e tre percentuali minime facoltative, che puoi compilare mentre Pubblica la copertura è attivo. Fallisci con requisiti non riusciti o non coperti aggiunge un passaggio dopo l'esecuzione dei test che controlla la tracciabilità dei requisiti rispetto a questa esecuzione, conserva il report di tracciabilità insieme agli altri report e fa fallire la build; sotto Fallisci con scegli quali stati dei requisiti la fanno fallire (Failed e Uncovered per impostazione predefinita). Con un filtro suite, il controllo copre le stesse suite dell'esecuzione dei test. |
| Runner CI | Se il runner da riga di comando è installato su questo computer, e Salva il file di licenza CI (vedi Licenza per la CI). |
Un campo con un problema viene evidenziato e spiega cosa cambiare, ad esempio "Enter the PLC name." o "A cell with this name already exists."; la riga in fondo alla pagina ripete il primo problema.
Guarda i file. La parte destra della pagina mostra i file generati. Fai clic su un nome file sopra il testo, oppure usa i tasti freccia sinistra e destra, per passare tra runner.yaml e il file di pipeline. I file si aggiornano circa mezzo secondo dopo che smetti di digitare. Finché un campo ha un problema, l'anteprima mostra invece "Complete the highlighted fields to preview the files.". Trascina il divisore tra modulo e anteprima per dare più spazio a uno dei due lati.
Scrivi i file.
- Anteprima come file senza titolo apre entrambi i file come editor non salvati, così puoi copiarli o salvarli altrove.
- Scrivi file salva il
runner.yamlnella cartella di progetto e il file di pipeline nella cartella del repository (la cartella di progetto quando Cartella del repository è vuota). Se uno di essi esiste già, una sola domanda elenca tutto ciò che verrebbe sostituito; Annulla non scrive nulla.
Entrambi i pulsanti sono disponibili solo finché il modulo non ha problemi. Un campo non può contenere ${{ o $(, perché il tuo sistema CI li valuterebbe, e la Pianificazione (cron) richiede cinque campi (minuto, ora, giorno del mese, mese, giorno della settimana); il messaggio sotto il campo ti dice cosa cambiare. Il runner.yaml viene scritto nella cartella di progetto e il file di pipeline nel percorso che il suo sistema CI si aspetta nella cartella del repository: .github/workflows/tia-tests.yml per GitHub Actions, Jenkinsfile per Jenkins, azure-pipelines.yml per Azure DevOps e .gitlab-ci.yml per GitLab CI. Esegui il commit di entrambi i file.
Dove inizia il tuo repository. La pipeline indica il file di progetto, il runner.yaml e le cartelle dei report in modo relativo alla cartella che l'agente di build estrae con il checkout. Quando il tuo repository inizia dalla cartella di progetto, lascia vuota Cartella del repository. Quando la cartella di progetto si trova più in profondità, ad esempio come cartella MixingPlant del repository, inserisci il percorso completo della cartella principale del repository sul tuo computer: il file di pipeline va lì e i suoi percorsi partono da lì (MixingPlant/MixingPlant.ap20). Una cartella che non contiene la cartella di progetto, o un percorso senza unità, mostra un messaggio sotto il campo e i file non possono essere scritti.
Le tue impostazioni restano. Puoi chiudere la pagina in qualsiasi momento senza perdere nulla: Studio ricorda il modulo per ogni progetto e lo mostra di nuovo la prossima volta che apri la pagina, anche dopo un riavvio. Una pagina aperta alla chiusura di Studio si riapre con esso. Quando sei connesso a un progetto diverso da quello della pagina, una riga in alto riporta "This page belongs to <project file>."; la pagina continua a scrivere nella propria cartella di progetto.
Quando viene eseguita la pipeline. Per impostazione predefinita la pipeline generata viene eseguita su richiesta: avviala manualmente dal tuo sistema CI ogni volta che vuoi testare. Compila Trigger per eseguirla anche automaticamente a ogni push o pull request verso i branch elencati, oppure secondo una pianificazione cron per le esecuzioni notturne. (Per GitLab la pianificazione stessa si imposta nella schermata delle pianificazioni della pipeline di GitLab; per Jenkins, le esecuzioni su push e pull request arrivano dal webhook del tuo repository.)
La pipeline deve essere eseguita su un agente di build Windows self-hosted. I test pilotano TIA Portal e PLCSIM, quindi la macchina che esegue la pipeline richiede TIA Portal installato, PLCSIM disponibile e una licenza Pro+ o superiore attiva. I runner ospitati nel cloud non possono eseguire i test. Per questo la pipeline generata richiede un agente Windows self-hosted: su GitHub Actions un runner con le etichette
self-hostedeWindows, su Azure DevOps un agente Windows del poolDefault, su GitLab CI un runner con il tagwindows, su Jenkins un agente con l'etichettawindows. Inserisci un'Etichetta dell'agente nella pagina per usare al suo posto la tua etichetta, il tuo pool o il tuo tag.
L'agente ha bisogno di bash. Il passaggio di test delle pipeline GitHub Actions, GitLab CI, Azure DevOps e Jenkins generate viene eseguito in bash, quindi un agente di build Windows richiede Git Bash installato e nel
PATH; un runner GitLab può mantenere la sua shell PowerShell. Un file di pipeline generato con una versione precedente continua a funzionare così com'è finché non lo generi di nuovo.
Matrice di build
Aggiungi una o più celle con Aggiungi cella nell'intestazione della sezione Matrice di build e ogni cella esegue le tue suite di test come job separato e parallelo nella pipeline generata. Usala per testare le stesse suite su più progetti, o per dividere un grande insieme di suite in parti parallele, così l'intera esecuzione CI termina prima e riporta ogni cella separatamente.
Ogni cella è una riga della tabella:
- Nome (obbligatorio): un'etichetta breve con lettere, cifre,
_o-, univoca all'interno della matrice. Una nuova cella inizia con un nome libero comecell1. - File di progetto (facoltativo): lascialo vuoto per usare il progetto della pagina, oppure indirizza la cella a un altro file di progetto. Indicalo in modo relativo alla cartella del repository (la cartella di progetto della pagina quando Cartella del repository è vuota), ad esempio
Cells/A/A.ap20; un percorso completo deve trovarsi in quella cartella o sotto di essa, altrimenti un messaggio sotto il campo lo segnala e i file non possono essere scritti. - Filtro suite (facoltativo): esegue solo alcune delle suite in quella cella. Lascialo vuoto per eseguirle tutte.
Rimuovi una cella con l'icona di rimozione alla fine della sua riga. Ogni cella scrive i risultati nella propria cartella dei report, quindi le celle non si sovrascrivono mai e puoi confrontarle fianco a fianco. La matrice di build è disponibile per tutti e quattro i sistemi CI. Lasciandola vuota si ottiene la normale pipeline a esecuzione singola.
Licenza per la CI
Il test di unità è una funzionalità Pro+ (Pro+ e superiori), quindi il runner controlla la tua licenza prima di fare qualsiasi lavoro. Un agente di build riceve la licenza tramite un file di licenza CI che salvi da Studio e consegni all'agente.
Salva il file. In Studio esegui Genera pipeline CI, fai clic su Salva il file di licenza CI nella sezione Runner CI della pagina Pipeline CI e scegli una posizione. Devi aver effettuato l'accesso con una licenza Pro+ attiva.
Consegnalo all'agente. Puoi mettere il file sull'agente e indicare al runner dove trovarlo:
tia-test-runner run --license-offline "C:\agent\anyautomation-ci.json" --project "C:\Projects\Plant\Plant.ap20" --out-dir "C:\Projects\Plant\.tia-tests\reports\ci"
oppure memorizza il contenuto del file come variabile di pipeline mascherata di nome ANYAUTOMATION_CI_ENTITLEMENT, esattamente come salvato oppure codificato in base64 (alcuni sistemi CI mascherano solo valori base64 su una sola riga). Il runner legge quella variabile quando non viene indicato alcun percorso.
Il percorso --license-offline deve puntare a un'unità locale dell'agente; un percorso di condivisione di rete (\server...) viene rifiutato. Se il file si trova su una condivisione, copialo sull'agente oppure usa invece la variabile.
Tratta il file come un segreto. Contiene il tuo diritto di licenza, quindi chiunque lo ottenga può eseguire i verbi soggetti a licenza. Memorizzalo come variabile mascherata o segreta, non stamparlo mai in un log di build e non eseguirne il commit nel tuo repository.
Il file smette di funzionare quando termina il tuo abbonamento e in ogni caso 90 giorni dopo che l'hai salvato. Salvane uno nuovo da Studio quando una pipeline segnala una licenza scaduta. Il file funziona su qualsiasi agente di build; il runner lo controlla sull'agente stesso e non richiede una connessione a internet per farlo.
--license-key non è più accettato e termina con il codice 3. Usa invece il file di licenza.
Questi verbi non richiedono un file di licenza: version, verify e validate. verify resta volutamente aperto, così puoi ricontrollare l'integrità di un verbale di collaudo archiviato anche anni dopo, anche dopo la fine di un abbonamento, e validate è un semplice controllo dello schema che puoi eseguire in un hook pre-commit.
Accesso alla rete
Il runner non contatta alcun server di licenze: controlla il file di licenza CI sull'agente, quindi non serve alcuna impostazione proxy per la licenza. Si connette solo a ciò che le tue suite indicano (TIA Portal e PLCSim sull'agente, il server OPC UA o il controller di una suite).
Ambienti supportati
Windows 11 (desktop)
- Supportato?
- Sì
- Note
- Ambiente di riferimento.
Windows Server 2022 con Esperienza desktop
- Supportato?
- Sì
- Note
- TIA Portal e PLCSIM Advanced richiedono una sessione desktop interattiva.
Windows Server Core
- Supportato?
- No
- Note
- TIA Portal Openness richiede la shell desktop completa; l'installazione headless di Server Core non la fornisce.
Docker / container Windows
- Supportato?
- No
- Note
- TIA Portal e PLCSIM Advanced non sono supportati all'interno dei container.
Problemi nelle esecuzioni CI
| Sintomo | Causa e soluzione |
|---|---|
Codice di uscita 3, "--project is required" | Manca un argomento obbligatorio oppure non è stato possibile leggere la configurazione YAML. Controlla i percorsi --project, --out-dir e --config. |
Codice di uscita 2, messaggio di licenza | L'agente non ha un file di licenza CI valido. Salvane uno nuovo da Studio e indica al runner dove trovarlo, oppure imposta la variabile mascherata ANYAUTOMATION_CI_ENTITLEMENT. |
Codice di uscita 3, "--out-dir resolves under a protected Windows directory" o "--out-dir must lie inside the reports folder ... of the project" | --out-dir punta fuori da .tia-tests\reports della cartella di progetto. Indica una cartella relativa come ci, che viene calcolata da lì. |
Codice di uscita 3, "No suites found for PLC ..." o "No test case of the selected suites matches the case filters" (nessun caso di test corrisponde ai filtri) | --plc, --tag, --priority-min o --owner non selezionano nulla. Controlla il nome PLC delle suite e i tag, la priorità e il responsabile dei casi di test. |
Codice di uscita 4, timeout | L'esecuzione ha superato --timeout-minutes. Aumenta il limite oppure dividi le suite grandi; controlla che la connessione al PLC sia raggiungibile dall'agente. |
| Nessun report di test appare nella CI | Il passaggio del reporter di test non punta a junit.xml, oppure viene eseguito solo in caso di successo. Pubblica i report con una condizione always()/when: always e puntalo a **/junit.xml sotto la cartella dei report dell'esecuzione. |
Privacy
La CLI e l'interfaccia utente non raccolgono alcuna telemetria. Le variabili CI riportate nei report vengono registrate solo quando lo scegli con --ci-env-capture, e i report non rivelano il percorso del progetto. I report HTML soddisfano WCAG 2.1 AA, verificato con controlli automatici; una verifica manuale con screen reader (NVDA) fa parte del passaggio end-to-end del rilascio.