public static void MiscellaneousTest()
{
Thread.BeginCriticalRegion();
Thread.EndCriticalRegion();
Thread.BeginThreadAffinity();
Thread.EndThreadAffinity();
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
// TODO: Port tests for these once all of the necessary interop APIs are available
Thread.CurrentThread.DisableComObjectEagerCleanup();
Marshal.CleanupUnusedObjectsInCurrentContext();
});
#pragma warning disable 618 // obsolete members
Assert.Throws <InvalidOperationException>(() => Thread.CurrentThread.GetCompressedStack());
Assert.Throws <InvalidOperationException>(() => Thread.CurrentThread.SetCompressedStack(CompressedStack.Capture()));
#pragma warning restore 618 // obsolete members
Thread.MemoryBarrier();
var ad = Thread.GetDomain();
Assert.NotNull(ad);
Assert.Equal(AppDomain.CurrentDomain, ad);
Assert.Equal(ad.Id, Thread.GetDomainID());
Thread.SpinWait(int.MinValue);
Thread.SpinWait(-1);
Thread.SpinWait(0);
Thread.SpinWait(1);
Thread.Yield();
}
public static void CurrentPrincipalContextFlowTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(async() =>
{
Thread.CurrentPrincipal = new ClaimsPrincipal();
await Task.Run(async() =>
{
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
await Task.Run(async() =>
{
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("name"), new string[0]);
await Task.Run(() =>
{
Assert.IsType <GenericPrincipal>(Thread.CurrentPrincipal);
});
Assert.IsType <GenericPrincipal>(Thread.CurrentPrincipal);
});
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
});
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
});
}
public static void CurrentPrincipalContextFlowTest_NotFlow()
{
ThreadTestHelpers.RunTestInBackgroundThread(async() =>
{
Thread.CurrentPrincipal = new ClaimsPrincipal();
Task task;
using (ExecutionContext.SuppressFlow())
{
Assert.True(ExecutionContext.IsFlowSuppressed());
task = Task.Run(() =>
{
// Default PrincipalPolicy for netcoreapp is null
if (PlatformDetection.IsNetCore)
{
Assert.Null(Thread.CurrentPrincipal);
}
else
{
Assert.IsType <GenericPrincipal>(Thread.CurrentPrincipal);
}
Assert.False(ExecutionContext.IsFlowSuppressed());
});
}
Assert.False(ExecutionContext.IsFlowSuppressed());
await task;
});
}
public static void CurrentPrincipalTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var originalPrincipal = Thread.CurrentPrincipal;
var otherPrincipal =
new GenericPrincipal(new GenericIdentity(string.Empty, string.Empty), new string[] { string.Empty });
Thread.CurrentPrincipal = otherPrincipal;
Assert.Equal(otherPrincipal, Thread.CurrentPrincipal);
Thread.CurrentPrincipal = originalPrincipal;
Assert.Equal(originalPrincipal, Thread.CurrentPrincipal);
});
}
[PlatformSpecific(TestPlatforms.Windows)] // Expected behavior differs on Unix and Windows
public static void GetSetApartmentStateTest_ChangeAfterThreadStarted_Windows(
Func <Thread, ApartmentState> getApartmentState,
Func <Thread, ApartmentState, int> setApartmentState,
int setType /* 0 = ApartmentState setter, 1 = SetApartmentState, 2 = TrySetApartmentState */)
{
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var t = Thread.CurrentThread;
Assert.Equal(1, setApartmentState(t, ApartmentState.STA - 1));
Assert.Equal(1, setApartmentState(t, ApartmentState.Unknown + 1));
Assert.Equal(ApartmentState.MTA, getApartmentState(t));
Assert.Equal(0, setApartmentState(t, ApartmentState.MTA));
Assert.Equal(ApartmentState.MTA, getApartmentState(t));
Assert.Equal(setType == 0 ? 0 : 2, setApartmentState(t, ApartmentState.STA)); // cannot be changed after thread is started
Assert.Equal(ApartmentState.MTA, getApartmentState(t));
});
}
public static void NameTest()
{
string name = Guid.NewGuid().ToString("N");
Action waitForThread;
var t =
ThreadTestHelpers.CreateGuardedThread(out waitForThread, () =>
{
var ct = Thread.CurrentThread;
Assert.Equal(name, ct.Name);
Assert.Throws <InvalidOperationException>(() => ct.Name = null);
Assert.Throws <InvalidOperationException>(() => ct.Name = name + "b");
Assert.Equal(name, ct.Name);
});
t.IsBackground = true;
Assert.Null(t.Name);
t.Name = null;
t.Name = null;
Assert.Null(t.Name);
t.Name = name;
Assert.Equal(name, t.Name);
Assert.Throws <InvalidOperationException>(() => t.Name = null);
Assert.Throws <InvalidOperationException>(() => t.Name = name + "b");
Assert.Equal(name, t.Name);
t.Start();
waitForThread();
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var ct = Thread.CurrentThread;
Assert.Null(ct.Name);
ct.Name = null;
ct.Name = null;
Assert.Null(ct.Name);
ct.Name = name;
Assert.Equal(name, ct.Name);
Assert.Throws <InvalidOperationException>(() => ct.Name = null);
Assert.Throws <InvalidOperationException>(() => ct.Name = name + "b");
Assert.Equal(name, ct.Name);
});
}
public static void CurrentCultureTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var t = Thread.CurrentThread;
var originalCulture = CultureInfo.CurrentCulture;
var originalUICulture = CultureInfo.CurrentUICulture;
var otherCulture = CultureInfo.InvariantCulture;
// Culture properties return the same value as those on CultureInfo
Assert.Equal(originalCulture, t.CurrentCulture);
Assert.Equal(originalUICulture, t.CurrentUICulture);
try
{
// Changing culture properties on CultureInfo causes the values of properties on the current thread to change
CultureInfo.CurrentCulture = otherCulture;
CultureInfo.CurrentUICulture = otherCulture;
Assert.Equal(otherCulture, t.CurrentCulture);
Assert.Equal(otherCulture, t.CurrentUICulture);
// Changing culture properties on the current thread causes new values to be returned, and causes the values of
// properties on CultureInfo to change
t.CurrentCulture = originalCulture;
t.CurrentUICulture = originalUICulture;
Assert.Equal(originalCulture, t.CurrentCulture);
Assert.Equal(originalUICulture, t.CurrentUICulture);
Assert.Equal(originalCulture, CultureInfo.CurrentCulture);
Assert.Equal(originalUICulture, CultureInfo.CurrentUICulture);
}
finally
{
CultureInfo.CurrentCulture = originalCulture;
CultureInfo.CurrentUICulture = originalUICulture;
}
Assert.Throws <ArgumentNullException>(() => t.CurrentCulture = null);
Assert.Throws <ArgumentNullException>(() => t.CurrentUICulture = null);
});
}
public static void CurrentPrincipalContextFlowTest_NotFlow()
{
ThreadTestHelpers.RunTestInBackgroundThread(async() =>
{
Thread.CurrentPrincipal = new ClaimsPrincipal();
Task task;
using (ExecutionContext.SuppressFlow())
{
Assert.True(ExecutionContext.IsFlowSuppressed());
task = Task.Run(() =>
{
Assert.Null(Thread.CurrentPrincipal);
Assert.False(ExecutionContext.IsFlowSuppressed());
});
}
Assert.False(ExecutionContext.IsFlowSuppressed());
await task;
});
}
public static void ExecutionContextTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(
() => Assert.Equal(ExecutionContext.Capture(), Thread.CurrentThread.ExecutionContext));
}
public static void CurrentPrincipalTest_SkipOnDesktopFramework()
{
ThreadTestHelpers.RunTestInBackgroundThread(() => Assert.Null(Thread.CurrentPrincipal));
}
