C #. Esempio di creazione di un test unitario in MS Visual Studio

1. Il contenuto
2. esecuzione
3. 2. Preparazione del testo del modulo Program.cs
4. 2.2. Rendi pubblica la classe Program
5. 3. Elenco del programma testato
6. 4. Creazione di un test
7. 4.1. Aggiunta di un nuovo progetto alla soluzione
8. 4.2. Struttura della soluzione
9. 4.3. Il testo del file "UnitTest1.cs". Attributi [TestMethod] e [TestClass]
10. 4.4. Apportare modifiche al testo del modulo UnitTest1. Modifica del nome del metodo di prova
11. 4.5. Connessione del progetto MinApp al progetto TestMinApp
12. 4.6. Apportare modifiche al testo del modulo UnitTest1.cs
13. 4.6.2. TestMin () metodo di testo
14. 4.7. UnitTest1.cs testo del modulo
15. 5. Eseguire il test e controllare il risultato del test
16. 6. Il risultato. Interazione tra progetti

Questo argomento descrive la procedura dettagliata per la creazione di un semplice Test unità in Microsoft Visual Studio 2010 (C #) per un'applicazione come Applicazione console. Usando questo esempio, puoi imparare come creare i tuoi test unitari. L'esempio dimostra anche l'uso della classe Assert per testare l'operazione delle funzioni.

Il contenuto

La condizione del problema

Per un'applicazione come Console Application, sviluppare un test unitario che verifica il funzionamento della funzione Min (), che determina l'elemento massimo di tre numeri.

Per la funzione Min (), impostare il metodo di test su TestMin (). Controlla la funzione.

esecuzione

1. Creare un'applicazione utilizzando il modello dell'applicaiton della console

Eseguire MS Visual Studio 2010 per l'esecuzione. Per creare un progetto utilizzando il modello di applicazione della console, è necessario chiamare la seguente sequenza di comandi:

File -> Nuovo -> Progetto ...

Di conseguenza, si apre la finestra Nuovo progetto. Nella finestra, selezionare il modello dell'applicazione Console come mostrato nella Figura 1. Il modello è selezionato nella scheda Visual C #.

Visual C # -> Applicazione console

Fig. 1. Finestra "Nuovo progetto". Scelta di un'applicazione del tipo di applicazione della console

2. Preparazione del testo del modulo Program.cs

2.1. Aggiungi la funzione Min () al testo del modulo

Nel corpo della classe Program, aggiungi il testo della funzione Min ().

La funzione è dichiarata pubblica (statica) e pubblica. Min () testo della funzione

public static int Min (int a, int b, int c) {int min = a; se (min> b) min = b; se (min> c) min = c; ritorno min; }

Fig. 2. Vista della finestra di MS Visual Studio 2010, modulo "Program.cs"

2.2. Rendi pubblica la classe Program

Per poter accedere alla funzione Min () della classe Program, è necessario rendere questa classe pubblicamente disponibile. Per fare ciò, prima di dichiarare una classe, è necessario definire la parola chiave pubblica.

... namespace MinApp {public class Program {// metodi della classe // ...}} ...

Dopodiché, il programma di test è pronto.

3. Elenco del programma testato

Al momento, l'elenco del programma sottoposto a test è il seguente:

usando il sistema; using System.Collections.Generic; using System.Linq; using System.Text; namespace MinApp {public class Program {pubblico static int Min (int a, int b, int c) {int min = a; se (min> b) min = b; se (min> c) min = c; ritorno min; } static void Main (string [] args) {Console.WriteLine ("Demo di Unit-testing in C #."); }}}

Poiché questo programma verrà testato da un altro modulo di test, non è necessario immettere altro nella funzione Main (). Perché, in base alle condizioni del problema, è necessario testare il funzionamento della funzione Min (). E questo sarà fatto dal modulo di test. Al momento, il nostro programma è pronto per i test.

4. Creazione di un test

Il test viene creato da un progetto separato (Progetto) nella soluzione (Soluzione). Il programma in fase di test non lo sa. Il programma che testerà (il programma di test) chiamerà le funzioni del programma in fase di test. Nel nostro caso, il programma di test chiamerà la funzione

int Min (int, int, int);

4.1. Aggiunta di un nuovo progetto alla soluzione

Per questa soluzione (Soluzione) è necessario aggiungere un nuovo progetto usando il comando

File-> Aggiungi-> Nuovo progetto ...

La finestra per la creazione di un nuovo progetto è mostrata nella Figura 3.

Fig. 3. Finestra per la creazione di un progetto del tipo Progetto di test

Un gruppo di modelli Visual C # -> Test è selezionato nella finestra. Dai modelli visualizzati, è selezionato il modello di progetto "Progetto di prova". Nel campo "Nome" viene indicato il nome del progetto che testerà il nostro programma. È necessario impostare, ad esempio, TestMinApp. Il progetto si trova in una cartella separata "E: \ Test \ MinApp".

Fig. 4. Il testo del modulo UnitTest1.cs. Finestra di utilità Solution Explorer con i progetti TestMinApp e MinApp visualizzati

4.2. Struttura della soluzione

Come si può vedere dalla Figura 4, l'utilità Solution Explorer visualizza la struttura degli elementi della soluzione, che contiene due progetti:

• progetto MinApp. Questo è un progetto creato utilizzando il modello di applicazione Console con la funzione Min () che si desidera protestare;
• Progetto TestMinApp. Questo progetto è progettato per testare le funzionalità del progetto MinApp. Il codice del programma che testa la funzione Min () verrà inserito nel file di progetto UnitTest1 del progetto TestMinApp.

Entrambi i progetti possono essere eseguiti indipendentemente l'uno dall'altro.

4.3. Il testo del file "UnitTest1.cs". Attributi [TestMethod] e [TestClass]

Nel progetto TestMinApp, il file di test UnitTest1.cs è di interesse primario. Questo file contiene metodi che testeranno le funzioni del progetto MinApp. Il progetto TestMinApp può contenere qualsiasi numero di file che contengono test (ad esempio, UnitTest2.cs, UnitTest3.cs, ecc.).

L'elenco del file UnitTest1.cs generato da MS Visual Studio 2010 è il seguente:

usando il sistema; using System.Text; using System.Collections.Generic; using System.Linq; utilizzando Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Descrizione riassuntiva per UnitTest1 /// </ summary> [TestClass] public Class UnitTest1 {public UnitTest1 () {// // TODO: Aggiungi la logica del costruttore qui //} private TestContext testContextInstance; /// <summary> /// Ottiene o imposta il contesto di test. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = value; }} #region Ulteriori attributi di test // puoi usare i tuoi test // // Usa ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext TestContext) {} // // Utilizza ClassCleanup per eseguire il codice dopo che tutti i test di una classe hanno eseguito // [ClassCleanup ()] // public static void MyClassCleanup () {} // // Usa TestInitialize per eseguire il codice prima dell'esecuzione di ogni test // [TestInitialize ()] // public void MyTestInitialize () {} // // Utilizzare TestCleanup per eseguire il codice dopo l'esecuzione di ciascun test // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMethod1 () {// // TODO: Aggiungi logica di test qui //}}}

Come si può vedere dal codice precedente, il file contiene una classe denominata UnitTest1. La classe ha un metodo pubblico chiamato TestMethod1 (). Prima di implementare il metodo TestMethod1 (), viene inserito l'attributo [TestMethod]. Ciò significa che è necessario inserire il codice che testerà le funzioni del progetto MinApp nel corpo del metodo.

Nella classe, puoi inserire qualsiasi numero di metodi che testeranno diverse funzioni da diversi moduli. La cosa principale è che questi metodi sono contrassegnati con l'attributo [TestMethod].

4.4. Apportare modifiche al testo del modulo UnitTest1. Modifica del nome del metodo di prova

È possibile modificare i nomi dei metodi e aggiungere nuovi metodi contrassegnati con l'attributo [TestMethod] nel modulo UnitTest1.cs. Detto questo, nel testo del modulo UnitTest1.cs, è necessario rinominare il metodo TestMethod1 () in TestMin ().

Dopo aver apportato le modifiche, il testo abbreviato del modulo del file UnitTest1.cs sarà:

usando il sistema; using System.Text; using System.Collections.Generic; using System.Linq; utilizzando Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Descrizione riassuntiva per UnitTest1 /// </ summary> [TestClass] publicTest UnitTest1 {... [TestMethod] public void TestMin () {// // TODO: Aggiungi test logica qui //}}}

4.5. Connessione del progetto MinApp al progetto TestMinApp

Per accedere alla funzione Min () (progetto MinApp) dal progetto TestMinApp, è necessario connettere lo spazio dei nomi in cui si trova questa funzione.

Per fare ciò, prima di tutto, è necessario chiamare il menu di scelta rapida per il progetto TestMinApp. Quindi nel menu di scelta rapida è necessario chiamare il comando "Aggiungi riferimento ..." (Figura 5).

Fig. 5. Squadra "Aggiungi referenza ..."

Di conseguenza, verrà visualizzata la finestra Aggiungi riferimento, in cui è necessario selezionare il progetto MinApp.

Fig. 6. Finestra "Aggiungi riferimento". Connettendo il progetto MinApp

Dopo le azioni completate, le funzioni del progetto MinApp saranno disponibili per l'uso nel progetto TestMinApp.

Fig. 7. Scheda Riferimenti con progetto MinApp collegato

4.6. Apportare modifiche al testo del modulo UnitTest1.cs

4.6.1. Aggiunta dello spazio dei nomi di MinApp al modulo UnitTest1.cs

In questo passaggio, nel modulo UnitTest1.cs, è necessario aggiungere lo spazio dei nomi di MinApp usando la direttiva using:

usando il sistema; using System.Text; using System.Collections.Generic; using System.Linq; utilizzando Microsoft.VisualStudio.TestTools.UnitTesting; usando MinApp; namespace TestMinApp {...}

4.6.2. TestMin () metodo di testo

Nel testo del metodo TestMin (), inserire il seguente codice:

... [TestMethod] public void TestMin () {// // TODO: Aggiungi logica di test qui // int min; min = Program .Min (3, 4, 5); Assert. AreEqual (2, min); } ...

4.7. UnitTest1.cs testo del modulo

Il testo dell'intero modulo UnitTest1.cs è il seguente:

usando il sistema; using System.Text; using System.Collections.Generic; using System.Linq; utilizzando Microsoft.VisualStudio.TestTools.UnitTesting; usando MinApp; namespace TestMinApp {/// <summary> /// Descrizione riassuntiva per UnitTest1 /// </ summary> [TestClass] public Class UnitTest1 {public UnitTest1 () {// // TODO: Aggiungi la logica del costruttore qui //} private TestContext testContextInstance; /// <summary> /// Ottiene o imposta il contesto di test. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = value; }} #region Ulteriori attributi di test // puoi usare i tuoi test // // Usa ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext TestContext) {} // // Utilizza ClassCleanup per eseguire il codice dopo che tutti i test di una classe hanno eseguito // [ClassCleanup ()] // public static void MyClassCleanup () {} // // Usa TestInitialize per eseguire il codice prima dell'esecuzione di ogni test // [TestInitialize ()] // public void MyTestInitialize () {} // // Utilizzare TestCleanup per eseguire il codice dopo l'esecuzione di ciascun test // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMin () {// // TODO: Aggiungi logica di test qui // int min; min = Program .Min (3, 4, 5); Assert. AreEqual (2, min); }}}

5. Eseguire il test e controllare il risultato del test

In Microsoft Visual Studio 2010, uno speciale menu di comandi chiamato Test è implementato per lavorare con i test di unità.

Per eseguire un test di esecuzione, selezionare uno dei comandi.

o

Prova -> Esegui -> Tutti i test in soluzione

come mostrato nella Figura 8.

Fig. 8. Richiama il comando start test e visualizza il risultato.

Dopo aver eseguito il test, il risultato può essere visualizzato nella parte inferiore della finestra Risultati del test. Come si può vedere dalla figura, il test non viene superato. Questo è logico, poiché nella funzione Assert.AreEqual () confrontiamo i numeri 2 e 3, che sono diversi. Qui, il numero 2 viene introdotto in modo speciale anziché 3.

Se invece del numero 2 si inserisce la risposta corretta - numero 3 (minimo tra 3, 4, 5), il test verrà superato (Figura 9). In questo caso, il testo del metodo TestMin () sarà il seguente:

... [TestMethod] public void TestMin () {// // TODO: Aggiungi logica di test qui // int min; min = Program .Min (3, 4, 5); Assert. AreEqual (3, min); } ...

La finestra dei risultati è mostrata nella Figura 9.

Fig. 9. Risultato del test per il caso, se si inserisce la risposta corretta

Ora possiamo concludere che la funzione Min () per questo caso funziona correttamente.

6. Il risultato. Interazione tra progetti

In questo documento, due progetti sono formati nella soluzione. Un progetto MinApp contiene la funzione Min () che si desidera testare. Il secondo progetto, TestMinApp, contiene metodi di test.

In Microsoft Visual Studio 2010, ogni progetto viene avviato utilizzando diversi comandi di menu. Quindi, il progetto MinApp viene lanciato nel modo standard dal menu Esegui. E il progetto TestMinApp viene lanciato dal menu Test speciale.

Argomenti correlati