Archive for the 'Polyscopia' Category

XP Programming: Part 2 Testing is Fundamental

Sunday, October 8th, 2006

One of the cornerstones of the type of Extreme Programming (is it more Agile Modeling?) that I am interested in pursuing is unit testing. You start with your requirements and build use cases from them. You take your use cases and build unit tests that test the functionality displayed in the use case. I want everything to be documented and the documentation to flow all the way back to the requirements document. This way, you can pursue changed requirements through the use cases and unit tests down to the objects that support them.

To get started with unit testing, grab NUnit from http://www.nunit.org/ and take it for a spin. I have used NUnit in a project before, and loved the structure that it provided. Test-driven development is when you begin your process by writing tests that cover your requirements and then write code until they all pass. Start with a simple sample testing suite:

PLAIN TEXT
C#:
  1. using System;
  2. using NUnit.Framework;
  3. namespace Reservation
  4. {
  5.     [TestFixture]
  6.     public class PolyscopiaUnitTests
  7.     {
  8.        
  9.         [SetUp]
  10.         public void Init()
  11.         {
  12.         }
  13.        
  14.         [TearDown]
  15.         public void Destroy()
  16.         {
  17.         }
  18.        
  19.         [Test]
  20.         public void MigrateObject()
  21.         {
  22.             Assert.Fail("This is a test failure");
  23.         }
  24.     }
  25. }

and add tests that cover your requirements. Writing good unit tests is not as easy as it sounds, it takes time and effort. While you are creating your tests, you are also defining the solution set that your program will generate. As you develop your code, your goal should be to reduce the number of tests that fail.

So how do you integrate this into your NAnt build file? This is something I have never done before, but it turns out that you would simply add a section to compile your unit test dll and then change the test block as follows:

PLAIN TEXT
XML:
  1. <target name="compileUnitTests">
  2.     <csc target="library" output="${basename}UnitTests.dll" debug="${debug}">
  3.       <sources>
  4.         <include name="${basename}UnitTests.cs"/>
  5.       </sources>
  6.       <references>
  7.         <include name="System.dll"/>
  8.         <include name="System.Data.dll"/>
  9.         <include name="c:\Program Files (x86)\NUnit-Net-2.0 2.2.8\bin\nunit.framework.dll"/>
  10.         <include name="c:\Program Files (x86)\NUnit-Net-2.0 2.2.8\bin\nunit.core.extensions.dll"/>
  11.         <include name="c:\Program Files (x86)\NUnit-Net-2.0 2.2.8\bin\nunit.util.dll"/>
  12.         <include name="c:\Program Files (x86)\NUnit-Net-2.0 2.2.8\bin\nunit.testutilities.dll"/>
  13.       </references>
  14.     </csc>
  15.   </target>
  16.  
  17.  
  18.   <target name="test" depends="compile,compileUnitTests">
  19.     <nunit2>
  20.       <formatter type="Plain" />
  21.       <test assemblyname="${basename}UnitTests.dll"/>
  22.     </nunit2>
  23.   </target>

Be sure and note the reference section and the nunit2 section.

Another topic that I would like to pursue is Spec#, an extension to the C# language to allow for provable code. See: http://research.microsoft.com/specsharp/ for more information on it. I will be trying to decide how to integrate it into my process.

It is also good to note and acknowledge that the mechanisms that work for a single individual may not scale to a group of 5 or, worse yet, a group of 500. I am going to attempt to keep to procedures that appear to be scalable enough to handle groups of up to 20 programmers. I will also try and identify those pieces that I feel will have trouble scaling beyond that.

Posted in Code, Projects, XP Programming, Programming, Polyscopia | No Comments »