Writing tests with Zanebug is easy. There are 4 steps that you must take:

Although Zanebug contains several other attributes and features, the above steps are at the heart of any unit test.

In order to demonstrate a full test, let's use a modified version of the famous "Hello World" example. We first create a simple class with two methods:

using System;

namespace Examples
{
	public class HelloWorld
	{
		public static string SayHello()
		{
			return "Hello!";
		}

		public static string SayHello(string name)
		{
			return String.Format("Hello {0}!", name);
		}
	}
}

In a traditional testing environment, this would most likely be validated with a simple console application:

using System;
using Examples;

namespace ConsoleApplication1
{
	class Class1
	{
		[STAThread]
		static void Main(string[] args)
		{
			Console.WriteLine(HelloWorld.SayHello());
			Console.WriteLine(HelloWorld.SayHello("Sean"));
			Console.ReadLine();
		}
	}
}

This would produce the following output:

Hello!

Hello Sean!

Unfortunately, this is a very rudimentary way to test and relies on human interaction to validate that a component behaved correctly. The more complex the component, the more error-prone.

Using Zanebug, automated tests can be easily written and rerun on a continual basis. To address the above example, we would write the following unit test:

using System;
using Adapdev.UnitTest;
using Examples;

namespace Examples.Test
{
	[TestFixture]
	public class HelloWorldTest
	{
		[Test]
		public void SayHello()
		{
			Assert.AreEqual("Hello!", HelloWorld.SayHello());
		}

		[Test]
		public void SayHelloWithName()
		{
			Assert.AreEqual("Hello Sean!", HelloWorld.SayHello("Sean"));
		}
	}
}

The above test is very simple. The first test, SayHello(), simple validates that the text being returned from the HelloWorld.SayHello() method is the expected text. The second test does the same thing, but tests the result with a name being passed in.

In both instances, the Assert class is used to test behavior. Assert is a key part of writing unit tests, since it does the actual work. When an assertion is performed, only one of two outcomes is possible -- correct or incorrect. If the response is correct, then that portion of the test passes. If the response is incorrect, an AssertionException is thrown and the test immediately fails without continuing.

The Assert class contains multiple methods. Listed below are some of the more common ones (see the API documentation for a full list):

Test methods can (and normally should) contain multiple assertions. Revisiting our original HelloWorld example, we'll add some more assertions:

using System;
using Adapdev.UnitTest;
using Examples;

namespace Examples.Test
{
	[TestFixture]
	public class HelloWorldTest
	{
		[Test]
		public void SayHello()
		{
			Assert.AreEqual("Hello!", HelloWorld.SayHello());
			Assert.IsTrue(HelloWorld.SayHello().Length == 6);
		}

		[Test]
		public void SayHelloWithName()
		{
			Assert.AreEqual("Hello Sean!", HelloWorld.SayHello("Sean"));
			Assert.IsTrue(HelloWorld.SayHello("Sean").Length == 11);
		}
	}
}

The multiple assertions in the above example don't add much value in this instance, but it gets the point across...

Now, to round things out, let's show an explicit example of a test failing:

using System;
using Adapdev.UnitTest;
using Examples;

namespace Examples.Test
{
	[TestFixture]
	public class HelloWorldTest
	{
		[Test]
		public void SayHello()
		{
			// Test passes and continues
			Assert.AreEqual("Hello!", HelloWorld.SayHello()); 

			// Test fails because length is 6
			Assert.IsTrue(HelloWorld.SayHello().Length == 5); 
		}

		[Test]
		public void SayHelloWithName()
		{
			// Test fails because the returned value is Hello instead of Bonjour
			Assert.AreEqual("Bonjour Sean!", HelloWorld.SayHello("Sean")); 

			// Not tested, since the test has already failed
			Assert.IsTrue(HelloWorld.SayHello("Sean").Length == 11); 
		}
	}
}

In summary, to write a test you need the following basic components: