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

using System;

using KALib;

namespace UTCore
{
	public abstract class TestUnitAttribute
	{
		protected ClassItem ci;
		protected MethodItem mi;
		protected object attr;

		private long ticks;
		private double secs;
		private string time;

		public ClassItem TestClass
		{
			get {return ci;}
		}

		public MethodItem TestMethod
		{
			get {return mi;}
		}

		public string Time
		{
			get {return time;}
			set {time=value;}
		}

		public double dTime
		{
			get {return secs;}
			set
			{
				secs=value;
				time=String.Format("{0:0.0000000}", secs);
			}
		}

		public TestUnitAttribute()
		{
		}

		public abstract void SelfRegister(TestFixture tf);

		public void Initialize(ClassItem ci, MethodItem mi, object attr)
		{
			this.ci=ci;
			this.mi=mi;
			this.attr=attr;
		}

		public object CreateClass()
		{
			object obj=ci.Create();
			return obj;
		}

		public virtual void Invoke(object classInstance)
		{
			// make sure we time exceptions as well.
			try
			{
				mi.Invoke(classInstance);
			}
			catch(Exception e)
			{
				throw(e);
			}
			finally
			{
				ticks=mi.ExecutionTime;
				secs=(double)ticks/HiResTimer.TicksPerSecond;
				time=String.Format("{0:0.0000000}", secs);
			}
		}
	}

	public class NullTestUnitAttribute : TestUnitAttribute
	{
		public override void Invoke(object classInstance)
		{
		}

		public override void SelfRegister(TestFixture tf)
		{
		}

	}

	public class TestFixtureAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.AddTestFixtureAttribute(this);
		}
	}

	public class ProcessTestAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.IsProcessTest=true;
		}
	}

	public class FixtureSetUpAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.AddFixtureSetUpAttribute(this);
		}
	}

	public class FixtureTearDownAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.AddFixtureTearDownAttribute(this);
		}
	}

	public class SequenceAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			UnitTest.SequenceAttribute sa=attr as UnitTest.SequenceAttribute;
			mi.Sequence=sa.Order;
		}
	}

	public class RequiresAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			UnitTest.RequiresAttribute ra=attr as UnitTest.RequiresAttribute;
			mi.AddRequires(ra.PriorTestMethod);
		}
	}

	public class TestAttribute : TestUnitAttribute
	{
		public enum TestState
		{
			Untested=0,
			NotRun,
			Pass,
			Ignore,
			Fail,
		}

		TestState state;
		string result;

		public TestState State
		{
			get {return state;}
			set {state=value;}
		}

		public string Result
		{
			get {return result;}
			set {result=value;}
		}

		public bool IgnoreTest
		{
			get {return mi.Ignore==true;}
		}

		public string IgnoreReason
		{
			get {return mi.IgnoreReason;}
		}

		public Type ExpectedExceptionType
		{
			get
			{
				if (mi.ExpectedException==null)
				{
					return null;
				}
				else
				{
					return mi.ExpectedException.ExceptionType;
				}
			}
		}

		public TestAttribute()
		{
			state=TestState.Untested;
			result="";
		}

		public override void SelfRegister(TestFixture tf)
		{
			tf.AddTestAttribute(this);
		}
	}

	public class TestSetUpAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.AddTestSetUpAttribute(this);
		}
	}

	public class TestTearDownAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			tf.AddTestTearDownAttribute(this);
		}
	}

	public class ExpectedExceptionAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.ExpectedException=attr as UnitTest.ExpectedExceptionAttribute;
		}
	}

	public class ReverseProcessExpectedExceptionAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.ReverseProcessExpectedException.Add((attr as UnitTest.ReverseProcessExpectedExceptionAttribute).ExceptionType, attr);
		}
	}

	public class IgnoreAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.Ignore=true;
			mi.IgnoreReason=(attr as UnitTest.IgnoreAttribute).Reason;
		}
	}

	public class MinOperationsPerSecondAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.MinOPS=(attr as UnitTest.MinOperationsPerSecondAttribute).MinOPS;
		}
	}

	public class RepeatAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.RepeatCount=(attr as UnitTest.RepeatAttribute).RepeatCount;
			mi.RepeatDelay=(attr as UnitTest.RepeatAttribute).RepeatDelay;
		}
	}

	public class MaxKMemoryAttribute : TestUnitAttribute
	{
		public override void SelfRegister(TestFixture tf)
		{
			mi.MaxK=(attr as UnitTest.MaxKMemoryAttribute).MaxK;
		}
	}
}