C #. Exemplu de creare a unui test de unitate în MS Visual Studio

1. conținut
2. execuție
3. 2. Pregătirea textului modulului Program.cs
4. 2.2. Faceți clasa programului publică
5. 3. Listați programul testat
6. 4. Crearea unui test
7. 4.1. Adăugarea unui nou proiect la soluție
8. 4.2. Structura soluției
9. 4.3. Textul fișierului "UnitTest1.cs". Atributele [TestMethod] și [TestClass]
10. 4.4. Efectuarea modificărilor la textul modulului UnitTest1. Schimbarea numelui metodei de testare
11. 4.5. Conectarea proiectului MinApp la proiectul TestMinApp
12. 4.6. Modificarea textului modulului UnitTest1.cs
13. 4.6.2. Textul metodei TestMin ()
14. 4.7. Textul modulului UnitTest1.cs
15. 5. Rulați testul și verificați rezultatul testului
16. 6. Rezultatul. Interacțiunea dintre proiecte

Acest subiect descrie procesul pas cu pas de creare a unui test simplu de unitate în Microsoft Visual Studio 2010 (C #) pentru o aplicație cum ar fi Application Console. Folosind acest exemplu, puteți afla cum să vă creați propriile teste de unitate. Exemplul demonstrează, de asemenea, utilizarea clasei Assert pentru testarea funcționării funcțiilor.

conținut

Starea problemei

Pentru o aplicație cum ar fi aplicația Console, dezvoltați un test Unitate care testează funcționarea funcției Min (), care determină elementul maxim de trei numere.

Pentru funcția Min (), setați metoda TestMin (). Verificați funcția.

execuție

1. Creați o aplicație folosind șablonul Application Console

Executați pentru execuție MS Visual Studio 2010. Pentru a crea un proiect folosind modelul aplicației Console, trebuie să fie apelată următoarea linie de comandă:

Fișier -> Nou -> Proiect ...

Ca urmare, se deschide fereastra Nou proiect. În fereastră, selectați șablonul Application Console, așa cum se arată în figura 1. Șablonul este selectat în fila Visual C #.

Visual C # -> aplicație consola

Fig. 1. Fereastra "Proiect nou". Alegerea unei aplicații pentru tipul de aplicație din consola

2. Pregătirea textului modulului Program.cs

2.1. Adăugați funcția Min () la textul modulului

Textul funcției Min () ar trebui adăugat la corpul clasei programului.

Funcția este declarată publică (publică) și publică. Textul funcției Min ()

static int int Min (int a, int b, int c) {int min = a; dacă (min> b) min = b; dacă (min> c) min = c; retur min; }

Fig. 2. Vizualizarea ferestrei MS Visual Studio 2010, modul "Program.cs"

2.2. Faceți clasa programului publică

Pentru a avea acces la funcția Min () a clasei programului, trebuie să faceți public această clasă. Pentru a face acest lucru, înainte de a declara o clasă, trebuie să definiți cuvântul cheie public.

... namespace MinApp {program de clasă publică {// metode de clasă // ...}} ...

După aceea, programul de testare este gata.

3. Listați programul testat

În momentul de față, lista programului care este testată este următoarea:

utilizând Sistemul; folosind System.Collections.Generic; folosind System.Linq; utilizând System.Text; spațiul de nume MinApp {public class Program {public static int Min (int a, int b, int c) {int min = a; dacă (min> b) min = b; dacă (min> c) min = c; retur min; } static void Principal (șir [] args) {Console.WriteLine ("Demo de testare a unității în C #."); }}}

Deoarece acest program va fi testat de la un alt modul de testare, nu este nevoie să introduceți nimic altceva în funcția Main (). Deoarece, în funcție de condiția problemei, trebuie să testați funcționarea funcției Min (). Și acest lucru se va face din modulul de testare. În prezent, programul nostru este pregătit pentru testare.

4. Crearea unui test

Testul este creat de un proiect separat (Project) în soluție (Soluție). Programul testat nu știe despre el. Programul care va testa (programul de testare) va apela funcțiile programului care este testat. În cazul nostru, programul de testare va apela funcția

int min (int, int, int);

4.1. Adăugarea unui nou proiect la soluție

Pentru această soluție (Soluție), trebuie să adăugați un nou proiect folosind comanda

Fișier-> Adăugați-> Proiect nou ...

Fereastra pentru crearea unui nou proiect este prezentată în Figura 3.

Fig. 3. Fereastră pentru crearea unui proiect de tip Test Project

Un grup de șabloane Visual C # -> Test este selectat în fereastră. Din șabloanele afișate este selectat șablonul de proiect "Test Project". În câmpul "Name" este indicat numele proiectului care va testa programul nostru. Trebuie să setați, de exemplu, TestMinApp. Proiectul se află într-un director separat "E: \ Test \ MinApp".

Fig. 4. Textul modulului UnitTest1.cs. Soluția fereastră utilitar Explorer cu proiectele TestMinApp și MinApp afișate

4.2. Structura soluției

După cum se poate vedea din Figura 4, utilitarul Solution Explorer afișează structura Solution Items, care conține două proiecte:

• proiect MinApp. Acesta este un proiect creat folosind șablonul Application Console cu funcția Min () pe care doriți să o protestați;
• Proiectul TestMinApp. Acest proiect este conceput pentru a testa caracteristicile proiectului MinApp. Codul programului care testează funcția Min () va fi introdus în fișierul proiectului UnitTest1 al proiectului TestMinApp.

Ambele proiecte pot fi efectuate independent una de cealaltă.

4.3. Textul fișierului "UnitTest1.cs". Atributele [TestMethod] și [TestClass]

În proiectul TestMinApp, fișierul test UnitTest1.cs este de interes primar. Acest fișier conține metode care vor testa funcțiile proiectului MinApp. Proiectul TestMinApp poate conține orice număr de fișiere care conțin teste (de exemplu, UnitTest2.cs, UnitTest3.cs etc.).

Listarea fișierului UnitTest1.cs generat de MS Visual Studio 2010 este după cum urmează:

utilizând Sistemul; utilizând System.Text; folosind System.Collections.Generic; folosind System.Linq; folosind Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Descrierea sumară pentru UnitTest1 /// </ summary> [TestClass] clasa publică UnitTest1 {public UnitTest1 () {// // TODO: Adăugați logica constructorului aici //} privat TestContext testContextInstance; /// <summary> /// Obține sau stabilește contextul testului. /// </ summary> public TestContext TestContext {get {retur testContextInstance; } set {testContextInstance = valoare; }} #region Atribute suplimentare de testare // puteți utiliza testele dvs. // // Utilizați ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Folosiți ClassCleanup pentru a rula codul pentru a rula codul înainte de a executa fiecare test // [TestInitialize ()] // public void MyTestInitialize () {} // // Utilizați TestCleanup ) {} // #endregion [TestMethod] public void TestMethod1 () {// // TODO: Adăugați logica de testare aici //}}}

După cum se poate observa din codul de mai sus, fișierul conține o clasă numită UnitTest1. Clasa are o metodă publică numită TestMethod1 (). Înainte de a implementa metoda TestMethod1 (), este plasat atributul [TestMethod]. Aceasta înseamnă că trebuie să introduceți codul care va testa funcțiile proiectului MinApp în corpul metodei.

În clasă, puteți introduce numeroase metode care vor testa diferite funcții din diferite module. Principalul lucru pe care aceste metode au fost marcate cu atributul [TestMethod].

4.4. Efectuarea modificărilor la textul modulului UnitTest1. Schimbarea numelui metodei de testare

Puteți modifica numele metodelor și puteți adăuga metode noi care sunt marcate cu atributul [TestMethod] în modulul UnitTest1.cs. Având în vedere acest lucru, în textul modulului UnitTest1.cs, trebuie să redenumiți metoda TestMethod1 () la TestMin ().

După efectuarea modificărilor, textul abreviat al modulului din fișierul UnitTest1.cs va fi:

utilizând Sistemul; utilizând System.Text; folosind System.Collections.Generic; folosind System.Linq; folosind Microsoft.VisualStudio.TestTools.UnitTesting; spațiu de nume TestMinApp {/// <summary> /// Descriere sumară pentru UnitTest1 /// </ summary> [TestClass] public class UnitTest1 {... [TestMethod] public void TestMin () {// // TODO: logica aici //}}}

4.5. Conectarea proiectului MinApp la proiectul TestMinApp

Pentru a avea acces la funcția Min () (proiect MinApp) din proiectul TestMinApp, trebuie să conectați spațiul de nume în care este localizată această funcție.

Pentru a face acest lucru, mai întâi trebuie să apelați meniul contextual pentru proiectul TestMinApp. Apoi, în meniul contextual trebuie să apelați comanda "Add Reference ..." (Figura 5).

Fig. 5. Echipa "Add Referencse ..."

Ca rezultat, se va deschide fereastra Adăugare referință, în care trebuie să selectați proiectul MinApp.

Fig. 6. Fereastra "Adăugați o referință". Conectarea proiectului MinApp

După acțiunile finalizate, funcțiile proiectului MinApp vor fi disponibile pentru utilizare în proiectul TestMinApp.

Fig. 7. Fila Referințe cu proiectul MinApp conectat

4.6. Modificarea textului modulului UnitTest1.cs

4.6.1. Adăugarea spațiului de nume MinApp la modulul UnitTest1.cs

La acest pas, în modulul UnitTest1.cs, trebuie să adăugați spațiul de nume MinApp utilizând directiva de utilizare:

utilizând Sistemul; utilizând System.Text; folosind System.Collections.Generic; folosind System.Linq; folosind Microsoft.VisualStudio.TestTools.UnitTesting; folosind MinApp; namespace TestMinApp {...}

4.6.2. Textul metodei TestMin ()

În textul metodei TestMin (), introduceți următorul cod:

... [TestMethod] void public TestMin () {// // TODO: Adăugați logica de testare aici // int min; min = program. Min (3, 4, 5); Assert .AreEqual (2, min); } ...

4.7. Textul modulului UnitTest1.cs

Textul întregului modul UnitTest1.cs este următorul:

utilizând Sistemul; utilizând System.Text; folosind System.Collections.Generic; folosind System.Linq; folosind Microsoft.VisualStudio.TestTools.UnitTesting; folosind MinApp; namespace TestMinApp {/// <summary> /// Descrierea sumară pentru UnitTest1 /// </ summary> [TestClass] clasa publică UnitTest1 {public UnitTest1 () {// // TODO: Adăugați logica constructorului aici //} privat TestContext testContextInstance; /// <summary> /// Obține sau stabilește contextul testului. /// </ summary> public TestContext TestContext {get {retur testContextInstance; } set {testContextInstance = valoare; }} #region Atribute suplimentare de testare // puteți utiliza testele dvs. // // Utilizați ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Folosiți ClassCleanup pentru a rula codul după ce toate testele dintr-o clasă au executat // [ClassCleanup ()] // public static void MyClassCleanup () {} // // Utilizați TestInitialize pentru a rula codul înainte de a executa fiecare test // [TestInitialize ()] // public void MyTestInitialize () {} // // Utilizați TestCleanup ) {} // #regiunea [TestMethod] public void TestMin () {// // TODO: Adăugați logica de testare aici // int min; min = program. Min (3, 4, 5); Assert .AreEqual (2, min); }}}

5. Rulați testul și verificați rezultatul testului

În Microsoft Visual Studio 2010, un meniu special de comenzi numit Test este implementat pentru lucrul cu testele Unit.

Pentru a executa un test de execuție, selectați una din comenzi.

sau

Test -> Run -> Toate testele în soluție

așa cum se arată în figura 8.

Fig. 8. Apelați comanda de test de pornire și vizualizați rezultatul.

După efectuarea testului, rezultatul poate fi văzut în partea de jos a ferestrei Rezultate teste. Așa cum se poate vedea din figură, testul nu este trecut. Acest lucru este logic, deoarece în funcția Assert.AreEqual () comparăm numerele 2 și 3, care sunt diferite. Aici, numărul 2 este introdus în loc de 3.

Dacă în locul numărului 2 introduceți răspunsul corect - numărul 3 (minim între 3, 4, 5), atunci testul va fi trecut (Figura 9). În acest caz, textul metodei TestMin () va fi după cum urmează:

... [TestMethod] void public TestMin () {// // TODO: Adăugați logica de testare aici // int min; min = program. Min (3, 4, 5); Assert .AreEcal (3, min); } ...

Fereastra rezultată este prezentată în Figura 9.

Fig. 9. Rezultatul testului pentru caz, dacă introduceți răspunsul corect

Acum putem concluziona că funcția Min () pentru acest caz funcționează corect.

6. Rezultatul. Interacțiunea dintre proiecte

În această lucrare se formează două proiecte în soluție. Un proiect MinApp conține funcția Min () pe care doriți să o testați. Al doilea proiect TestMinApp conține metode de testare.

În Microsoft Visual Studio 2010, fiecare proiect este lansat utilizând diferite comenzi de meniu. Deci, proiectul MinApp este lansat în mod standard din meniul Executare. Și proiectul TestMinApp este lansat din meniul special Test.

Subiecte conexe