1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
using System;
using System.Collections.Generic;
using System.Linq;
using Mono.Cecil;
using Mono.Linker.Tests.Cases.Expectations.Metadata;
using Mono.Linker.Tests.Extensions;
using Mono.Linker.Tests.TestCases;
namespace Mono.Linker.Tests.TestCasesRunner
{
public class TestCaseCollector
{
private readonly NPath _rootDirectory;
private readonly NPath _testCaseAssemblyPath;
public TestCaseCollector (string rootDirectory, string testCaseAssemblyPath)
: this (rootDirectory.ToNPath (), testCaseAssemblyPath.ToNPath ())
{
}
public TestCaseCollector (NPath rootDirectory, NPath testCaseAssemblyPath)
{
_rootDirectory = rootDirectory;
_testCaseAssemblyPath = testCaseAssemblyPath;
}
public IEnumerable<TestCase> Collect ()
{
return Collect (AllSourceFiles ());
}
public TestCase Collect (NPath sourceFile)
{
return Collect (new[] { sourceFile }).FirstOrDefault ();
}
public IEnumerable<TestCase> Collect (IEnumerable<NPath> sourceFiles)
{
_rootDirectory.DirectoryMustExist ();
_testCaseAssemblyPath.FileMustExist ();
using (var caseAssemblyDefinition = AssemblyDefinition.ReadAssembly (_testCaseAssemblyPath.ToString ())) {
foreach (var file in sourceFiles) {
if (CreateCase (caseAssemblyDefinition, file, out TestCase testCase))
yield return testCase;
}
}
}
public IEnumerable<NPath> AllSourceFiles ()
{
_rootDirectory.DirectoryMustExist ();
foreach (var file in _rootDirectory.Files ("*.cs")) {
yield return file;
}
foreach (var subDir in _rootDirectory.Directories ()) {
if (subDir.FileName == "bin" || subDir.FileName == "obj" || subDir.FileName == "Properties")
continue;
foreach (var file in subDir.Files ("*.cs", true)) {
var relativeParents = file.RelativeTo (_rootDirectory);
// Magic : Anything in a directory named Dependencies is assumed to be a dependency to a test case
// and never a test itself
// This makes life a little easier when writing these supporting files as it removes some constraints you would previously have
// had to follow such as ensuring a class exists that matches the file name and putting [NotATestCase] on that class
if (relativeParents.RecursiveParents.Any (p => p.Elements.Any () && p.FileName == "Dependencies"))
continue;
// Magic: Anything in a directory named Individual is expected to be ran by it's own [Test] rather than as part of [TestCaseSource]
if (relativeParents.RecursiveParents.Any (p => p.Elements.Any () && p.FileName == "Individual"))
continue;
yield return file;
}
}
}
public TestCase CreateIndividualCase (Type testCaseType)
{
_rootDirectory.DirectoryMustExist ();
_testCaseAssemblyPath.FileMustExist ();
var pathRelativeToAssembly = $"{testCaseType.FullName.Substring (testCaseType.Module.Name.Length - 3).Replace ('.', '/')}.cs";
var fullSourcePath = _rootDirectory.Combine (pathRelativeToAssembly).FileMustExist ();
using (var caseAssemblyDefinition = AssemblyDefinition.ReadAssembly (_testCaseAssemblyPath.ToString ())) {
if (!CreateCase (caseAssemblyDefinition, fullSourcePath, out TestCase testCase))
throw new ArgumentException ($"Could not create a test case for `{testCaseType}`. Ensure the namespace matches it's location on disk");
return testCase;
}
}
private bool CreateCase (AssemblyDefinition caseAssemblyDefinition, NPath sourceFile, out TestCase testCase)
{
var potentialCase = new TestCase (sourceFile, _rootDirectory, _testCaseAssemblyPath);
var typeDefinition = FindTypeDefinition (caseAssemblyDefinition, potentialCase);
testCase = null;
if (typeDefinition == null) {
Console.WriteLine ($"Could not find the matching type for test case {sourceFile}. Ensure the file name and class name match");
return false;
}
if (typeDefinition.HasAttribute (nameof (NotATestCaseAttribute))) {
return false;
}
// Verify the class as a static main method
var mainMethod = typeDefinition.Methods.FirstOrDefault (m => m.Name == "Main");
if (mainMethod == null) {
Console.WriteLine ($"{typeDefinition} in {sourceFile} is missing a Main() method");
return false;
}
if (!mainMethod.IsStatic) {
Console.WriteLine ($"The Main() method for {typeDefinition} in {sourceFile} should be static");
return false;
}
testCase = potentialCase;
return true;
}
private static TypeDefinition FindTypeDefinition (AssemblyDefinition caseAssemblyDefinition, TestCase testCase)
{
var typeDefinition = caseAssemblyDefinition.MainModule.GetType (testCase.ReconstructedFullTypeName);
// For all of the Test Cases, the full type name we constructed from the directory structure will be correct and we can successfully find
// the type from GetType.
if (typeDefinition != null)
return typeDefinition;
// However, some of types are supporting types rather than test cases. and may not follow the standardized naming scheme of the test cases
// We still need to be able to locate these type defs so that we can parse some of the metadata on them.
// One example, Unity run's into this with it's tests that require a type UnityEngine.MonoBehaviours to exist. This tpe is defined in it's own
// file and it cannot follow our standardized naming directory & namespace naming scheme since the namespace must be UnityEngine
foreach (var type in caseAssemblyDefinition.MainModule.Types) {
// Let's assume we should never have to search for a test case that has no namespace. If we don't find the type from GetType, then o well, that's not a test case.
if (string.IsNullOrEmpty (type.Namespace))
continue;
if (type.Name == testCase.Name) {
// This isn't foolproof, but let's do a little extra vetting to make sure the type we found corresponds to the source file we are
// processing.
if (!testCase.SourceFile.ReadAllText ().Contains ($"namespace {type.Namespace}"))
continue;
return type;
}
}
return null;
}
}
}
|
