NUnit

Den här artikeln handlar om ramverket för C#-enhetstestning. För NGINX webbapplikationsserver, se NGINX Unit .
NUnit
Originalförfattare Charlie Poole, James Newkirk, Alexei Vorontsov, Michael Two, Philip Craig, Rob Prouse, Simone Busoli, Neil Colvin
Utvecklare
NUnit-projektet, .NET Foundation
Stabil frisättning
3.13.2 / 27 april 2021 ; 22 månader sedan ( 2021-04-27 )
Förvar github .com /nunit
Skrivet i C#
Operativ system .NET Framework , Mono
Typ Enhetstestverktyg _
Licens MIT-licens för 3.0, BSD-stil (modifierad zlib-licens ) för 2.x
Hemsida www .nunit .org

NUnit är ett ramverk för enhetstestning med öppen källkod för .NET Framework och Mono . Det tjänar samma syfte som JUnit gör i Java- världen och är ett av många program i xUnit -familjen. [ citat behövs ]

Funktioner

  • Tester kan köras från en konsollöpare, i Visual Studio via en testadapter eller via tredje parts löpare.
  • Tester kan köras parallellt.
  • Starkt stöd för datadrivna tester.
  • Stöder flera plattformar inklusive .NET Core , Xamarin Mobile , Compact Framework och Silverlight .
  • Varje testfall kan läggas till i en eller flera kategorier för att möjliggöra selektiv körning.

NUnit tillhandahåller en konsollöpare (nunit3-console.exe), som används för batchkörning av tester. Konsollöparen fungerar genom NUnit Test Engine, som ger den möjlighet att ladda, utforska och utföra tester. När tester ska köras i en separat process använder motorn sig av programmet nunit-agent för att köra dem. [ citat behövs ]

NUnitLite löpare kan användas i situationer där en enklare löpare är mer lämplig. Det låter utvecklare skapa självkörande tester. [ citat behövs ]

Påståenden

NUnit tillhandahåller en rik uppsättning påståenden som statiska metoder för Assert -klassen. Om ett påstående misslyckas återkommer inte metodanropet och ett fel rapporteras. Om ett test innehåller flera påståenden kommer alla som följer efter det som misslyckades inte att köras. Av denna anledning är det vanligtvis bäst att försöka få ett påstående per test. [ citat behövs ]

Nunit 3.x stöder flera påståenden.


  

       

     
    
          
          
    
 [Test]  public  void  ComplexNumberTest  ()  {  ComplexNumber  result  =  SomeCalculation  ();  Påstå  .  Multiple  (()  =>  {  Assert  .  AreEqual  (  5.2  ,  resultat  .  RealPart  ,  "Real part"  );  Assert  .  AreEqual  (  3.9  ,  resultat  .  ImaginaryPart  ,  "Imaginary del"  );  });  }

Klassisk

användes en separat metod av Assert -klassen för varje olika påstående. Det fortsätter att stödjas i NUnit, eftersom många föredrar det. [ citat behövs ]

Varje påståendemetod kan anropas utan meddelande, med ett enkelt textmeddelande eller med ett meddelande och argument. I det sista fallet formateras meddelandet med den angivna texten och argumenten. [ citat behövs ] 


   
        

   
        


   
        

   
        



 
 

 
 

 

 
 

 
  // Jämlikhet  hävdar  .  AreEqual  (  objekt  förväntat  ,  objekt  faktiskt  );  Påstå  .  AreEqual  (  objekt  förväntat  ,  objekt  faktiskt  ,  strängmeddelande  ,  params  objekt  []  parms  )  ;  Påstå  .  AreNotEqual  (  objekt  förväntat  ,  objekt  faktiskt  );  Påstå  .  AreNotEqual  (  objekt  förväntat  ,  objekt  faktiskt  ,  strängmeddelande  ,  params  objekt  []  parms  )  ;  // Identitet  hävdar  .  AreSame  (  objekt  förväntat  ,  objekt  faktiskt  );  Påstå  .  AreSame  (  objekt  förväntat  ,  objekt  faktiskt  ,  strängmeddelande  ,  params  objekt  []  parms  )  ;  Påstå  .  AreNotSame  (  objekt  förväntat  ,  objekt  faktiskt  );  Påstå  .  AreNotSame  (  objekt  förväntat  ,  objekt  faktiskt  ,  strängmeddelande  ,  params  objekt  []  parms  )  ;  // Condition asserts  // (För enkelhetens skull utelämnas metoder med meddelandesignaturer.)  Assert  .  IsTrue  (  bool  condition  );  Påstå  .  IsFalse  (  bool  condition  );  Påstå  .  IsNull  (  objekt  anObject  );  Påstå  .  IsNotNull  (  objekt  anObject  );  Påstå  .  IsNaN  (  dubbel  aDouble  );  Påstå  .  IsEmpty  (  sträng  aString  );  Påstå  .  IsNotEmpty  (  sträng  aString  );  Påstå  .  IsEmpty  (  ICollection  collection  );  Påstå  .  IsNotEmpty  (  ICollection  -samling  );

Begränsningsbaserad

Från och med NUnit 2.4 introducerades en ny Constraint-baserad modell. Detta tillvägagångssätt använder en enda metod av Assert -klassen för alla påståenden, och passerar ett Constraint- objekt som anger testet som ska utföras. Denna begränsningsbaserade modell används nu internt av NUnit för alla påståenden. Metoderna för det klassiska tillvägagångssättet har återimplementerats ovanpå denna nya modell. [ citat behövs ]

Exempel

Exempel på en NUnit testfixtur : [ citat behövs ] 

 
 

  

    
      
    
          
        
        
        
        
          
    





  

    
      
    
        
        
             
	    
        
        
        
	         

        
        
                  
    
    
     
    
          
    





  

    
      
    
           
                  
         
          
    





  

    
      
    
        
                                 
                                 
                  
    
 använder  NUnit.Framework  ;  [TestFixture]  public  class  ExampleTestOfNUnit  {  [Test]  public  void  TestMultiplication  ()  {  Assert  .  AreEqual  (  4  ,  2  *  2  ,  "Multiplikation" )  ;  // På motsvarande sätt, eftersom version 2.4 NUnit erbjuder en ny och  // mer intuitiv påståendesyntax baserad på begränsningsobjekt  // [http://www.nunit.org/index.php?p=constraintModel&r=2.4.7]:  Assert  .  Det  (  2  *  2  ,  är  .  EqualTo  (  4  ),  "Multiplikationsbegränsningsbaserad" )  ;  }  }  // Följande exempel visar olika sätt att skriva samma undantagstest.  [TestFixture]  public  class  AssertThrowsTests  {  [Test]  public  void  Tests  ()  {  // .NET 1.x  Assert  .  Throws  (  typeof  (  ArgumentException  ),  ny  TestDelegate  (  MethodThatThrows )  );  // .NET 2.0  Säkerställ  .  Throws  <  ArgumentException  >(  MethodThatThrows )  ;  Påstå  .  Kastar  <  ArgumentException  >(  delegate  {  throw  new  ArgumentException  ();  });  // Använder C# 3.0  Assert  .  Kastar  <  ArgumentException  >(  ()  =>  {  throw  new  ArgumentException  ();  });  }  void  MethodThatThrows  ()  {  throw  new  ArgumentException  ();  }  }  // Det här exemplet visar användningen av returvärdet för att utföra ytterligare verifiering av undantaget.  [TestFixture]  public  class  UsingReturnValue  {  [Test]  public  void  TestException  ()  {  MyException  ex  =  Assert  .  Kastar  <  MyException  >(  delegate  {  throw  new  MyException  (  "meddelande"  ,  42  )  ; });  Påstå  .  Det  (  ex  .  Message  ,  Is  .  EqualTo  (  "meddelande" )  );  Påstå  .  Det  (  ex  .  MyParam  ,  Is  .  EqualTo  (  42  ));  }  }  // Det här exemplet gör samma sak med hjälp av överbelastningen som innehåller en begränsning.  [TestFixture]  public  class  UsingConstraint  {  [Test]  public  void  TestException  ()  {  Assert  .  Kastar  (  Är  .  Typ av  <  MyException  >()  .  And  .  Message  .  EqualTo  (  "meddelande"  )  .  And  .  Property  (  "MyParam"  ).  EqualTo  (  42  ),  delegera  {  throw  new  MyException  (  "meddelande"  ,  42  );  } );  }  }

Ramverket NUnit upptäcker metoden ExampleTestOfNUnit.TestMultiplication() automatiskt genom reflektion . [ citat behövs ]

Tillägg

FireBenchmarks är ett tillägg som kan registrera exekveringstid för enhetstester och generera XML , CSV , XHTML prestandarapporter med diagram och historikspårning. Dess huvudsakliga syfte är att göra det möjligt för en utvecklare eller ett team som arbetar med en agil metodik för att integrera prestandamått och analys i enhetstestmiljön , att enkelt kontrollera och övervaka utvecklingen av ett mjukvarusystem när det gäller algoritmisk komplexitet och systemresursbelastning. [ citat behövs ]

NUnit.Forms är en expansion till NUnits kärna och är också öppen källkod. Den tittar specifikt på att utöka NUnit för att kunna hantera testning av användargränssnittselement i Windows Forms . Från och med januari 2013 är Nunit.Forms i Alpha-utgåvan, och inga versioner har släppts sedan maj 2006. [ citat behövs ]

NUnit.ASP är en utvidgning av kärnan i NUnit-ramverket och är också öppen källkod. Den tittar specifikt på att utöka NUnit för att kunna hantera testning av användargränssnittselement i ASP.Net. [ citat behövs ]

Se även

Bibliografi

  •   Hunt, Andrew; Thomas, David (2007). Pragmatisk enhetstestning i C# med NUnit, 2nd Ed. The Pragmatic Bookshelf (Raleigh), 2007. ISBN 0-9776166-7-3 .
  •   Newkirk, Jim; Vorontsov, Alexei (2004). Testdriven utveckling i Microsoft .NET. Microsoft Press (Redmond), 2004. ISBN 0-7356-1948-4 .
  •   Hamilton, Bill (2004). NUnit Pocket Reference . O'Reilly (Cambridge), 2004. ISBN 0-596-00739-6 .

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=NUnit&oldid=1119651951 "