DirectUnitTestDriverCore.ttinclude

<#@ assembly name="System.Core" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Globalization" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Threading.Tasks" #>
<#+
private const string TestDriverTestListProperty = "TestClasses";

/// <summary>
/// 	Generate direct test invocation driver code from test class informations.
/// </summary>
/// <param name="testClasses">A collection of test classes.</param>
private void GenerateTestDriver( IEnumerable<TestClass> testClasses )
{
	var testClassList = ( testClasses ?? Enumerable.Empty<TestClass>() ).ToArray();
#>
	/// <summary>
	///		Represents a test class which groups related tests and holds their states.
	/// </summary>
	public partial class TestClass
	{
		/// <summary>
		///		The null object for <see cref="Action" /> typed property.
		/// </summary>
		private static readonly Action Nop = () => {};

		/// <summary>
		///		The null object for <see cref="Action{TestClassInstance, object}"/> typed property.
		/// </summary>
		private static readonly Action<TestClassInstance, object> NoInitialization = ( c, i ) => {};

		/// <summary>
		///		Gets the name of the test class.
		/// </summary>
		/// <value>
		///		The name of the test class. This value will not be <c>null</c>.
		/// </value>
		public string Name { get; private set; }

		/// <summary>
		///		Gets the delegate for fixture level setup routine.
		/// </summary>
		/// <value>
		///		The delegate for fixture level setup routine. This value will not be <c>null</c> even if the underlying test class does not have any fixture level setup routines.
		/// </value>
		public Action FixtureSetup { get; set; }

		/// <summary>
		///		Gets the delegate for fixture level cleanup routine.
		/// </summary>
		/// <value>
		///		The delegate for fixture level cleanup routine. This value will not be <c>null</c> even if the underlying test class does not have any fixture level cleanup routines.
		/// </value>
		public Action FixtureCleanup { get; set; }

		/// <summary>
		///		Gets the count of test methods in the test class.
		/// </summary>
		/// <value>
		///		The ount of test methods in the test class.
		/// </value>
		public int MethodCount { get; private set; }

		/// <summary>
		///		The delegate which instantiate "test class" instance.
		/// </summary>
		private readonly Func<object> _instanceFactory;

		/// <summary>
		///		The delegate which initializes <see cref="TestClassInstance" /> instance with "test class" instance.
		/// </summary>
		private readonly Action<TestClassInstance, object> _testClassInstanceInitializer;

		/// <summary>
		///		Initializes a new instance.
		/// </summary>
		/// <param name="name">The name of the test class.</param>
		/// <param name="instanceFactory">The delegate which instantiate "test class" instance.</param>
		/// <param name="methodCount">The ount of test methods in the test class.</param>
		/// <param name="testClassInstanceInitializer">The delegate which initializes <see cref="TestClassInstance" /> instance with "test class" instance.</param>
		/// <exception cref="ArgumentException">The <paramref name="name"/> is <c>null</c> or empty.</exception>
		/// <exception cref="ArgumentNullException">The <paramref name="instanceFactory"/> is <c>null</c>.</exception>
		public TestClass( string name, Func<object> instanceFactory, int methodCount, Action<TestClassInstance, object> testClassInstanceInitializer )
		{
			if ( String.IsNullOrEmpty( name ) )
			{
				throw new ArgumentException( "name cannot be null nor empty.", "name" );
			}

			if ( instanceFactory == null )
			{
				throw new ArgumentNullException( "instanceFactory" );
			}

			this.Name = name;
			this._instanceFactory = instanceFactory;
			this._testClassInstanceInitializer = testClassInstanceInitializer ?? NoInitialization;
			this.MethodCount = methodCount;
			this.FixtureSetup = Nop;
			this.FixtureCleanup = Nop;
		}

		/// <summary>
		///		Creates a new, initialized <see cref="TestClassInstance" /> which represents instantiated test class information.
		/// </summary>
		/// <returns>
		///		The new, initialized <see cref="TestClassInstance" /> which represents instantiated test class information.
		/// </returns>
		public TestClassInstance NewTest()
		{
			var instance = this._instanceFactory();
			var result = new TestClassInstance( this.MethodCount );
			this._testClassInstanceInitializer( result, instance );
			return result;
		}
	}

	/// <summary>
	///		Represents instantiated test class information.
	/// </summary>
	public partial class TestClassInstance
	{
		// A test class intance will be hold via delegate for its instance methods.

		/// <summary>
		///		The null object for <see cref="Action" /> typed property.
		/// </summary>
		private static readonly Action Nop = () => {};

		/// <summary>
		///		Gets the delegate for per test setup routine.
		/// </summary>
		/// <value>
		///		The delegate for per test setup routine. This value will not be <c>null</c> even if the underlying test class does not have any per test setup routines.
		/// </value>
		public Action TestSetup { get; set; }

		/// <summary>
		///		Gets the delegate for per test cleanup routine.
		/// </summary>
		/// <value>
		///		The delegate for per test cleanup routine. This value will not be <c>null</c> even if the underlying test class does not have any per test cleanup routines.
		/// </value>
		public Action TestCleanup { get; set; }

		/// <summary>
		///		Gets the list of the test methods.
		/// </summary>
		/// <value>
		///		The list of the test methods. This value will not be <c>null</c>.
		/// </value>
		public IList<TestMethod> TestMethods { get; private set; }

		/// <summary>
		///		Initializes a new instance.
		/// </summary>
		/// <param name="methodCount">The ount of test methods in the test class.</param>
		public TestClassInstance( int methodCount )
		{
			this.TestMethods = new List<TestMethod>( methodCount );
			this.TestSetup = Nop;
			this.TestCleanup = Nop;
		}
	}

	/// <summary>
	///		Represents a test method.
	/// </summary>
	public partial class TestMethod
	{
		// "test case" is not supported.

		/// <summary>
		///		Gets the name of the test method.
		/// </summary>
		/// <value>
		///		The name of the test method. This value will not be <c>null</c>.
		/// </value>
		public string Name { get; private set; }

		/// <summary>
		///		Gets the delegate for instance methnod which is test method itself
		/// </summary>
		/// <value>
		///		The delegate for instance methnod which is test method itself. This value will not be <c>null</c>.
		/// </value>
		public Action Method { get; private set; }

		/// <summary>
		///		Initializes a new instance.
		/// </summary>
		/// <param name="name">The name of the test method.</param>
		/// <param name="method">The delegate for instance methnod which is test method itself.</param>
		/// <exception cref="ArgumentException">The <paramref name="name"/> is <c>null</c> or empty.</exception>
		/// <exception cref="ArgumentNullException">The <paramref name="method"/> is <c>null</c>.</exception>
		public TestMethod( string name, Action method )
		{
			if ( String.IsNullOrEmpty( name ) )
			{
				throw new ArgumentException( "name cannot be null nor empty.", "name" );
			}

			if ( method == null )
			{
				throw new ArgumentNullException( "method" );
			}

			this.Name = name;
			this.Method = method;
		}
	}

	/// <summary>
	///		Implements running environment agnostics test driver features.
	/// </summary>
	public partial class TestDriver
	{
		/// <summary>
		///		Gets the list of the test classes.
		/// </summary>
		/// <value>
		///		The list of the test classes. This value will not be <c>null</c>.
		/// </value>
		protected IList<TestClass> <#= TestDriverTestListProperty #> { get; private set; }

		/// <summary>
		///		Initializes a new instance.
		/// </summary>
		protected TestDriver()
		{
			this.<#= TestDriverTestListProperty #> = new List<TestClass>( <#= testClassList.Length #> );
			InitializeTestClasses( this.<#= TestDriverTestListProperty #> );
		}

		/// <summary>
		///		Fills intialized <see cref="TestClass" /> to specified list.
		/// </summary>
		private static void InitializeTestClasses( IList<TestClass> testClasses )
		{
<#+
	foreach ( var testClass in testClassList )
	{
		var friendlyName = testClass.TypeFullName;
		var lastDot = friendlyName.LastIndexOf( "." );
		if ( lastDot >= 0 && friendlyName.Length > lastDot + 2 )
		{
			friendlyName = friendlyName.Substring( lastDot + 1 );
		}

		var initializerName = GetInitializerClassName( testClass.TypeFullName );
#>
			{
				var testClass = 
					new TestClass( 
						"<#= friendlyName #>", 
						<#= initializerName #>.CreateInstance, 
						<#= testClass.TestMethods.Count #>,
						<#= initializerName #>.InitializeInstance
					 );
<#+
		GenerateActionAssignmentIfNotEmpty( testClass.FixtureSetup, "testClass.FixtureSetup", testClass.TypeFullName + ".{0}" );
		GenerateActionAssignmentIfNotEmpty( testClass.FixtureCleanup, "testClass.FixtureCleanup", testClass.TypeFullName + ".{0}" );
#>
				testClasses.Add( testClass );
			}

<#+
	} // foreach ( testClasses )

#>
		} // void InitializeTestClasses
	} // partial class TestDriver
<#+

	// To avoid UNetWeaver error, avoid lamdas as possible.
	foreach ( var testClass in testClassList )
	{
#>
	internal static class <#= GetInitializerClassName( testClass.TypeFullName ) #>
	{
		public static object CreateInstance()
		{
			return new <#= testClass.TypeFullName #>();
		}

		public static void InitializeInstance( TestClassInstance testClassInstance, object testFixtureInstance )
		{
			var instance = ( ( <#= testClass.TypeFullName #> )testFixtureInstance );
<#+
		GenerateActionAssignmentIfNotEmpty( testClass.TestSetup, "testClassInstance.TestSetup", "instance.{0}" );
		GenerateActionAssignmentIfNotEmpty( testClass.TestCleanup, "testClassInstance.TestCleanup", "instance.{0}" );
		foreach ( var method in testClass.TestMethods )
		{
			if ( method.ArgumentsList.Count == 0 )
			{
#>
			testClassInstance.TestMethods.Add( new TestMethod( "<#= method.Name #>", new Action( instance.<#= method.Name #> ) ) );
<#+
			}
			else
			{
#>
			testClassInstance.TestMethods.Add(
				new TestMethod(
					"<#= method.Name #>",
					() => {
<#+
				foreach( var arguments in method.ArgumentsList )
				{
#>
						instance.<#= method.Name #>( <#= String.Join( ", ", arguments ) #> );
<#+
				}
#>
					}
				)
			);
<#+
			}
		}
#>
		}
	} 

<#+
	}
} // GenerateTestDriver

private void GenerateActionAssignmentIfNotEmpty( string value, string target, string expressionTemplate )
{
	if ( !String.IsNullOrEmpty( value ) )
	{
#>
<#= target #> = new Action( <#= String.Format( CultureInfo.InvariantCulture, expressionTemplate, value ) #> );
<#+
	}
}

/// <summary>
///		Returns the class name for initializer.
/// </summary>
/// <param name="typeFullName">The type full name of the test class.</param>
/// <returns>
///		The class name for initializer.
/// </returns>
private static string GetInitializerClassName( string typeFullName )
{
	return typeFullName.Replace( '.', '_' ) + "Initializer";
}

/// <summary>
///		Represents the test class for code generaton.
/// </summary>
private class TestClass
{
	public string TypeFullName { get; private set; }
	
	/// <summary>
	///		Gets or sets the name of fixture level test setup method.
	/// </summary>
	/// <value>
	///		The name for of fixture level test setup method. This value will be <c>null</c> if not exists.
	/// </value>
	public string FixtureSetup { get; set; }
	
	/// <summary>
	///		Gets or sets the name of fixture level test cleanup method.
	/// </summary>
	/// <value>
	///		The name for of fixture level test cleanup method. This value will be <c>null</c> if not exists.
	/// </value>
	public string FixtureCleanup { get; set; }

	/// <summary>
	///		Gets or sets the name of per test setup method.
	/// </summary>
	/// <value>
	///		The name for of per test setup method. This value will be <c>null</c> if not exists.
	/// </value>
	public string TestSetup { get; set; }

	/// <summary>
	///		Gets or sets the name of per test cleanup method.
	/// </summary>
	/// <value>
	///		The name for of per test cleanup method. This value will be <c>null</c> if not exists.
	/// </value>
	public string TestCleanup { get; set; }

	/// <summary>
	///		Gets the list of the test methods.
	/// </summary>
	/// <value>
	///		The list of the test methods. This value will not be <c>null</c>.
	/// </value>
	public IList<TestMethod> TestMethods { get; private set; }

	/// <summary>
	///		Initializes a new instance.
	/// </summary>
	/// <param name="name">The name of the test class.</param>
	/// <param name="methods">The test methods.</param>
	public TestClass( string typeFullName, IEnumerable<TestMethod> methods )
	{
		this.TypeFullName = typeFullName;
		this.TestMethods = methods == null ? new List<TestMethod>() : methods.ToList();
	}
}

/// <summary>
///		Represents the test method for code generaton.
/// </summary>
private struct TestMethod
{
	/// <summary>
	///		Gets the name of the test method.
	/// </summary>
	/// <value>
	///		The name of the test method. This value will not be <c>null</c>.
	/// </value>
	public string Name { get; private set; }

	/// <summary>
	///		Gets the arguments for the test method in C# syntax
	/// </summary>
	/// <value>
	/// 	The arguments for the test method in C# syntax. Each element is arguments for single test method invocation.
	/// 	This value will not be <c>null</c>.
	/// </value>
	public IList<IList<string>> ArgumentsList { get; private set; }

	/// <summary>
	///		Initializes a new instance.
	/// </summary>
	/// <param name="name">The name of the test method.</param>
	/// <param name="arguments">The arguments for the test method.</param>
	public TestMethod( string name, IList<IList<string>> argumentsList )
	{
		this.Name = name;
		this.ArgumentsList = argumentsList;
	}
}
#>