Introduzione agli unit test

Usare Visual Studio per definire ed eseguire i test unitari per mantenere l'integrità del codice, assicurarsi della copertura del codice, e trovare errori e difetti prima che li trovino i clienti. Eseguire spesso gli unit test per assicurarsi che il codice funzioni correttamente.

In questo articolo il codice usa C# e C++, ma i concetti e le funzionalità si applicano ai linguaggi .NET, C++, Python, JavaScript e TypeScript.

Creare unit test

Questa sezione descrive come creare un progetto di unit test.

Aprire il progetto da testare in Visual Studio.

Ai fini della dimostrazione di un unit test di esempio, questo articolo testa un semplice progetto console 'Hello World' in C# o C++, denominato HelloWorld. Il codice di esempio per un progetto di questo tipo è il seguente:
- .NET
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
In Esplora soluzioni selezionare il nodo della soluzione. Quindi, nella barra dei menu in alto selezionare FileAggiunginuovo progetto.
Nella finestra di dialogo Nuovo progetto trovare il progetto di unit test da usare.

Digitare test nella casella di ricerca per trovare un modello di progetto unit test per il framework di test che si vuole usare, ad esempio MSTest (C#) o il progetto di unit test nativo (C++) e selezionarlo.

Le lingue .NET in Visual Studio includono modelli predefiniti per NUnit e xUnit. Per C++, in questo esempio selezionare il progetto Unit Test Nativo, che usa Microsoft Native Unit Test Framework. Per usare un framework di test C++ diverso, vedere Scrittura di unit test per C/C++. Per Python, vedere Impostare unit test nel codice Python per configurare il progetto di test.

Suggerimento

Questo articolo descrive come creare manualmente unit test. Per generare i test automaticamente dal codice esistente, vedere Generate ed eseguire unit test usando GitHub Copilot test per .NET o per altri linguaggi, vedere Usare i comandi slash in GitHub Copilot

Suggerimento

Questo articolo descrive come creare manualmente unit test. Per generare automaticamente test dal codice esistente, vedere Creare stub del metodo di unit test C# dal codice o per altri linguaggi, vedere Usare i comandi barra in GitHub Copilot

La figura seguente illustra uno unit test MSTest, supportato in .NET.

Modello di progetto per test unitario in Visual Studio 2022

Fare clic su Avanti, scegliere un nome per il progetto di test e quindi fare clic su Crea.

Il progetto viene aggiunto alla soluzione.

progetto di test
Nel progetto di unit test aggiungere un riferimento al progetto da testare facendo clic con il pulsante destro del mouse su Riferimenti o dipendenze e quindi scegliendo Aggiungi riferimento o Aggiungi riferimento al progetto.
Selezionare il progetto contenente il codice che verrà testato e fare clic su OK.

Aggiungere codice al metodo unit test.

Ad esempio, è possibile usare il codice seguente selezionando la scheda della documentazione corretta corrispondente al framework di test: MSTest, NUnit o xUnit (supportato solo in .NET) o C++ Microsoft Native Unit Test Framework.

MSTest
NUnit
xUnit
Framework di unit test nativo Microsoft

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System;

namespace HelloWorldTests
{
   [TestClass]
   public class UnitTest1
   {
      private const string Expected = "Hello World!";
      [TestMethod]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using NUnit.Framework;
using System.IO;
using System;

namespace HelloWorldTests
{
   public class Tests
   {
      private const string Expected = "Hello World!";

      [SetUp]
      public void Setup()
      {
      }
      [Test]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using System;
using Xunit;
using System.IO;

namespace HelloWorldTests
{
    public class UnitTest1
    {
        private const string Expected = "Hello World!";
        [Fact]
        public void Test1()
        {
            using (var sw = new StringWriter())
            {
                Console.SetOut(sw);
                HelloWorld.Program.Main();

                var result = sw.ToString().Trim();
                Assert.Equal(Expected, result);
            }
        }
    }
}

#include "pch.h"
#include "CppUnitTest.h"
#include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace HelloWorldTests
{
   TEST_CLASS(HelloWorldTests)
   {
   public:

      TEST_METHOD(TestMethod)
      {
         std::string expected = "Hello World!\n";

         std::stringstream buffer;
         std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
         std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer

         // Call main() in your test
         int result = main();

         // When finished, redirect cout to the original buffer 
         std::cout.rdbuf(sbuf);
         std::cout << "std original buffer: \n";
         std::cout << buffer.get();

         // Test
         Assert::AreEqual(expected, buffer.str());
      }
   };
}

Eseguire i test delle unità

Aprire Esplora test.

Per aprire Esplora test, scegliere Esploratest dalla barra dei menu in alto o premere CTRLE, T.
Eseguire gli unit test facendo clic su Esegui tutto (oppure premere CTRLR, V).

Screenshot che mostra Esplora Test.

Eseguire i test unità in Esplora test

Al termine dei test, un segno di spunta verde indica che un test è stato superato. Un'icona rossa "x" indica che un test non è riuscito.

Screenshot che mostra i risultati degli unit test in Esplora test.

Esaminare i risultati degli unit test in Esplora test

Suggerimento

È possibile usare Esplora test per eseguire unit test dal framework di test predefinito (MSTest) o da framework di test di terze parti. È possibile raggruppare i test in categorie, filtrare l'elenco di test e creare, salvare ed eseguire playlist di test. È anche possibile eseguire il debug dei test e analizzare le prestazioni dei test e il code coverage.

Visualizzare i risultati dello unit test live (Visual Studio Enterprise)

Se si usa il framework di test MSTest, xUnit o NUnit in Visual Studio 2017 o versione successiva, è possibile visualizzare i risultati in tempo reale degli unit test.

Annotazioni

Per seguire questi passaggi, è necessario Visual Studio Enterprise, insieme al codice .NET e a uno dei framework di test seguenti: MSTest, xUnit o NUnit.

Attiva il live unit testing dal menu Test scegliendo TestLive Unit TestingStart.
Visualizzare i risultati dei test nella finestra dell'editor di codice durante la scrittura e la modifica del codice.

Screenshot che mostra i risultati dei test.

Visualizzare i risultati dei test
Fare clic su un indicatore dei risultati del test per visualizzare altre informazioni, ad esempio i nomi dei test che riguardano tale metodo.

Screenshot che mostra gli indicatori dei risultati del test.

Scegliere gli indicatori dei risultati del test

Per altre informazioni sugli unit test live, vedere Live Unit Testing.

Usare un framework di test di terze parti

È possibile eseguire unit test in Visual Studio usando framework di test di terze parti, ad esempio NUnit, Boost o Google C++ Testing Framework, a seconda del linguaggio di programmazione. Per usare un framework di terze parti:

Usare il NuGet Gestione pacchetti per installare il pacchetto NuGet per il framework preferito.
(.NET) A partire da Visual Studio 2017 versione 14.6, Visual Studio include modelli di progetto di test preconfigurati per framework di test NUnit e xUnit. I modelli includono anche i pacchetti NuGet necessari per abilitare il supporto.
(C++) In Visual Studio 2017 e versioni successive alcuni framework come Google C++ Testing Framework sono già inclusi. Per altre informazioni, vedere Scrivere test unitari per C/C++ in Visual Studio.

Per aggiungere un progetto di unit test:

Aprire la soluzione che contiene il codice da testare.
Fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni e scegliere Aggiungi>Nuovo progetto.
Selezionare un modello di progetto unit test.

In questo esempio selezionare NUnit

modello di progetto di test

Il modello di progetto include riferimenti NuGet a NUnit e NUnit3TestAdapter.
Aggiungere un riferimento dal progetto di test al progetto che contiene il codice da testare.

Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e quindi selezionare Add>Reference. È anche possibile aggiungere un riferimento dal menu di scelta rapida del nodo Riferimenti o dipendenze .
Aggiungere codice al metodo di test.

Screenshot che mostra il codice nel file di unit test.

Aggiungere codice al file di codice unit test
Eseguire il test da Esplora test o facendo clic con il pulsante destro del mouse sul codice di test e scegliendo Esegui test (o CTRLR, T).

Passaggi successivi

Nozioni di base sugli unit test

Creare ed eseguire unit test per il codice gestito

Scrivere test unitari per C/C++

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-06