Esercitazione: Testare una libreria di classi .NET

Questa esercitazione illustra come automatizzare gli unit test aggiungendo un progetto di test a una soluzione.

Prerequisiti

Questa esercitazione funziona con la soluzione creata in Creare una libreria di classi .NET.

Creare un progetto di unit test

Gli unit test forniscono test software automatizzati durante lo sviluppo e la pubblicazione. MSTest è uno dei tre framework di test tra cui è possibile scegliere. Gli altri sono xUnit e nUnit .

Avviare Visual Studio.
Aprire la soluzione ClassLibraryProjects creata in Creare una libreria di classi .NET.
Aggiungere alla soluzione un nuovo progetto di unit test denominato "StringLibraryTest".
1. Fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni e selezionare Aggiungi>Nuovo progetto.
2. Nella pagina Aggiungi un nuovo progetto immettere mstest nella casella di ricerca. Scegliere C# o Visual Basic dall'elenco Lingua e quindi scegliere Tutte le piattaforme dall'elenco Piattaforma.
3. Scegliere il modello progetto di test MSTest e quindi scegliere Avanti.
4. Nella pagina Configura il nuovo progetto, immettere StringLibraryTest nella casella Nome progetto. Scegliere quindi Avanti.
5. Nella pagina Informazioni aggiuntive selezionare .NET 10 nella casella Framework, selezionare Microsoft.Testing.Platform per lo strumento di esecuzione Test e quindi scegliere Crea.
Immettere informazioni aggiuntive per il progetto di test MSTest
Visual Studio crea il progetto e apre il file di classe nella finestra del codice con il codice seguente. Se la lingua da usare non viene visualizzata, modificare il selettore di lingua nella parte superiore della pagina.
```
namespace StringLibraryTest
{

    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}
```
```
Imports Microsoft.VisualStudio.TestTools.UnitTesting

Namespace StringLibraryTest
    <TestClass>
    Public Class Test1
        <TestMethod>
        Sub TestSub()

        End Sub
    End Class
End Namespace
```
Il codice sorgente creato dal modello di unit test esegue le operazioni seguenti:
- Include Microsoft.VisualStudio.TestTools.UnitTesting nel file di progetto StringLibraryTest in C# e importa Microsoft.VisualStudio.TestTools.UnitTesting in Visual Basic.
- Applica l'attributo alla classe .
- Applica l'attributo TestMethodAttribute per definire TestMethod1 in C# o TestSub in Visual Basic.
Ogni metodo contrassegnato con [TestMethod] in una classe di test contrassegnato con [TestClass] viene eseguito automaticamente quando viene eseguito lo unit test.

Avvia Visual Studio Code.
Aprire la soluzione ClassLibraryProjects creata in Creare una libreria di classi .NET.
Da Esplora soluzioni selezionare Nuovo progetto oppure nel riquadro comandi selezionare .NET: Nuovo progetto.
Selezionare MSTest Test Project (Progetto di test MSTest), denominarlo "StringLibraryTest", selezionare la directory predefinita e selezionare Crea progetto.

Il modello di progetto crea StringLibraryTest/Test1.cs con il codice seguente:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
Il codice sorgente creato dal modello di unit test esegue le operazioni seguenti:
- Applica l'attributo alla classe .
- Applica l'attributo per definire .
- Importa lo spazio dei nomi , che contiene i tipi usati per unit test. Lo spazio dei nomi viene importato tramite una direttiva in GlobalUsings.cs.
Ogni metodo contrassegnato con [TestMethod] in una classe di test contrassegnato con [TestClass] viene eseguito automaticamente quando viene richiamato lo unit test.

Aprire il terminale e passare alla cartella tutorials contenente i progetti StringLibrary e ShowCase.
Creare un nuovo progetto di test MSTest:
```
dotnet new mstest -n StringLibraryTest
```
Il modello di progetto crea StringLibraryTest/Test1.cs con il codice seguente:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
Il codice sorgente creato dal modello di unit test esegue le operazioni seguenti:
- Applica l'attributo alla classe .
- Applica l'attributo per definire .
- Importa lo spazio dei nomi, che contiene i tipi usati per i test unitari.
Ogni metodo contrassegnato con [TestMethod] in una classe di test contrassegnato con [TestClass] viene eseguito automaticamente quando viene richiamato lo unit test.

Aggiungere un riferimento al progetto

Affinché il progetto di test funzioni con la classe , aggiungere un riferimento nel progetto al progetto.

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Dependencies del StringLibraryTest e scegliere Aggiungi riferimento al progetto dal menu di scelta rapida.
Nella finestra di dialogo Gestione riferimenti selezionare la casella accanto a StringLibrary.

Aggiungere StringLibrary come riferimento al progetto per StringLibraryTest.
Seleziona OK.

Da Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto "StringLibraryTest" e selezionare Aggiungi riferimento al progetto.
Selezionare "StringLibrary".

Passare alla cartella StringLibraryTest e aggiungere il riferimento al progetto:

cd StringLibraryTest
dotnet add reference ../StringLibrary/StringLibrary.csproj

Aggiungere ed eseguire metodi di unit test

Quando viene eseguito uno unit test, ogni metodo contrassegnato con l'attributo in una classe contrassegnata con l'attributo viene eseguito automaticamente. Un metodo di test termina quando viene trovato il primo errore o quando tutti i test contenuti nel metodo hanno esito positivo.

I test più comuni chiamano i membri della classe . Molti metodi assert includono almeno due parametri, uno dei quali è il risultato previsto del test e l'altro dei quali è il risultato effettivo del test. Nella tabella seguente sono illustrati alcuni dei metodi chiamati più frequentemente della classe :

Metodi di asserzione	Funzione
`Assert.AreEqual`	Verifica che due valori o oggetti siano uguali. L'asserzione ha esito negativo se i valori o gli oggetti non sono uguali.
`Assert.AreSame`	Verifica che due variabili oggetto facciano riferimento allo stesso oggetto. L'asserzione ha esito negativo se le variabili fanno riferimento a oggetti diversi.
`Assert.IsFalse`	Verifica che una condizione sia . L'asserzione ha esito negativo se la condizione è .
`Assert.IsNotNull`	Verifica che un oggetto non sia . L'asserzione ha esito negativo se l'oggetto è .

È anche possibile usare il metodo in un metodo di test per indicare il tipo di eccezione che dovrebbe generare. Il test ha esito negativo se l'eccezione specificata non viene sollevata.

Nel test del metodo è necessario specificare una serie di stringhe che iniziano con un carattere maiuscolo. Si prevede che il metodo restituisca in questi casi, in modo da poter chiamare il metodo . Analogamente, si vuole fornire una serie di stringhe che iniziano con un carattere diverso da un carattere maiuscolo. Si prevede che il metodo restituisca in questi casi, in modo da poter chiamare il metodo .

Poiché il metodo di libreria gestisce le stringhe, è anche necessario assicurarsi che gestisca correttamente una stringa vuota () e una stringa. Una stringa vuota è una stringa priva di caratteri e la cui proprietà è 0. Una stringa è una stringa che non è stata inizializzata. È possibile chiamare direttamente come metodo statico e passare un singolo argomento. In alternativa, è possibile chiamare come metodo di estensione su una variabile assegnata a .

Verranno definiti tre metodi, ognuno dei quali chiama un metodo per ogni elemento in una matrice di stringhe. Verrà chiamato un metodo overload che consente di specificare un messaggio di errore da visualizzare in caso di errore del test. Il messaggio identifica la stringa che ha causato l'errore.

Per creare i metodi di test:

Nella finestra del codice Test1.cs o Test1.vb sostituire il codice con il codice seguente:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports UtilityLibraries

Namespace StringLibraryTest
    <TestClass>
    Public Class UnitTest1
        <TestMethod>
        Public Sub TestStartsWithUpper()
            ' Tests that we expect to return true.
            Dim words() As String = {"Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsTrue(result,
                       $"Expected for '{word}': true; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub TestDoesNotStartWithUpper()
            ' Tests that we expect to return false.
            Dim words() As String = {"alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " "}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub DirectCallWithNullOrEmpty()
            ' Tests that we expect to return false.
            Dim words() As String = {String.Empty, Nothing}
            For Each word In words
                Dim result As Boolean = StringLibrary.StartsWithUpper(word)
                Assert.IsFalse(result,
                       $"Expected for '{If(word Is Nothing, "<null>", word)}': false; Actual: {result}")
            Next
        End Sub
    End Class
End Namespace

Il test dei caratteri maiuscoli nel metodo include la lettera maiuscola greca alfa (U+0391) e la lettera maiuscola cirillico EM (U+041C). Il test dei caratteri minuscoli nel metodo include la lettera minuscola greca alfa (U+03B1) e la lettera minuscola cirillico Ghe (U+0433).

Sulla barra dei menu selezionare FileSalva Test1.cs con nome o FileSalva Test1.vb con nome. Nella finestra di dialogo Salva file con nome, selezionare la freccia accanto al pulsante Salva e selezionare Salva con codifica.
Nella finestra di dialogo Conferma salvataggio con nome, selezionare il pulsante Sì per salvare il file.
Nella finestra di dialogo opzioni di salvataggio avanzate selezionare Unicode (UTF-8 con firma) - Codepage 65001 dall'elenco a discesa codifica e selezionare OK.

Se non si salva il codice sorgente come file con codifica UTF8, Visual Studio potrebbe salvarlo come file ASCII. In questo caso, il runtime non decodifica accuratamente i caratteri UTF8 all'esterno dell'intervallo ASCII e i risultati del test non sono corretti.
Nella barra dei menu selezionare TestEsegui tutti i test. Se la finestra esplora test di non viene aperta, aprirla scegliendo TestEsplora test. I tre test sono elencati nella sezione test superati e la sezione Riepilogo segnala il risultato dell'esecuzione del test.

finestra Esplora test con test superati

Aprire StringLibraryTest/Test1.cs e sostituire tutto il codice con il codice seguente.

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Salvare le modifiche.

Compilare ed eseguire i test

In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione e selezionare Build o dal riquadro comandi, selezionare .NET: Build.
Selezionare la finestra Test , selezionare Esegui test o nel riquadro comandi selezionare Test: Esegui tutti i test.

Aprire StringLibraryTest/Test1.cs e sostituire tutto il codice con il codice seguente:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Salvare le modifiche ed eseguire i test:
```
dotnet test
```
I test devono superare.

Gestire gli errori di test

Se si esegue lo sviluppo basato su test (TDD), si scrivono prima i test e falliscono quando vengono eseguiti per la prima volta. Quindi aggiungi il codice all'app per far sì che il test abbia successo. Per questa esercitazione, hai creato il test dopo aver scritto il codice dell'app che deve convalidare, quindi non hai visto il test fallire. Per verificare che un test non riesca quando si prevede che non riesca, aggiungere un valore non valido all'input di test.

Modificare la matrice di nel metodo per includere la stringa "Error".

string[] words = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " };

Dim words() As String = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " }

Eseguire il test selezionando TestEsegui tutti i test dalla barra dei menu. La finestra Test Explorer indica che due test hanno avuto risultato positivo e uno è fallito.

finestra Esplora test con test non superati
Selezionare il test non riuscito .

Nella finestra Esplora Test viene visualizzato il messaggio generato dall'asserzione: "Assert.IsFalse failed. Previsto per 'Error': false; effettivo: True." A causa del fallimento, le string nella matrice dopo 'Errore' non sono state testate.

finestra "Esplora test" che mostra il fallimento di asserzione IsFalse

Eseguire i test facendo clic sull'errore verde accanto al test nell'editor.

L'output mostra che il test ha esito negativo e viene visualizzato un messaggio di errore per il test non riuscito: "Assert.IsFalse non riuscito. Previsto per 'Error': false; effettivo: True". A causa dell'errore, nessuna stringa nell'array dopo "Error" è stata testata.

Eseguire i test:
```
dotnet test
```
L'output mostra che il test ha esito negativo e viene visualizzato un messaggio di errore per il test non riuscito: "Assert.IsFalse non riuscito. Previsto per 'Error': false; effettivo: true. A causa dell'errore, non sono state testate stringhe nell'array dopo "Error".

Rimuovere la stringa "Error" aggiunta.
Ripeti il test e i test vengono superati.

Testare la versione release della libreria

Ora che tutti i test sono stati superati durante l'esecuzione della compilazione Debug della libreria, eseguire i test un tempo aggiuntivo rispetto alla build release della libreria. Alcuni fattori, incluse le ottimizzazioni del compilatore, possono talvolta produrre un comportamento diverso tra compilazioni di debug e rilascio.

Per testare la build di rilascio:

Nella barra degli strumenti Visual Studio modificare la configurazione della build da Debug a Release.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto StringLibrary e scegliere Build dal menu di scelta rapida per ricompilare la libreria.
Esegui i test unitari scegliendo TestEsegui tutti i test dalla barra dei menu. I test passano.

Eseguire i test con la configurazione della build di rilascio:

dotnet test StringLibraryTest/StringLibraryTest.csproj --configuration Release

I test passano.

Eseguire i test con la configurazione della build di rilascio:

dotnet test --configuration Release

I test passano.

Eseguire il debug dei test

Se si usa Visual Studio come IDE, è possibile usare lo stesso processo illustrato in Tutorial: Eseguire il debug di un'applicazione console .NET per eseguire il debug del codice usando il progetto di unit test. Invece di avviare il progetto dell'app ShowCase, fare clic con il pulsante destro del mouse sul progetto StringLibraryTests e scegliere Debug tests dal menu di scelta rapida.

Visual Studio avvia il progetto di test con il debugger collegato. L'esecuzione si arresta in qualsiasi punto di interruzione aggiunto al progetto di test o al codice della libreria sottostante.

Se si usa Visual Studio Code come IDE, è possibile usare lo stesso processo illustrato in Debug un'applicazione console .NET per eseguire il debug del codice usando il progetto di unit test. Anziché avviare il progetto di app ShowCase , aprire StringLibraryTest/Test1.cs e selezionare Debug test nel file corrente tra le righe 7 e 8. Se non si riesce a trovarlo, premere Ctrl+Shift+P per aprire la palette dei comandi e immettere Ricarica finestra.

Visual Studio Code avvia il progetto di test con il debugger collegato. L'esecuzione verrà arrestata in qualsiasi punto di interruzione aggiunto al progetto di test o al codice della libreria sottostante.

Risorse aggiuntive

Nozioni di base sul test unitario - Visual Studio
test Unit in .NET

Test unitario in .NET

Risorse di pulizia

GitHub elimina automaticamente codespace dopo 30 giorni di inattività. Se hai intenzione di esplorare altre esercitazioni in questa serie, puoi mantenere attivo il tuo Codespace. Se si è pronti per visitare il sito .NET per scaricare .NET SDK, è possibile eliminare codespace. Per eliminare Codespace, aprire una finestra del browser e passare a Codespaces. Nella finestra viene visualizzato un elenco degli spazi di codice. Selezionare i tre puntini () nella voce dello spazio di codice del tutorial Learn. Selezionare quindi "Elimina".

Passaggi successivi

In questo tutorial, hai effettuato i test unitari su una libreria di classi. È possibile rendere disponibile la libreria ad altri utenti pubblicandola in NuGet come pacchetto. Per sapere come, segui un tutorial su NuGet:

Creare e pubblicare un pacchetto usando l'interfaccia della riga di comando dotnet

Se si pubblica una libreria come pacchetto NuGet, altri utenti possono installarla e usarla. Per sapere come, segui un tutorial su NuGet:

Installare e usare un pacchetto usando l'interfaccia della riga di comando dotnet

Non è necessario distribuire una libreria come pacchetto. Può essere incluso in un'app console che la usa. Per informazioni su come pubblicare un'app console, vedere l'esercitazione precedente in questa serie:

Pubblica un'applicazione console .NET

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-06

Condividi tramite

Esercitazione: Testare una libreria di classi .NET

Prerequisiti

Creare un progetto di unit test

Aggiungere un riferimento al progetto

Aggiungere ed eseguire metodi di unit test

Compilare ed eseguire i test

Gestire gli errori di test

Testare la versione release della libreria

Eseguire il debug dei test

Risorse aggiuntive

Risorse di pulizia

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive