TestExecutionContext
Helper class used to save and restore certain static or
singleton settings in the environment that affect tests
or which might be changed by the user tests.
using NUnit.Compatibility;
using NUnit.Framework.Constraints;
using NUnit.Framework.Interfaces;
using NUnit.Framework.Internal.Execution;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Security.Principal;
using System.Threading;
namespace NUnit.Framework.Internal
{
[NullableContext(1)]
[Nullable(0)]
public class TestExecutionContext : LongLivedMarshalByRefObject
{
[NullableContext(0)]
public class IsolatedContext : IDisposable
{
[Nullable(1)]
private readonly TestExecutionContext _originalContext;
public IsolatedContext()
{
_originalContext = CurrentContext;
CurrentContext = _originalContext.CreateIsolatedContext();
}
public void Dispose()
{
_originalContext.OutWriter?.Write(CurrentContext.CurrentResult?.Output);
CurrentContext = _originalContext;
}
}
[NullableContext(0)]
public class AdhocContext : TestExecutionContext
{
public AdhocContext()
{
base.CurrentTest = new TestMethod(new MethodWrapper(GetType(), "AdhocTestMethod"));
base.CurrentResult = base.CurrentTest.MakeTestResult();
}
private void AdhocTestMethod()
{
}
}
[Nullable(2)]
private readonly TestExecutionContext _priorContext;
private TestExecutionStatus _executionStatus;
private ITestListener _listener = TestListener.NULL;
private int _assertCount;
[Nullable(2)]
private Randomizer _randomGenerator;
private TestResult _currentResult;
private SandboxedThreadState _sandboxedThreadState;
[Nullable(new byte[] {
1,
2
})]
private static readonly AsyncLocal<TestExecutionContext> AsyncLocalCurrentContext = new AsyncLocal<TestExecutionContext>();
public static TestExecutionContext CurrentContext {
get {
AsyncLocal<TestExecutionContext> asyncLocalCurrentContext = AsyncLocalCurrentContext;
object testExecutionContext = asyncLocalCurrentContext.Value;
if (testExecutionContext == null) {
TestExecutionContext testExecutionContext3 = asyncLocalCurrentContext.Value = new AdhocContext();
testExecutionContext = testExecutionContext3;
}
return (TestExecutionContext)testExecutionContext;
}
[param: AllowNull]
internal set {
AsyncLocalCurrentContext.Value = value;
}
}
public Test CurrentTest { get; set; }
public DateTime StartTime { get; set; }
public long StartTicks { get; set; }
public double Duration {
get {
long num = Stopwatch.GetTimestamp() - StartTicks;
return (double)num / (double)Stopwatch.Frequency;
}
}
public TestResult CurrentResult {
get {
return _currentResult;
}
set {
_currentResult = value;
if (value != null)
OutWriter = value.OutWriter;
}
}
public TextWriter OutWriter { get; set; }
[Nullable(2)]
[field: Nullable(2)]
public object TestObject {
[NullableContext(2)]
get;
[NullableContext(2)]
set;
}
public bool StopOnError { get; set; }
public TestExecutionStatus ExecutionStatus {
get {
if (_executionStatus == TestExecutionStatus.Running && _priorContext != null)
_executionStatus = _priorContext.ExecutionStatus;
return _executionStatus;
}
set {
_executionStatus = value;
if (_priorContext != null)
_priorContext.ExecutionStatus = value;
}
}
internal ITestListener Listener {
get {
return _listener;
}
set {
_listener = value;
}
}
public IWorkItemDispatcher Dispatcher { get; set; }
public ParallelScope ParallelScope { get; set; }
public Tolerance DefaultFloatingPointTolerance { get; set; }
[Nullable(2)]
[field: Nullable(2)]
public TestWorker TestWorker {
[NullableContext(2)]
get;
[NullableContext(2)]
internal set;
}
public Randomizer RandomGenerator {
get {
if (_randomGenerator == null)
_randomGenerator = new Randomizer(CurrentTest.Seed);
return _randomGenerator;
}
}
internal int AssertCount => _assertCount;
internal int MultipleAssertLevel { get; set; }
internal bool ThrowOnEachFailureUnderDebugger { get; set; }
public int TestCaseTimeout { get; set; }
public bool UseCancellation { get; set; }
public CancellationToken CancellationToken { get; set; } = CancellationToken.None;
public List<ITestAction> UpstreamActions { get; }
public CultureInfo CurrentCulture {
get {
return _sandboxedThreadState.Culture;
}
set {
_sandboxedThreadState = _sandboxedThreadState.WithCulture(value);
Thread.CurrentThread.CurrentCulture = value;
}
}
public CultureInfo CurrentUICulture {
get {
return _sandboxedThreadState.UICulture;
}
set {
_sandboxedThreadState = _sandboxedThreadState.WithUICulture(value);
Thread.CurrentThread.CurrentUICulture = value;
}
}
[Nullable(2)]
public IPrincipal CurrentPrincipal {
[NullableContext(2)]
get {
return _sandboxedThreadState.Principal;
}
[NullableContext(2)]
set {
_sandboxedThreadState = _sandboxedThreadState.WithPrincipal(value);
ThreadUtility.SetCurrentThreadPrincipal(value);
}
}
public ValueFormatter CurrentValueFormatter { get; set; }
public bool IsSingleThreaded { get; set; }
public int CurrentRepeatCount { get; set; }
public TestExecutionContext()
{
_priorContext = null;
TestCaseTimeout = 0;
UpstreamActions = new List<ITestAction>();
UpdateContextFromEnvironment();
CurrentValueFormatter = ((object val) => MsgUtils.DefaultValueFormatter(val));
IsSingleThreaded = false;
DefaultFloatingPointTolerance = Tolerance.Default;
}
public TestExecutionContext(TestExecutionContext other)
{
_priorContext = other;
CurrentTest = other.CurrentTest;
CurrentResult = other.CurrentResult;
TestObject = other.TestObject;
_listener = other._listener;
StopOnError = other.StopOnError;
TestCaseTimeout = other.TestCaseTimeout;
ThrowOnEachFailureUnderDebugger = other.ThrowOnEachFailureUnderDebugger;
UseCancellation = other.UseCancellation;
CancellationToken = other.CancellationToken;
UpstreamActions = new List<ITestAction>(other.UpstreamActions);
_sandboxedThreadState = other._sandboxedThreadState;
DefaultFloatingPointTolerance = other.DefaultFloatingPointTolerance;
CurrentValueFormatter = other.CurrentValueFormatter;
Dispatcher = other.Dispatcher;
ParallelScope = other.ParallelScope;
IsSingleThreaded = other.IsSingleThreaded;
}
[MemberNotNull("_sandboxedThreadState")]
public void UpdateContextFromEnvironment()
{
_sandboxedThreadState = SandboxedThreadState.Capture();
}
public void EstablishExecutionEnvironment()
{
_sandboxedThreadState.Restore();
CurrentContext = this;
}
public void IncrementAssertCount()
{
Interlocked.Increment(ref _assertCount);
}
public void IncrementAssertCount(int count)
{
while (count-- > 0) {
Interlocked.Increment(ref _assertCount);
}
}
public void AddFormatter(ValueFormatterFactory formatterFactory)
{
CurrentValueFormatter = formatterFactory(CurrentValueFormatter);
}
private TestExecutionContext CreateIsolatedContext()
{
TestExecutionContext testExecutionContext = new TestExecutionContext(this);
if (testExecutionContext.CurrentTest != null)
testExecutionContext.CurrentResult = testExecutionContext.CurrentTest.MakeTestResult();
testExecutionContext.TestWorker = TestWorker;
return testExecutionContext;
}
public void SendMessage(string destination, string message)
{
Listener?.SendMessage(new TestMessage(destination, message, CurrentTest.Id));
}
}
}