N Unit Presentation
Upcoming SlideShare
Loading in...5
×
 

N Unit Presentation

on

  • 2,941 views

 

Statistics

Views

Total Views
2,941
Views on SlideShare
2,941
Embed Views
0

Actions

Likes
0
Downloads
106
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

N Unit Presentation N Unit Presentation Presentation Transcript

  • NUnit – A Unit Test Framework for .Net
  • Topics
    • What is NUnit ?
    • Features
    • Writing a Unit Test
    • Code Examples
    • Pros and Cons
    • Conclusion
  • NUnit framework
    • NUnit framework is port of JUnit framework from java and Extreme Programming (XP). This is an open source product. You can download it from http:// www.nunit.org .
    • The NUnit framework is developed from ground up to make use of .NET framework functionalities.
    • NUnit is a unit-testing framework for all .Net languages.
    • It is written entirely in C#.
    • NUnit is much the same as all the Extreme Programming test frameworks (xUnits)
    • NUnit was initially ported from JUnit.
    • It uses an Attribute based programming model. It loads test assemblies in separate application domain hence we can test an application without restarting the NUnit test tools.
    • The NUnit further watches a file/assembly change events and reload it as soon as they are changed. With these features in hand a developer can perform develop and test cycles sides by side.
  • What NUnit Framework is not:
    • It is not Automated GUI tester.
    • It is not a scripting language, all test are written in .NET supported language e.g. C#, VC, VB.NET, J# etc.
    • It is not a benchmark tool.
    • Passing the entire unit test suite does not mean software is production ready.
    • NUnit is simple to understand and easy to learn.
    • Object Oriented.
    • NUnit is flexible - Test code can be in any .Net language.
    • NUnit uses the "attribute" feature of .NET to identify tests.
    Features
  • Download & Installation
    • http://www.nunit.org
    • http://nunit.org/download.html
    • http://sourceforge.net/projects/nunit/
    • Download Nunit-2.2.0.msi from http:// nunit.org/download.html and install nunit.
    • Add nunit.frameworks.dll to your project references. This dll resides in nunitin folder.
    • The next few screen shots show how to add this dll file if your project has been opened as a classlibrary .
  • Simple concepts
    • . Test fixture : a class that contains one ore more test methods
    • . Test method : a method that executes a specific test
    • . Test runner : an application that finds and executes test methods on test fixtures
    • . Assertion : a Boolean expression that describes what must be true when some
    • action has been executed
    • . Expected Exception : the type of an Exception we expect to be thrown during
    • execution of a test method
    • . Setup : Code that is run before every test method is executed (eg, logging in as a
    • particular user or initializing a singleton)
    • . Teardown : Code that is run after every test method has finished (eg, deleting rows
    • from a table that were inserted during the test)
    • Cons
    • C based extensions not available.
    • Lack of awareness among .Net Community.
    • Pros
    • NUnit is Open Source and highly extensible.
    • Platform independent.
    • Simple and easy to learn syntax.
    • When integrated with NAnt, can be used for incremental projects.
  • The Input & Output of nUnit NUnit Dll, exe file XML file (Optional) Processing details on the GUI or Command prompt
  • Writing Unit Test Code
    • Every Class must have a corresponding Test Class named Test ClassName
    • One test method per public method, named test MethodName.
    • In each test method, test good results and failures
    • Every Test Class must have the attribute [TestFixture]
    • Each Test Method must have the attribute [Test]
    • Other Attributes include
      • SetUp / Teardown
      • ExpectedException ( typeof( Exception))
      • Explicit
      • Ignore
  • Select the Solution explorer mode
  • Right click references and select Add reference
  • Select Browse
  • Goto the nunitin directory, choose nunit.framework.dll and press open.
  • Now press ok in the Add reference page
  • The dll has been added to your reference list.
  • In your code, add using nunit.framework.
  • Add testfixture to your program
  • TestFixture Example
    • [TestFixture]
    • public class calcTest{
    • [Test]
    • public void AdditionTests(){
    • calculator cal=new calculator();
    • cal.Addition(5,10); //CASE 1
    • Assert.AreEqual(15,cal.output());
    • cal.Addition(-5,10); // CASE 2
    • Assert.AreEqual(15,cal.output());
    • }
    • [Test]
    • public void DivisionTests(){
    • calculator cal=new calculator();
    • cal.Division(10,2); // CASE 1
    • Assert.AreEqual(5,cal.output());
    • cal.Division(10,0); //CASE 2
    • Assert.AreEqual(2,cal.output());
    • }
    • }//for testfixture
  • How to write your test code
    • Suppose you want to test the functions in a class, your testfixture(test stub) should look somewhat like this
    • using NUnit.Framework;
    • Namespace sample1{
    • public class sampleclass(){
    • public void func1(){}
    • }//for sampleclass
    • [TestFixture]
    • public class sampleTest(){
    • [Test]
    • public void test1(){
    • testcase1;
    • testcase2;
    • }//for test1()
    • }//for sampleTest textfixture
    • }//for namespace
  • Calculator Example
    • using System;
    • using NUnit.Framework;
    • namespace ClassLibrary1
    • {
    • public class calculator
    • {
    • private int result;
    • public void Addition(int num1,int num2){
    • result=num1+num2;
    • }
    • public int output(){
    • return result;
    • }
    • public void Division(int num1,int num2){
    • if(num2==0){
    • throw new DivideByZeroException();
    • }
    • result = num1/num2;
    • }
    • }
  • Calculator Example cont…
    • [TestFixture]
    • public class calcTest
    • {
    • [Test]
    • public void AdditionTests(){
    • calculator cal=new calculator();
    • cal.Addition(5,10);Console.Write("TESTING 5+10 ");
    • Assert.AreEqual(15,cal.output());
    • cal.Addition(-5,10);Console.Write("TESTING -5+10 ");
    • Assert.AreEqual(5,cal.output());
    • }
    • [Test]
    • public void DivisionTests(){
    • calculator cal=new calculator();
    • cal.Division(10,2); Console.Write("TESTING 10div2 ");
    • Assert.AreEqual(5,cal.output());
    • cal.Division(10,0); Console.Write("TESTING 10div0 ");
    • Assert.AreEqual(0,cal.output());
    • }
    • }//for testfixture
    • }//for namespace
  • Build the Project
    • After the testfixture is complete, build the project. This will create a dll file which will reside in projectnameindebug folder.
  • LOCATION of dll
    • In this example I am copying the dll file from projectnameindebug folder to nunitin folder for my convenience.
    • But this is not a requirement when we are testing and the dll can be run from projectnameindebug folder.
  • Location of exe files
  • Starting the GUI from console
    • The GUI can be started from the console by executing
    • nunit-gui.exe [ inputfilename ][ options ]
    • Ex: nunit-gui.exe nunit.tests.dll –run
    • This option will load the dll file and run the test.
    • * Options with their values are separated by an equal, colon or a space.
  • Starting the GUI from console
    • nunit-gui.exe [inputfilename][options]
    • Options:
    • /help short format: /?
    • /config=STR project config to load
    • /noload suppress loading of last proj
    • /run Automatically run after load
    • /fixture=STR Fixture to test
  • GUI MODE
    • The steps to be followed are
      • Load the Dll file.
      • Select Run.
      • View the errors if any on the GUI screen.
      • Save the output XML if necessary.
  • Select open in the NUNIT GUI
  • Select the dll which you want to test(In this case, we have moved the dll to the nunitin folder)
  • Runs Perfectly
  • Tests Fail
  • To save the output in an XML file
  • Writing in the output file
    • In the GUI mode , the user must specify that he/she wants to save the output. No xml output file is automatically created on the users behalf.
    • But in Console mode , a XML file is created even if not specified by the user.
  • Console mode
    • The command to execute the exe in console mode is
    • nunit-console.exe [filename] [option]
    • Example:
    • nunit-console.exe classlibrary1.dll -XML=ourfile.xml
  • The different options are
    • Nunit-console [inputfiles][options]
    • Options
    • /Fixture=STR Fixture to test
    • /config=STR project configuration to load
    • /XML=STR Name of XML output file
    • /transform=STR name of transform file
    • /xmlConsole display XML to the console
    • /output=STR File to receive test output (short :/out=STR)
    • /err=STR File to receive test error output
    • /labels Label each test in stdout
    • /include = STR list of categories to include
    • /exclude = STR list of categories to exclude
    • /noshadow disable shadow option
    • /thread runs thread on a separate thread
    • /wait wait for input before closing console window
    • /nologo Do not display the logo
    • /help Display help (short format: /?)
  • Runs Perfectly
  • Test Fails
  • Output file
    • As mentioned earlier, in console mode the xml file is automatically created as testresult.xml in the nunitin folder.
    • The user can change the name of the output file by saying -XML = newfilename.xml as shown in the previous slide.
  • Now lets Examine the Output file (test passed)
  • Test Failed
  • Failure message(1 message)
  • Test Failure(2 tests)
  • Proposed Architecture
    • The architecture which has been proposed by the architect is
      • The user shall run his tests in the console mode of the nUnit tool after the dll has been created by the nAnt tool.
      • The output XML file shall be sent to the User Interface to accommodate information about the user, date, time and other related information.
  • NUNIT
    • Thank you