Advanced Unit Testing, Part III - Testing Processes

using System;

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

		public ClassItem TestClass
		{
			get {return ci;}
		}

		public MethodItem TestMethod
		{
			get {return mi;}
		}

		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 void Invoke(object classInstance)
		{
			mi.Invoke(classInstance);
		}
	}

	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 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;
		}
	}
}