private void SetupFakeReturnValue(ISuite suite, ReturnedFromAttribute attribute, FieldInfo field)
{
var fake = suite.GetMemberValue <object>(attribute.FakeField);
var returnValue = field.GetValue(suite);
this.InvokeGenericMethod("SetupFakeCall", new[] { fake, returnValue }, new[] { field.FieldType });
}
private void FolderSearch(string sDir, ISuite parentSuite)
{
foreach (string d in Directory.GetDirectories(sDir))
{
var info = new DirectoryInfo(d);
if ((info.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
if (UtilityService.IsTestDir(d))
{
LoadTestCase(info, parentSuite);
}
else if (UtilityService.IsSuiteDir(d))
{
ISuite suite = LoadSuite(info, parentSuite);
FolderSearch(d, suite);
}
else
{
if (OnNotifyLoadErrors != null)
{
OnNotifyLoadErrors("\n" + info.Name +
" error loading script. skipped!");
}
}
}
}
public T CreateFor <T> (ISuite <T> suiteInstance)
{
var suiteType = suiteInstance.GetType();
var subjectType = typeof(T);
var constructors = subjectType.GetConstructors(MemberBindings.Instance);
if (constructors.Length != 1)
{
throw new EvaluationException(string.Format("Missing default constructor for subject type '{0}'.", subjectType.Name));
}
var constructor = constructors.Single();
var constructorParameters = constructor.GetParameters();
var suiteFields = suiteType.GetFieldsWithAttribute <InjectedAttribute>().Select(x => x.Item1).ToList();
var arguments = constructorParameters.Select(x => GetArgumentValue(x, suiteInstance, suiteFields)).ToArray();
if (arguments.Any(x => x == null))
{
var missingParameters = constructorParameters.Select((x, i) => Tuple.Create(x, arguments[i]))
.Where(x => x.Item2 == null)
.Select(x => x.Item1.AssertNotNull().Name);
throw new EvaluationException(
string.Format(
"Missing constructor arguments for subject type '{0}': {1}",
subjectType.Name,
string.Join(", ", missingParameters.ToArray())));
}
return((T)constructor.Invoke(arguments));
}
private void CreateAndAssignAuto(ISuite suite, ITestDataGenerator generator, AutoDataAttribute attribute, FieldInfo field)
{
var autoData = this.InvokeGenericMethod("CreateAutoData", new object[] { generator, attribute.MaxRecursionDepth }, new[] { field.FieldType });
attribute.CurrentSuite = suite;
attribute.Mutate(autoData);
field.SetValue(suite, autoData);
}
private void LoadTestCase(FileSystemInfo info, ISuite parentSuite)
{
ITestCase testcase = parentSuite.CreateTestCase(info.Name);
(testcase as IRedefineTestNodeProperties).FullFileName = info.FullName + "\\content.txt";
testcase.Load(this);
testcase.IsRunnable = true;
NotifyOnAfterCreateNode(testcase);
}
private ISuite LoadSuite(FileSystemInfo info, ISuite parentSuite)
{
ISuite suite = parentSuite.CreateSuite(info.Name);
(suite as IRedefineTestNodeProperties).FullFileName = info.FullName + "\\content.txt";
suite.Load(this);
suite.IsRunnable = UtilityService.IsRunnable(info.FullName);
NotifyOnAfterCreateNode(suite);
return(suite);
}
private void SetupFakes(ITestController testController, ISuite suite)
{
var fieldsWithAttribute = suite.GetType().GetFieldsWithAttribute <ReturnedFromAttribute>().ToList();
if (fieldsWithAttribute.Count == 0)
{
return;
}
testController.AddAction <SetupExtension>("<Setup_Fakes>", x => fieldsWithAttribute.ForEach(t => SetupFakeReturnValue(suite, t.Item2, t.Item1)));
}
public void Extend(ITestController testController, ISuite suite)
{
var fields = suite.GetType().GetFields(MemberBindings.Instance).ToList();
if (fields.Count == 0)
{
return;
}
testController.AddAction <SetupExtension>("<Reset_Instance_Fields>", x => fields.ForEach(f => f.SetValue(suite, f.FieldType.GetDefaultValue())));
}
private object GetArgumentValue(ParameterInfo parameter, ISuite suiteInstance, IList <FieldInfo> suiteFields)
{
var argumentField = suiteFields.SingleOrDefault(x => x.Name.Equals(parameter.Name, StringComparison.OrdinalIgnoreCase));
if (argumentField == null)
{
return(null);
}
return(argumentField.IsStatic ? argumentField.GetValue(null) : suiteInstance.GetMemberValue <object>(argumentField.Name));
}
private void CreateFakes(ITestController testController, ISuite suite)
{
var fieldsWithAttribute = suite.GetType().GetFieldsWithAttribute <FakeBaseAttribute>().ToList();
if (fieldsWithAttribute.Count == 0)
{
return;
}
testController.AddAction <SetupExtension>("<Create_Fakes>", x => fieldsWithAttribute.ForEach(t => CreateAndAssignFake(suite, t.Item2, t.Item1)));
}
public ClassSuiteController(
SuiteProvider provider,
ISuite <TSubject> suite,
IEnumerable <ITestExtension> testExtensions,
IControllerFactory controllerFactory,
IOperationSorter operationSorter)
: base(provider, suite, testExtensions, operationSorter)
{
_provider = provider;
_suite = suite;
_controllerFactory = controllerFactory;
_testSetupCleanupTuples = new List <Tuple <Action <ITestContext <TSubject> >, Action <ITestContext <TSubject> > > >();
}
public void ResolveIncludes(ISuite rootSuite, Hashtable lookupTable, NotifyEventDelegate onErrorIncluding)
{
foreach (ITestNode testNode in lookupTable.Values)
{
if (!testNode.IsRunnable)
{
continue;
}
foreach (ITestNode childNode in testNode)
{
var linkNode = childNode as ITestLink;
if (linkNode != null)
{
string searchNodeName = linkNode.ContentText;
searchNodeName = searchNodeName.Replace("/", "\\");
if (searchNodeName.ToLower().Contains("!include"))
{
searchNodeName = searchNodeName.Substring(9).Trim();
}
string rootSuitePath = rootSuite.Name + "\\";
if (searchNodeName.StartsWith("."))
{
searchNodeName = searchNodeName.Replace(".\\", rootSuitePath);
}
else
{
if (!searchNodeName.ToLower().StartsWith(rootSuitePath.ToLower()))
{
searchNodeName = rootSuitePath + searchNodeName;
}
}
searchNodeName = searchNodeName.Replace(".", "\\");
searchNodeName = searchNodeName.Replace("/", "\\");
var includeNode = lookupTable[searchNodeName.ToUpper()] as ITestNode;
bool containsRunnableNode = false;
ContainsRunnableItems(includeNode, ref containsRunnableNode);
if ((includeNode != null) && (!includeNode.IsRunnable) && (!containsRunnableNode))
{
linkNode.AddChildNode(includeNode);
}
else if (onErrorIncluding != null)
{
onErrorIncluding(linkNode);
}
}
}
}
}
public void LoadScripts()
{
string pathToScan = UtilityService.GetParentSuitePath(_testPathRelativeToTestRootPath);
if (UtilityService.IsTestDir(pathToScan))
{
LoadTestCase(new DirectoryInfo(pathToScan), RootSuite);
}
else
{
ISuite parentSuite = LoadSuite(new DirectoryInfo(pathToScan), RootSuite);
FolderSearch(pathToScan, parentSuite);
}
_allNodes = RootSuite.GetTreeChildEnumerator().ToHashtableByPath();
RootSuite.GetTreeChildEnumerator().ApplyLevelNumbers();
UtilityService.ResolveIncludes(RootSuite, _allNodes, OnErrorProcessingNodes);
}
public void Extend(ITestController testController, ISuite suite)
{
var suiteType = suite.GetType();
var fieldsWithAttribute = suiteType.GetFieldsWithAttribute <AutoDataAttribute>()
.OrderBy(x => x.Item1.Name)
.SortTopologically(IsDependentAutoData).ToList();
if (fieldsWithAttribute.Count == 0)
{
return;
}
var seed = GetSeed(suiteType);
var random = new Random(seed);
var configuration = GetAutoDataConfiguration(suiteType);
var generator = TestDataGeneratorFactory.Create(x => configuration(x).UseRandom(random));
// TODO: add seed to data
testController.AddAction <SetupExtension>(
string.Format("<Create_AutoData><{0}>", seed),
x => fieldsWithAttribute.ForEach(t => CreateAndAssignAuto(suite, generator, t.Item2, t.Item1)));
}
object IBenchmark.Execute(ISuite suite) => Execute((T)suite);
public ClassSuiteController(SuiteProvider provider, ISuite suite, IEnumerable <ITestExtension> testExtensions, IOperationSorter operationSorter)
: base(provider, operationSorter)
{
_suite = suite;
_testExtensions = testExtensions;
}
bool IBenchmark.Verify(ISuite suite, object result) => Verify((T)suite, (TResult)result);
private bool IsSuiteEqual(ISuite suite1,ISuite suite2)
{
Type type_1 = suite1.GetType();
Type type_2 = suite2.GetType();
if (!type_1.Equals(type_2))
{
return false;
}
else
{
if (suite1 is CellSuite)
{
CellSuite cellsuite1 = suite1 as CellSuite;
CellSuite cellsuite2 = suite2 as CellSuite;
return ListEquals(cellsuite1.CaseList, cellsuite2.CaseList);
}
else if (suite1 is BinSuite)
{
BinSuite cellsuite1 = suite1 as BinSuite;
BinSuite cellsuite2 = suite2 as BinSuite;
return ListEquals(cellsuite1.CaseList, cellsuite2.CaseList);
}
else
{
return false;
}
}
}
private void CreateAndAssignFake(ISuite suite, FakeBaseAttribute attribute, FieldInfo field)
{
var fake = this.InvokeGenericMethod("CreateFake", new object[] { attribute }, new[] { field.FieldType });
field.SetValue(suite, fake);
}
/// <summary>
/// 将Suite添加到指定List
/// </summary>
/// <param name="suiteList">List</param>
/// <param name="suite">Suite</param>
private void AddSuiteList(List<ISuite> suiteList, ISuite suite)
{
if (!suiteList.Contains(suite))
{
suiteList.Add(suite);
}
}
public void Extend(ITestController testController, ISuite suite)
{
CreateFakes(testController, suite);
SetupFakes(testController, suite);
}
public ClassSuiteController(SuiteProvider provider, ISuite suite, IEnumerable<ITestExtension> testExtensions, IOperationSorter operationSorter)
: base(provider, operationSorter)
{
_suite = suite;
_testExtensions = testExtensions;
}
protected ISuite AddSuite(ISuite suite)
{
AddChildNode(suite);
return(suite);
}
