Introduzione agli unit test

Articolo
01/19/2024

Visual Studio consente di definire ed eseguire unit test per mantenere l'integrità del codice, garantire il code coverage e individuare gli errori e i problemi prima dei clienti. Eseguire gli unit test di frequente per assicurarsi che il codice funzioni correttamente.

In questo articolo il codice usa C# e C++, le illustrazioni si trovano in 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 uno unit test di esempio, questo articolo testa un semplice progetto console C# o C++ "Hello World" denominato HelloWorld. Il codice di esempio per questo tipo di progetto è 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";
}
```
Selezionare il nodo della soluzione in Esplora soluzioni. Dalla barra dei menu superiore selezionare File>Aggiungi>Nuovo 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.

A partire da Visual Studio 2017 versione 14.8, i linguaggi .NET 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 Configurare unit test nel codice Python per configurare il progetto di test.

Suggerimento

Solo per C# è possibile creare progetti di unit test dal codice usando un metodo più rapido. Per altre informazioni, vedere Creare progetti di unit test e metodi di test. Per usare questo metodo con .NET Core o .NET Standard, è necessario Visual Studio 2019 o versione successiva.

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

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

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

Il progetto viene aggiunto alla soluzione.
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 che contiene il codice da testare e fare clic su OK.

Aggiungere codice al metodo di 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.

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());
      }
   };
}

Esecuzione di unit test

Aprire Esplora test.

Per aprire Esplora test, scegliere Esplora>test dalla barra dei menu in alto o premere CTRL + E, T.
Eseguire gli unit test facendo clic su Esegui tutto (oppure premere CTRL + R, V).

Dopo aver completato i test, un segno di spunta verde indica che un test è stato superato. Un'icona "x" rossa indica che un test non è stato superato.

Suggerimento

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

Visualizzare i risultati degli 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 in tempo reale i risultati degli unit test.

Nota

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

Attivare Live Unit Testing dal menu Test, scegliendo Test>Live Unit Testing>Avvia.
Visualizzare i risultati dei test nella finestra dell'editor di codice durante la scrittura e la modifica del codice.
Fare clic sull'indicatore del risultato di un test per visualizzare altre informazioni, ad esempio i nomi dei test che verificano tale metodo.

Per altre informazioni su Live Unit Testing, 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 Gestione pacchetti NuGet per installare il pacchetto NuGet per il framework di propria scelta.
(.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 unit test 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

Fare clic su Avanti, assegnare un nome al progetto e quindi fare clic su Crea.

Il modello di progetto include i riferimenti NuGet di 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 scegliere Aggiungi>Riferimento. È anche possibile aggiungere un riferimento dal menu di scelta rapida del nodo Riferimenti o Dipendenze.
Aggiungere codice al metodo di 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 CTRL + R, T).