An XML Compiler

/*
(c) 2005, Marc Clifton
All Rights Reserved
 
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer. 

Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution. 

Neither the name of the Marc Clifton, "Advanced Unit Test", "AUT", nor the names
of its contributors may be used to endorse or promote products derived from this
software without specific prior written permission. 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

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

using Vts.KALib;

namespace Vts.UTCore
{
//	[Serializable]
	public class MethodItem
	{
		[NonSerialized] private Assembly assembly;
		private string namespaceName;
		private string className;
		private string methodName;
		private object[] attributes;
		[NonSerialized] 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 long startMem;
		private long endMem;

		private int codePath;

		public int CodePath
		{
			get {return codePath;}
			set {codePath=value;}
		}

		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 == null) ? new UnitTest.ExpectedExceptionAttribute(null) : 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 long 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;
			codePath=-1;
		}

		public void AddCodePath(int codePath)
		{
			this.codePath=codePath;
		}

		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;

	         GC.Collect();
			startMem=GC.GetTotalMemory(true);
			if (MaxK!=-1)
			{
#if NET20
				startMem=Process.GetCurrentProcess().WorkingSet64;
#else
				startMem=Process.GetCurrentProcess().WorkingSet;
#endif
			}
			startTime=HiResTimer.Ticks;
			try
			{
				utd();
			}
			catch(Exception e)
			{
				Trace.WriteLine(e.Message);
				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);
            if (MaxK!=-1)
            {
#if NET20
				endMem=Process.GetCurrentProcess().WorkingSet64;
#else
				endMem=Process.GetCurrentProcess().WorkingSet;
#endif
            }
				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);
//			}
		}
	}
}