Procedura dettagliata: Sviluppo basato su test con Esplora test

Creare unit test per mantenere il codice funzionante correttamente tramite modifiche incrementali del codice. Esistono diversi framework che è possibile usare per scrivere unit test, tra cui alcuni sviluppati da terze parti. Alcuni framework di test sono specializzati per i test in linguaggi o piattaforme diversi. Esplora test offre una singola interfaccia per gli unit test in uno di questi framework. Per altre informazioni su Esplora test, vedere Eseguire unit test con Esplora test e Domande frequenti su Esplora test.

Questa procedura dettagliata illustra come sviluppare un metodo testato in C# usando Microsoft Test Framework (MSTest). È possibile adattarlo facilmente per altri linguaggi o altri framework di test, ad esempio NUnit. Per ulteriori informazioni, consultare i framework di unit test di terze parti Install.

Creare un test e generare codice

1. Creare un progetto libreria di classi C# per .NET o .NET Standard. Questo progetto conterrà il codice da testare. Assegnare al progetto il nome MyMath.

2. Nella stessa soluzione aggiungere un nuovo progetto di test MSTest per .NET.

   In Visual Studio 2019 versione 16.9, il nome del modello di progetto MSTest è Progetto di test unitario.

   Assegnare al progetto di test il nome MathTests.

   

3. Nel progetto di test scrivere un metodo di test semplice che verifica il risultato ottenuto per un input specifico. Aggiungere il codice seguente alla Test1 classe o UnitTest1 :

   [TestMethod]
   public void BasicRooterTest()
   {
     // Create an instance to test:
     Rooter rooter = new Rooter();
     // Define a test input and output value:
     double expectedResult = 2.0;
     double input = expectedResult * expectedResult;
     // Run the method under test:
     double actualResult = rooter.SquareRoot(input);
     // Verify the result:
     Assert.AreEqual(expectedResult, actualResult, delta: expectedResult / 100);
   }
   

4. Generare un tipo dal codice di test.

   1. Posizionare il cursore su Rootere quindi aprire il menu lampadina.

      Scegliere Genera nuovo tipo.

      

   2. Nella finestra di dialogo Genera tipo impostare Project su MyMath, il progetto di libreria di classi e quindi scegliere OK.

      

5. Generare un metodo dal codice di test. Posizionare il cursore su SquareRoote quindi dal menu lampadina scegliere Genera metodo 'SquareRoot' o Genera metodo 'Rooter.SquareRoot'.

6. Esegui il test unitario.

   1. Aprire Esplora test.

      Per aprire Esplora test dal menu Test , scegliere Esplora test.

   2. In Esplora test scegliere il pulsante Esegui tutto per eseguire il test.

   La soluzione viene compilata e il test viene eseguito e ha esito negativo.

7. Selezionare il nome del test.

   I dettagli del test vengono visualizzati nel riquadro Riepilogo dei dettagli del test.

   

8. Seleziona il primo collegamento sotto Traccia dello stack per passare alla posizione in cui il test non è riuscito.

A questo punto, è stato creato un test e uno stub che è possibile modificare in modo che il test venga superato.

Verificare una modifica del codice

1. Nel file Class1.cs migliorare il codice di SquareRoot:

   public double SquareRoot(double input)
   {
       return input / 2;
   }
   

2. In Esplora test scegliere Esegui tutto.

   La soluzione viene compilata e il test viene eseguito e superato.

   

Estendere l'intervallo di input

Per migliorare la sicurezza del funzionamento del codice in tutti i casi, aggiungere test che provano un'ampia gamma di valori di input.

Suggerimento

Evitare di modificare i test esistenti che risultano positivi. Aggiungere invece nuovi test. Modificare i test esistenti solo quando i requisiti utente cambiano. Questo criterio consente di assicurarsi di non perdere le funzionalità esistenti mentre si lavora per estendere il codice.

1. Nella classe di test aggiungere il test seguente, che prova un intervallo di valori di input:

   [TestMethod]
   public void RooterValueRange()
   {
       // Create an instance to test.
       Rooter rooter = new Rooter();
   
       // Try a range of values.
       for (double expected = 1e-8; expected < 1e+8; expected *= 3.2)
       {
           RooterOneValue(rooter, expected);
       }
   }
   
   private void RooterOneValue(Rooter rooter, double expectedResult)
   {
       double input = expectedResult * expectedResult;
       double actualResult = rooter.SquareRoot(input);
       Assert.AreEqual(expectedResult, actualResult, delta: expectedResult / 1000);
   }
   

2. In Esplora test scegliere Esegui tutto.

   Il nuovo test ha esito negativo (anche se il primo test è ancora superato). Per trovare il punto di guasto, selezionare il test non riuscito e quindi esaminare i dettagli nel riquadro Riepilogo dettagli test.

3. Esaminare il metodo sottoposto a test per verificare che cosa potrebbe essere sbagliato. Modificare il SquareRoot codice come segue:

   public double SquareRoot(double input)
   {
     double result = input;
     double previousResult = -input;
     while (Math.Abs(previousResult - result) > result / 1000)
     {
       previousResult = result;
       result = result - (result * result - input) / (2 * result);
     }
     return result;
   }
   

4. In Esplora test scegliere Esegui tutto.

   Entrambi i test sono stati superati.

Aggiungere test per casi eccezionali

1. Aggiungere un nuovo test per gli input negativi:

   [TestMethod]
   public void RooterTestNegativeInput()
   {
       Rooter rooter = new Rooter();
       Assert.ThrowsException<ArgumentOutOfRangeException>(() => rooter.SquareRoot(-1));
   }
   

2. In Esplora test scegliere Esegui tutto.

   Il nuovo test ha esito negativo.

   Se il metodo sottoposto a cicli di test, scegliere Annulla sulla barra degli strumenti di Esplora test. Il test interrompe l'esecuzione e non riesce.

3. Correggere il SquareRoot codice aggiungendo l'istruzione seguente if all'inizio del metodo :

   public double SquareRoot(double input)
   {
       if (input <= 0.0)
       {
           throw new ArgumentOutOfRangeException();
       }
       ...
   

4. In Esplora test scegliere Esegui tutto.

   Tutti i test vengono superati.

Eseguire il refactoring del codice sottoposto a test

Effettuare il refactoring del codice, ma non modificare i test.

Suggerimento

Un refactoring è una modifica progettata per migliorare o semplificare la comprensione del codice. Non è progettato per modificare il comportamento del codice e pertanto i test non vengono modificati.

È consigliabile eseguire i passaggi di refactoring separatamente dai passaggi che estendono la funzionalità. Mantenere invariati i test garantisce che non siano stati introdotti accidentalmente bug durante il refactoring.

1. Modificare la riga che calcola result nel metodo SquareRoot come segue:

   public double SquareRoot(double input)
   {
       if (input <= 0.0)
       {
           throw new ArgumentOutOfRangeException();
       }
   
       double result = input;
       double previousResult = -input;
       while (Math.Abs(previousResult - result) > result / 1000)
       {
           previousResult = result;
           result = (result + input / result) / 2;
           //was: result = result - (result * result - input) / (2*result);
       }
       return result;
   }
   

2. Scegliere Esegui tutto e verificare che tutti i test siano ancora superati.