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); }