public NewTestResultSummaryEventArgs(ITest test, ITestResult result, ITestOutcomeFilter outcomeFilter, ITestResultSummary summary) { Test = test; Result = result; OutcomeFilter = outcomeFilter; Summary = summary; }
public void AddTest(ITest test) { if(test == null) throw new ArgumentNullException("test"); tests.Add(test); test.TestCompleted += TestOnTestCompleted; }
public OrganizationService(ITest test) { if(test == null) throw new ArgumentNullException("test"); this._test = test; }
/// <summary> /// Forwards the TestStarted event to all listeners. /// </summary> /// <param name="test">The test that just started.</param> public void TestStarted(ITest test) { System.Diagnostics.Debug.WriteLine(test.Name + " TEST STARTED"); System.Threading.Thread.Sleep(2000); foreach (TestListener listener in listeners) listener.TestStarted(test); }
private void Execute(ITest test, string methodPrefix) { var method = Reflect.GetNamedMethod(_ActionInterfaceType, methodPrefix + "Test"); var details = CreateTestDetails(test); Reflect.InvokeMethod(method, _Action, details); }
public static void RunTest(TestType type, int ThreadCount, CallbackFunction callBack, ITest target) { for (int i = 0; i < ThreadCount; i++) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (object sender, DoWorkEventArgs e) => { bool result = target.Test(); e.Result = result; }; worker.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs e) => { if (callBack != null) { if (e.Error != null) { callBack(type, (bool)e.Result); } else { callBack(type, false); } } }; worker.RunWorkerAsync(); } }
/// <summary> /// Initializes a new instance of the <see cref="NUnitTestRunner"/> class. /// </summary> /// <param name="testData">The test data.</param> public NUnitTestRunner(NUnitTestData testData) { _nunittest = testData; string nunitsuite = testData.Class + "," + testData.Assembly; _suite = GetSuite(nunitsuite); testData.Suite = _suite; }
public static void Queue( this IMessageBus messageBus, ITest test, Func<ITest, IMessageSinkMessage> createTestResultMessage, CancellationTokenSource cancellationTokenSource) { Guard.AgainstNullArgument("messageBus", messageBus); Guard.AgainstNullArgument("createTestResultMessage", createTestResultMessage); Guard.AgainstNullArgument("cancellationTokenSource", cancellationTokenSource); if (!messageBus.QueueMessage(new TestStarting(test))) { cancellationTokenSource.Cancel(); } else { if (!messageBus.QueueMessage(createTestResultMessage(test))) { cancellationTokenSource.Cancel(); } } if (!messageBus.QueueMessage(new TestFinished(test, 0, null))) { cancellationTokenSource.Cancel(); } }
/// <summary> /// Writes test info to a file /// </summary> /// <param name="test">The test to be written</param> /// <param name="outputPath">Path to the file to which the test info is written</param> public void WriteTestFile(ITest test, string outputPath) { using (StreamWriter writer = new StreamWriter(outputPath, false, Encoding.UTF8)) { WriteTestFile(test, writer); } }
/// <summary> /// Check whether the filter matches a test /// </summary> /// <param name="test">The test to be matched</param> /// <returns>True if it matches, otherwise false</returns> public override bool Match( ITest test ) { if (topLevel && test.RunState == RunState.Explicit) return false; return !baseFilter.Pass( test ); }
public void AddAllCategories( ITest test ) { AddCategories( test ); if ( test.IsSuite ) foreach( ITest child in test.Tests ) AddAllCategories( child ); }
public static void UnloadTestDomain() { if ( testDomain != null ) testDomain.Unload(); loadedTest = null; testDomain = null; }
/// <summary> /// Called when a test has just started /// </summary> /// <param name="test">The test that is starting</param> public void TestStarted(ITest test) { if (test.IsSuite) TC_TestSuiteStarted(test.Name); else TC_TestStarted(test.Name); }
public void BeforeTest(ITest test) { //Log.Write("START:" + test.FullName); if (!_configuration.GenerateReport) return; _start = DateTime.Now; }
public void SetUp() { MethodInfo fakeTestMethod1 = this.GetType().GetMethod("FakeTestMethod1", BindingFlags.Instance | BindingFlags.NonPublic); this.fakeTest1 = new NUnitTestMethod(fakeTestMethod1); MethodInfo fakeTestMethod2 = this.GetType().GetMethod("FakeTestMethod2", BindingFlags.Instance | BindingFlags.NonPublic); this.fakeTest2 = new NUnitTestMethod(fakeTestMethod2); }
private static void ExecuteEventExposureTest(string[] args) { _test = new XMLTest2(Path.Combine(GetExecutingDirectory(), args[0]), Path.Combine(GetExecutingDirectory(), args[1])); IResult result = _test.RunTest(); DisplayOutput(result); }
bool OnStart(XmlNode xml) { var testCase = FindTestCase(xml.Attributes["type"].Value, xml.Attributes["method"].Value); currentTest = new Xunit1Test(testCase, xml.Attributes["name"].Value); SendTestCaseMessagesWhenAppropriate(testCase); return messageSink.OnMessage(new TestStarting(currentTest)) && TestClassResults.Continue; }
private static void ExecutePuzzleTest() { _test = new XMLTest1(Path.Combine(GetExecutingDirectory(), "puzzle1.xml")); IResult result = _test.RunTest(); DisplayOutput(result); }
public void TestStarted(ITest test) { level++; prefix = new string('>', level); if(options.DisplayTestLabels == "On" || options.DisplayTestLabels == "All") outWriter.WriteLine("{0} {1}", prefix, test.Name); }
/// <summary> /// Construct a TestNode given a TestResult /// </summary> public TestSuiteTreeNode( TestResult result ) : base(result.Test.TestName.Name) { this.test = result.Test; this.result = result; UpdateImageIndex(); }
/// <summary> /// Initializes a new instance of the <see cref="TestUnitWithMetadata"/> class. /// </summary> /// <param name="testRun">The test run.</param> /// <param name="test"></param> /// <param name="assemblyName">Name of the assembly.</param> /// <param name="children">The children.</param> public TestUnitWithMetadata(TestRun testRun, ITest test, string assemblyName, List<TestUnitWithMetadata> children = null) { Children = children ?? new List<TestUnitWithMetadata>(); Test = new TestUnit(test, testRun, assemblyName); Results = new List<TestResult>(); AttachedData = new TestUnitAttachedData(); }
public static ITestResult Failed( ITest test, string message, Exception t) { return new SimpleTestResult(false, test.Name + ": " + message, t); }
private static string BuildStackTrace(Exception exception, ITest test, IEnumerable<string> traceMessages) { StringBuilder sb = new StringBuilder(); sb.AppendLine("SPECIFICATION:"); if (test.Properties.Contains(TestExtensions.MultilineNameProperty)) { foreach (var line in ((string)test.Properties[TestExtensions.MultilineNameProperty]).Split('\n')) sb.AppendLine(" " + line); } sb.AppendLine(); if (traceMessages.Count() > 0) { foreach (var line in traceMessages) sb.AppendLine(line); sb.AppendLine(); } sb.AppendLine(GetStackTrace(exception)); for (Exception innerException = exception.InnerException; innerException != null; innerException = innerException.InnerException) { sb.Append(Environment.NewLine); sb.Append("--"); sb.Append(innerException.GetType().Name); sb.Append(Environment.NewLine); sb.Append(GetStackTrace(innerException)); } return sb.ToString(); }
protected static void RunTest(ITest test) { int loops = Calibrate(test, TimeSpan.FromMilliseconds(1000)); var sw = new Stopwatch(); GC.Collect(); GC.WaitForPendingFinalizers(); var c1 = GC.CollectionCount(0); var c2 = GC.CollectionCount(1); var c3 = GC.CollectionCount(2); sw.Start(); test.DoTest(loops); sw.Stop(); c1 = GC.CollectionCount(0) - c1; c2 = GC.CollectionCount(1) - c2; c3 = GC.CollectionCount(2) - c3; var lps = (int)(loops / (sw.ElapsedMilliseconds / 1000.0)); Console.WriteLine("{0,-40} {1,20} loops/s, collections {2}/{3}/{4}", test.GetType().Name, lps, c1, c2, c3); }
private int ProcessTestCases(ITest test, ITestCaseDiscoverySink discoverySink, TestConverter testConverter) { int cases = 0; if (test.IsSuite) { foreach (ITest child in test.Tests) cases += ProcessTestCases(child, discoverySink,testConverter); } else { try { #if LAUNCHDEBUGGER Debugger.Launch(); #endif TestCase testCase = testConverter.ConvertTestCase(test); discoverySink.SendTestCase(testCase); cases += 1; } catch (System.Exception ex) { testLog.SendErrorMessage("Exception converting " + test.TestName.FullName, ex); } } return cases; }
public void AddCategories( ITest test ) { if (test.Categories != null) foreach (string name in test.Categories) if (NUnitFramework.IsValidCategoryName(name)) Add(name); }
//public AlgorithmEvaluator(AlgorithmExecutor executor, ICollection<ITest> tests, IAnswerEvaluator answerEvaluator, TimeSpan timeLimit) : this(tests, answerEvaluator, timeLimit) //{ // this.executor = executor; //} //public AlgorithmEvaluator(string algorithmFolder, ICollection<ITest> tests, IAnswerEvaluator answerEvaluator, TimeSpan timeLimit) // : this(new AlgorithmExecutor(algorithmFolder), tests, answerEvaluator, timeLimit) //{ //} //public void SetAlgorithm(AlgorithmExecutor newAlg) //{ // this.executor = newAlg; //} public int EvaluateWithTest(AlgorithmExecutor algorithm, ITest test, bool allowTimeLimit = false) { this.logWriter.WriteLine(); this.logWriter.WriteLine("Evaluating {0} with test {1}", algorithm.AlgorithmOwner, test.Name); try { algorithm.StartAlgorithm(); } catch (Win32Exception) { this.logWriter.WriteLine("--couldn't start algorithm"); return 0; } DateTime start = DateTime.Now; string algorithmAnswer = ""; try { Task<string> algorithmAnswerTask = Task.Run(() => algorithm.GetAnswerToInput(test.Input)); bool timeLimitReached = false; //Console.WriteLine("press enter"); //Console.ReadLine(); System.Threading.Thread.Sleep(timeLimit - TimeSpan.FromMilliseconds(100)); while (!algorithmAnswerTask.IsCompleted) { TimeSpan elapsed = DateTime.Now - start; if (elapsed > timeLimit) { this.logWriter.WriteLine("--time limit reached, killing algorithm"); algorithm.KillAlgorithm(); timeLimitReached = true; break; } } if (!timeLimitReached || allowTimeLimit) { this.logWriter.WriteLine("--attempting to retrieve output from algorithm"); algorithmAnswerTask.Wait(); algorithmAnswer += algorithmAnswerTask.Result; } else { return 0; } algorithm.KillAlgorithm(); //just in case } catch (Exception e) { this.logWriter.WriteLine("--unexpected error while evaluating: {0}", e.Message); } this.logWriter.Write("--algorithm output:\r\n{0}\r\n", algorithmAnswer); return this.evaluator.EvaluateAnswer(algorithmAnswer, test.Input, test.ExpectedOutput); }
/// <summary> /// Checks whether the OrFilter is matched by a test /// </summary> /// <param name="test">The test to be matched</param> /// <returns>True if any of the component filters match, otherwise false</returns> public override bool Match( ITest test ) { foreach( TestFilter filter in _filters ) if ( filter.Match( test ) ) return true; return false; }
/// <summary> /// Causes a test to be skipped if this PlatformAttribute is not satisfied. /// </summary> /// <param name="test">The test to modify</param> public void ApplyToTest(ITest test) { if (test.RunState != RunState.NotRunnable && !platformHelper.IsPlatformSupported(this)) { test.RunState = RunState.Skipped; test.Properties.Add(PropertyNames.SkipReason, platformHelper.Reason); } }
/// <summary> /// Check if a test matches the filter /// </summary> /// <param name="test">The test to match</param> /// <returns>True if it matches, false if not</returns> public override bool Match( ITest test ) { foreach( TestName testName in testNames ) if ( test.TestName == testName ) return true; return false; }
public void SetUp() { traceTestNameAttribute = new TraceTestNameAttribute(); fakeTest = Substitute.For <ITest>(); fakeTest.FullName.Returns("Foo"); }
protected override void UpdateTestClass(ITest test, ITypeDefinition typeDefinition) { var testClass = test as MSTestClass; testClass.Update(typeDefinition); }
private static bool HasChildIndex(ITest test) { return(test.Properties["childIndex"].Count > 0); }
public TestController(ILogger logger, ITest test) { this.logger = logger; this.test = test; }
public static IEnumerable <ITest> GetChildren(this ITest test) => GetChildren(test, true);
public Test2(ITest test) { Test = test; }
public int callInterface9(ITest itest) { itest.refProp = new TestClass(3); return(itest.refProp.testval); }
protected override XunitTestRunner CreateTestRunner(ITest test, IMessageBus messageBus, Type testClass, object[] constructorArguments, MethodInfo testMethod, object[] testMethodArguments, string skipReason, IReadOnlyList <BeforeAfterTestAttribute> beforeAfterAttributes, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) { return(new AspNetTestRunner(test, messageBus, testClass, constructorArguments, testMethod, testMethodArguments, skipReason, beforeAfterAttributes, aggregator, cancellationTokenSource)); }
/// <summary> /// Checks whether the CompositeFilter is matched by a test. /// </summary> /// <param name="test">The test to be matched</param> public abstract override bool Pass(ITest test);
/// <summary> /// Checks whether the CompositeFilter is matched by a test. /// </summary> /// <param name="test">The test to be matched</param> public abstract override bool Match(ITest test);
/// <summary> /// Checks whether the CompositeFilter is explicit matched by a test. /// </summary> /// <param name="test">The test to be matched</param> public abstract override bool IsExplicitMatch(ITest test);
public void AfterTest([NotNull] ITest test) { }
private static async Task UpdateAcl(ISession <PrivateAuthentication> session, ITest test, List <AclSpec> data) { await UpdateAcl(data)(session, test); }
public void AfterTest(ITest test) { _transactionScope.Dispose(); }
private static void RodarTeste(ITest classeTeste) { RootTest rootTest = new RootTest(classeTeste); rootTest.RunTests(); }
public int callInterface8(ITest itest) { itest.intProp = 3; return(itest.intProp); }
public override void AfterTest(ITest test) { SharedDatabaseLocator.Cleanup(); }
public int callInterface5(ITest itest) { return(itest.test5(new TestClass(2), new TestClass(3))); }
/// <summary> /// Match a test against a single value. /// </summary> public override bool Match(ITest test) { return(Match(test.FullName)); }
public int callInterface4(ITest itest) { return(itest.test4(2, 3).testval); }
public MyJob() { _test = MvcApplication.Container.Resolve <ITest>(); }
public int callInterface1(ITest itest) { return(itest.test1(2, 3)); }
int OnTick(ILua lua) { if (current_test == null) { if (ListOfTests.Count == 0 && !WasServerQuitTrigered) { if (IsEverythingSuccessful) { lua.Log("All tests were completed successfully!"); lua.Log("Test run time is " + DateTime.Now.Subtract(tests_start_time).TotalSeconds + " seconds"); File.WriteAllText("tests-success.txt", "Success!"); lua.Log("Shutting down game..."); lua.PushSpecial(SPECIAL_TABLES.SPECIAL_GLOB); lua.GetField(-1, "engine"); lua.GetField(-1, "CloseServer"); lua.MCall(0, 0); WasServerQuitTrigered = true; } else { lua.Log("There are no more tests to run. Some tests have failed. Check log.", true); lua.Log("Test run time is " + DateTime.Now.Subtract(tests_start_time).TotalSeconds + " seconds"); lua.Log("Shutting down game..."); lua.PushSpecial(SPECIAL_TABLES.SPECIAL_GLOB); lua.GetField(-1, "engine"); lua.GetField(-1, "CloseServer"); lua.MCall(0, 0); WasServerQuitTrigered = true; } } else if (ListOfTests.Count != 0) { ITest cur_test_inst = ListOfTests.First(); ListOfTests.RemoveAt(0); lua.Log("Starting test " + cur_test_inst.GetType().ToString()); Task <bool> cur_test_promise = cur_test_inst.Start(lua, this.lua_extructor, current_load_context); current_test = new Tuple <ITest, Task <bool> >(cur_test_inst, cur_test_promise); } } else { if (current_test.Item2.IsCompleted) { ITest curr_test_inst = current_test.Item1; Task <bool> curr_test_promise = current_test.Item2; current_test = null; if (curr_test_promise.IsCompletedSuccessfully) { if (curr_test_promise.Result) { lua.Log("Test " + curr_test_inst.GetType().ToString() + " was completed successfully"); } else { lua.Log("FAILED TEST " + curr_test_inst.GetType().ToString() + ". An exception was not thrown", true); this.IsEverythingSuccessful = false; } } else if (curr_test_promise.IsFaulted) { string exception_msg = ""; foreach (Exception e in curr_test_promise.Exception.InnerExceptions) { exception_msg += "\n" + e.GetType().ToString() + " - " + e.Message; } lua.Log("FAILED TEST " + curr_test_inst.GetType().ToString() + ". List of exceptions: " + exception_msg, true); this.IsEverythingSuccessful = false; } } } return(0); }
public void AfterTest(ITest test) { }
private static int GetChildIndex(ITest test) { return((int)test.Properties["childIndex"][0]); }
public void AfterTest(ITest test) { disposables?.Dispose(); }
public TestRowException(ITest test, IRow row, string msg) : base(msg) { Test = test; Row = row; }
protected abstract void BeforeTest(ITest test, Configuration configuration);
public void AfterTest(ITest test) { ContextWriter.WriteLine(ClassDescription); }
public void BeforeTest(ITest test) { _transactionScope = new TransactionScope(); }