RoslynAnalyzerUnitTestExplorer.ttinclude

<#@ assembly name="System.Core" #>
<#@ assembly name="System.Runtime" #>
<#@ assembly name="System.Threading.Tasks" #>
<#@ assembly name="EnvDTE" #>
<#@ assembly name="$(DevEnvDir)PrivateAssemblies\Microsoft.CodeAnalysis.dll" #>
<#@ assembly name="$(DevEnvDir)PrivateAssemblies\Microsoft.CodeAnalysis.CSharp.dll" #>
<#@ assembly name="$(DevEnvDir)PrivateAssemblies\Microsoft.CodeAnalysis.Workspaces.dll" #>
<#@ assembly name="$(DevEnvDir)PrivateAssemblies\Microsoft.CodeAnalysis.Workspaces.Desktop.dll" #>
<#@ assembly name="$(DevEnvDir)PrivateAssemblies\System.Collections.Immutable.dll" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Globalization" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ import namespace="System.Threading.Tasks" #>
<#@ import namespace="Microsoft.CodeAnalysis" #>
<#@ import namespace="Microsoft.CodeAnalysis.CSharp" #>
<#@ import namespace="Microsoft.CodeAnalysis.CSharp.Syntax" #>
<#@ import namespace="Microsoft.CodeAnalysis.MSBuild" #>
<#@ import namespace="EnvDTE" #>
<#+
// This file is borrowed from UniRX (https://github.com/neuecc/UniRx/blob/master/Assets/UnitTests/UnitTests.tt)
// This file implicitly depends on DirectUnitTestDriverCore.ttinclude.

/// <summary>
///		Explores test classes/methods using EnvDTE and Roslyn Analyzer.
/// ><summary>
private class TestClassExplorer
{
	/// <summary>
	///		The type full name of "test class" inidicator attribute type.
	/// ><summary>
	private readonly string _testClassAttributeFullName;

	/// <summary>
	///		The type full name of "test method" inidicator attribute type.
	/// ><summary>
	private readonly string _testMethodAttributeFullName;

	/// <summary>
	///		The type full name of "fixture level test setip routine" inidicator attribute type.
	/// ><summary>
	private readonly string _fixtureSetupAttributeFullName;

	/// <summary>
	///		The type full name of "fixture level test cleanup routine" inidicator attribute type.
	/// ><summary>
	private readonly string _fixtureCleanupAttributeFullName;

	/// <summary>
	///		The type full name of "per test setip routine" inidicator attribute type.
	/// ><summary>
	private readonly string _testSetupAttributeFullName;

	/// <summary>
	///		The type full name of "per test cleanup routine" inidicator attribute type.
	/// ><summary>
	private readonly string _testCleanupAttributeFullName;

	/// <summary>
	///		The type full name of "skipping specified test" inidicator attribute type.
	/// ><summary>
	private readonly string _testSkippingAttributeFullName;

	/// <summary>
	///		The type full name of "test case" inidicator attribute type.
	/// ><summary>
	private readonly string _testCaseAttributeFullName;

	/// <summary>
	///		The array of type full names of attributes which should mark significant methods including test method, setup method, etc.
	/// ><summary>
	private readonly string[] _significantMethodAttributeFullNames;

	/// <summary>
	///		Initializes a new instance.
	/// </summary>
	/// <param name="testClassAttributeFullName">The type full name of "test class" inidicator attribute type.</param>
	/// <param name="testMethodAttributeFullName">The type full name of "test method" inidicator attribute type.</param>
	/// <param name="fixtureSetupAttributeFullName">The type full name of "fixture level test setip routine" inidicator attribute type.</param>
	/// <param name="fixtureCleanupAttributeFullName">The type full name of "fixture level test cleanup routine" inidicator attribute type.</param>
	/// <param name="testSetupAttributeFullName">The type full name of "per test setip routine" inidicator attribute type.</param>
	/// <param name="testCleanupAttributeFullName">The type full name of "per test cleanup routine" inidicator attribute type.</param>
	/// <param name="testSkippingAttributeFullName">The type full name of "skipping specified test" inidicator attribute type.</param>
	/// <param name="testCaseAttributeFullName">The type full name of "test case" inidicator attribute type.</param>
	public TestClassExplorer( string testClassAttributeFullName, string testMethodAttributeFullName, 
		string fixtureSetupAttributeFullName, string fixtureCleanupAttributeFullName,
		string testSetupAttributeFullName, string testCleanupAttributeFullName,
		string testSkippingAttributeFullName, string testCaseAttributeFullName
	)
	{
		this._testClassAttributeFullName = testClassAttributeFullName;
		this._testMethodAttributeFullName = testMethodAttributeFullName;
		this._fixtureSetupAttributeFullName = fixtureSetupAttributeFullName;
		this._fixtureCleanupAttributeFullName = fixtureCleanupAttributeFullName;
		this._testSetupAttributeFullName = testSetupAttributeFullName;
		this._testCleanupAttributeFullName = testCleanupAttributeFullName;
		this._testSkippingAttributeFullName = testSkippingAttributeFullName;
		this._testCaseAttributeFullName = testCaseAttributeFullName;
		this._significantMethodAttributeFullNames = 
			new [] { testMethodAttributeFullName, fixtureSetupAttributeFullName, fixtureCleanupAttributeFullName, testSetupAttributeFullName, testCleanupAttributeFullName };
	}

	/// <summary>
	///		Returns a new instance for NUnit or NUnitLite.
	/// </summary>
	/// <returns>
	///		 A new instance for NUnit or NUnitLite.
	/// </returns>
	public static TestClassExplorer ForNUnit()
	{
		return 
			new TestClassExplorer(
				"NUnit.Framework.TestFixtureAttribute",
				"NUnit.Framework.TestAttribute",
				"NUnit.Framework.TestFixtureSetUpAttribute",
				"NUnit.Framework.TestFixtureTearDownAttribute",
				"NUnit.Framework.SetUpAttribute",
				"NUnit.Framework.TearDownAttribute",
				"NUnit.Framework.IgnoreAttribute",
				"NUnit.Framework.TestCaseAttribute"
			);
	}

	/// <summary>
	///		Explores specified projects and returns found test classes.
	/// </summary>
	/// <param name="host">The host object which implements <see cref="IServiceProvider"/>.</param>
	/// <param name="projectName">The name of exploring test project.</param>
	/// <returns>
	///		 A sequence of the found test classes.
	/// </returns>
	public IEnumerable<TestClass> FindTestClasses( object host, string projectName )
	{
		var serviceProvider = host as IServiceProvider;
		var dte = serviceProvider.GetService( typeof( DTE ) ) as DTE;
		var targetProj = dte.Solution.Projects.Cast<EnvDTE.Project>().First( x => x.Name == projectName );
		return GetClassesAsync( targetProj.FullName ).Result.OrderBy( x => x.TypeFullName );
	}

	/// <summary>
	///		Explores specified projects and returns found test classes asynchronously.
	/// </summary>
	/// <param name="csProjectPath">The path to C# project.</param>
	/// <returns>
	///		 A pending asynchronous operation. Its value is sequence of the found test classes.
	/// </returns>
	private async Task<IEnumerable<TestClass>> GetClassesAsync( string csProjectPath )
	{
		var workspace = MSBuildWorkspace.Create();
		var project = await workspace.OpenProjectAsync( csProjectPath );

		var compilation = await project.GetCompilationAsync();

		return 
			compilation.SyntaxTrees
				.SelectMany( st => 
					{ 
						var semModel = compilation.GetSemanticModel( st );

						return
							st.GetRoot()
							.DescendantNodes()
							.OfType<ClassDeclarationSyntax>()
							.Select( x => semModel.GetDeclaredSymbol( x ) );
					} 
				).SelectMany( x => x.GetMembers(), ( @class, member ) => new { @class, member } )
				.Where( x => x.member.GetAttributes().Any( a => this._significantMethodAttributeFullNames.Contains( GetAttributeName( a ) ) ) )
				.Distinct()
				.GroupBy( x => x.@class.Name )
				.Where( g => g.SelectMany( x => x.@class.GetAttributes() ).Any( a => GetAttributeName( a ) == this._testClassAttributeFullName ) )
				.Select( g => 
					new TestClass( 
						g.Key,
						g.Where( x =>
							x.member.GetAttributes().Any( a => GetAttributeName( a ) == this._testMethodAttributeFullName ) // Only test methods
							&& x.member.GetAttributes().All( a => GetAttributeName( a ) != this._testSkippingAttributeFullName ) // Excludes "Ignored" method
						).Select( x => 
							new TestMethod(
								x.member.Name,
								// only test data from attribute constructor arguments are supported.
								x.member.GetAttributes().Where( a => GetAttributeName( a ) == this._testCaseAttributeFullName ).Select( a => GetTestData( a ) ).ToArray()
							)
						).OrderBy( x => x.Name )
					)
					{
						FixtureSetup = GetSpecialMethodName( g.Select( x => x.member ), this._fixtureSetupAttributeFullName ),
						FixtureCleanup = GetSpecialMethodName( g.Select( x => x.member ), this._fixtureCleanupAttributeFullName ),
						TestSetup = GetSpecialMethodName( g.Select( x => x.member ), this._testSetupAttributeFullName ),
						TestCleanup = GetSpecialMethodName( g.Select( x => x.member ), this._testCleanupAttributeFullName )
					}
				).OrderBy( x => x.TypeFullName )
				.ToArray();
	} // GetClassNamesAsync

	// From Roslyn source
	private static readonly SymbolDisplayFormat QualifiedNameOnlyFormat =
		new SymbolDisplayFormat(
			globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
			typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces
		);

	/// <summary>
	///		Gets the type full name of the attribute.
	/// </summary>
	/// <param name="attribute">The attribute.</param>
	/// <returns>
	///		 The type full name of the attribute.
	/// </returns>
	private static string GetAttributeName( AttributeData attribute )
	{
		return attribute.AttributeClass.ToDisplayString( QualifiedNameOnlyFormat );
	}

	/// <summary>
	/// 	Gets test data for specified "test case".
	/// </summary>
	/// <param name="attribute">The attribute.</param>
	/// <returns>
	///		The test data for the case. The element should be primitive value types, string or null.
	/// </returns>
	private static string[] GetTestData( AttributeData attribute )
	{
		TypedConstant[] constructorArguments =  attribute.ConstructorArguments.ToArray();
		switch ( constructorArguments.Length )
		{
			case 1:
			{
				if ( constructorArguments[ 0 ].Kind == TypedConstantKind.Array )
				{
					// [Attr(new object[]{ a, b, c })]
					// Returns array's content (Values is IEnumerable<TypedConstant>)
					return constructorArguments[ 0 ].Values.Select( ToCSharpLiteral ).ToArray();
				}
				else
				{
					goto default;
				}
			}
			default:
			{
					// [Attr( a, b, c )]
				return constructorArguments.Select( ToCSharpLiteral ).ToArray();
			}
		}
	}

	/// <summary>
	/// 	Converts a Roslyn <see cref="TypedConstant" /> to a C# literal representation.
	/// </summary>
	/// <param name="constant">A Roslyn <see cref="TypedConstant" />.</param>
	/// <returns>A C# literal representation.</returns>
	private static string ToCSharpLiteral( TypedConstant constant )
	{
		if ( constant.IsNull )
		{
			return "null";
		}

		switch( constant.Kind )
		{
			case TypedConstantKind.Enum:
			{
				var value = constant.Value.ToString();
				if ( Regex.IsMatch( value, @"^\d+$" ) )
				{
					return "( " + constant.Type.Name + " )" + constant.Value;
				}
				else
				{
					return constant.Type.Name + "." + constant.Value;
				}
			}
			case TypedConstantKind.Type:
			{
				// TODO: generic type
				return "typeof( " + constant.Value + " )";
			}
			case TypedConstantKind.Primitive:
			{
				switch( Type.GetTypeCode( constant.Value.GetType() ) )
				{
					case TypeCode.String:
					{
						return "@\"" + constant.Value.ToString().Replace( "\"", "\"\"" ) + "\"";
					}
					case TypeCode.Char:
					{
						return "'" + constant.Value + "'";
					}
					case TypeCode.Int64:
					{
						return constant.Value + "L";
					}
					case TypeCode.UInt32:
					{
						return constant.Value + "U";
					}
					case TypeCode.UInt64:
					{
						return constant.Value + "UL";
					}
					case TypeCode.Single:
					{
						return constant.Value + "F";
					}
					case TypeCode.Decimal:
					{
						return constant.Value + "M";
					}
					default:
					{
						return constant.Value.ToString();
					}
				}
			}
			default:
			{
				return "__ERROR(" + constant.Kind + ")__";
			}
		}
	}

	/// <summary>
	///		Gets the name of the special method which marked with specified attribute.
	/// </summary>
	/// <param name="m">The sequence of <see cref="ISymbol" /> which represents member of the type.</param>
	/// <param name="attributeFullName">The type full name of the attribute.</param>
	/// <returns>
	///		 The name of the special method which marked with specified attribute.
	/// </returns>
	private static string GetSpecialMethodName( IEnumerable<ISymbol> m, string attributeFullName )
	{
		var found = m.FirstOrDefault( x => x.GetAttributes().Any( a => GetAttributeName( a ) == attributeFullName ) );
		return found == null ? null : found.Name;
	}
} // TestClassExplorer

#>