Advanced Unit Testing, Part IV - Fixture Setup/Teardown, Test Repetition And Performance Tests

using System;
using System.Collections;
using System.Reflection;
using System.Threading;

using KALib;

namespace UTCore
{
	public class MethodItem
	{
		private Assembly assembly;
		private string namespaceName;
		private string className;
		private string methodName;
		private object[] attributes;
		private MethodInfo methodInfo;
		private delegate void UnitTestDelegate();

		// test options
		private bool ignore;
		private string ignoreReason;
		private UnitTest.ExpectedExceptionAttribute eea;
		private int sequence;
		private int minOPS;
		private int repeatCount;
		private int repeatDelay;
		private int maxK;
		private int currentRep;
		private ArrayList requires;
		private Hashtable processExceptions;

		private long startTime;
		private long stopTime;
		private long executionTime;

		private int startMem;
		private int endMem;

		public object[] Attributes
		{
			get {return attributes;}
		}

		public bool Ignore
		{
			get {return ignore;}
			set {ignore=value;}
		}

		public string IgnoreReason
		{
			get {return ignoreReason;}
			set {ignoreReason=value;}
		}

		public UnitTest.ExpectedExceptionAttribute ExpectedException
		{
			get {return eea;}
			set {eea=value;}
		}

		public Hashtable ReverseProcessExpectedException
		{
			get {return processExceptions;}
		}

		public int Sequence
		{
			get {return sequence;}
			set {sequence=value;}
		}

		public ArrayList Requirements
		{
			get {return requires;}
		}

		public override string ToString()
		{
			return methodName;
		}

		public long ExecutionTime
		{
			get {return executionTime;}
		}

		public int MinOPS
		{
			get {return minOPS;}
			set {minOPS=value;}
		}

		public int RepeatCount
		{
			set {repeatCount=value;}
			get {return repeatCount;}
		}

		public int RepeatDelay
		{
			set {repeatDelay=value;}
			get {return repeatDelay;}
		}

		public int CurrentRep
		{
			set {currentRep=value;}
			get {return currentRep;}
		}

		public int MemoryUsed
		{
			get {return endMem-startMem;}
		}

		public int MaxK
		{
			get {return maxK;}
			set {maxK=value;}
		}

		public MethodItem(Assembly assembly, string namespaceName, string className, string methodName, MethodInfo methodInfo)
		{
			this.assembly=assembly;
			this.namespaceName=namespaceName;
			this.className=className;
			this.methodName=methodName;
			this.methodInfo=methodInfo;
			attributes=methodInfo.GetCustomAttributes(true);
			sequence=0;
			requires=new ArrayList();
			processExceptions=new Hashtable();
			maxK=-1;
			minOPS=-1;
			repeatCount=1;
			repeatDelay=-1;
			eea=null;
			ignore=false;
			ignoreReason="";
			startMem=0;
			endMem=0;
		}

		public void AddRequires(string methodName)
		{
			requires.Add(methodName);
		}

		public void Invoke(object classInstance)
		{
			// Delegates requires that methods have a specific signature and are public.
			// Delegates are faster than "methodInfo.Invoke".

			Type utdType=typeof(UnitTestDelegate);
			UnitTestDelegate utd=Delegate.CreateDelegate(utdType, classInstance, methodName) as UnitTestDelegate;

//			startMem=GC.GetTotalMemory(false);
			startMem=ProcessMemory.WorkingSet;
			startTime=HiResTimer.Ticks;
			try
			{
				utd();
			}
			catch(Exception e)
			{
				throw(e);
			}
			finally
			{
				// execution time cannot be zero.  If it is, set to a minimum of 1 tick
				// this prevents problems with calculating operations per second, which would
				// otherwise result in a divide by zero error.
				stopTime=HiResTimer.Ticks;
//				endMem=GC.GetTotalMemory(false);
				endMem=ProcessMemory.WorkingSet;
				executionTime=(stopTime==startTime ? 1 : stopTime-startTime);
			}

// The invoke function allows us to call functions with different parameter lists, and ones that are not public.
// However, this changes how we handle exceptions

//			try
//			{
//				methodInfo.Invoke(classInstance, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.Static, null, null, null);
//			}
//			catch(Exception e)
//			{
//				throw(e.InnerException);
//			}
		}
	}
}