private static void Main()
{
bool isFirstInstance;
using(var mutex = new Mutex(true, "gitter-uac-instance", out isFirstInstance))
{
if(isFirstInstance)
{
var args = Environment.GetCommandLineArgs();
if(args == null || args.Length < 2 || args[1] != "--remoting")
return;
ChannelServices.RegisterChannel(
new IpcChannel(
new Dictionary<string, string>
{
{ "portName", RemotingChannelName }
},
new BinaryClientFormatterSinkProvider(),
new BinaryServerFormatterSinkProvider()
{
TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full,
}),
false);
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(RemoteExecutor), RemotingObjectName, WellKnownObjectMode.Singleton);
_executor = (RemoteExecutor)Activator.GetObject(typeof(RemoteExecutor),
string.Format(@"ipc://{0}/{1}", RemotingChannelName, RemotingObjectName));
_executor.ExitEvent.WaitOne();
_executor.ExitEvent.Close();
}
}
}
public void PredefinedCulturesOnlyEnvVarTest(string predefinedCulturesOnlyEnvVar, string cultureName)
{
var psi = new ProcessStartInfo();
psi.Environment.Clear();
psi.Environment.Add("DOTNET_SYSTEM_GLOBALIZATION_PREDEFINED_CULTURES_ONLY", predefinedCulturesOnlyEnvVar);
RemoteExecutor.Invoke((culture, predefined) =>
{
if (predefined == "1")
{
AssertExtensions.Throws <CultureNotFoundException>(() => new CultureInfo(culture));
}
else
{
CultureInfo ci = new CultureInfo(culture);
Assert.Equal(culture, ci.Name);
}
}, cultureName, predefinedCulturesOnlyEnvVar, new RemoteInvokeOptions {
StartInfo = psi
}).Dispose();
}
public void GetTypeByName()
{
RemoteInvokeOptions options = new RemoteInvokeOptions();
RemoteExecutor.Invoke(() =>
{
string test1 = testtype;
Type t1 = Type.GetType(test1,
(aName) => aName.Name == "Foo" ?
Assembly.LoadFrom(s_testAssemblyPath) : null,
typeloader,
true
);
Assert.NotNull(t1);
string test2 = "System.Collections.Generic.Dictionary`2[[Program, TestLoadAssembly], [Program, TestLoadAssembly]]";
Type t2 = Type.GetType(test2, assemblyloader, typeloader, true);
Assert.NotNull(t2);
Assert.Equal(t1, t2);
}, options).Dispose();
}
public void SdcaL1UpdateUTest(string mode, string test, string scale, Dictionary <string, string> environmentVariables)
{
RemoteExecutor.RemoteInvoke((arg0, arg1, arg2) =>
{
CheckProperFlag(arg0);
float defaultScale = float.Parse(arg2, CultureInfo.InvariantCulture);
float[] src = (float[])_testArrays[int.Parse(arg1)].Clone();
float[] v = (float[])src.Clone();
float[] w = (float[])src.Clone();
float[] expected = (float[])w.Clone();
for (int i = 0; i < expected.Length; i++)
{
float value = src[i] * (1 + defaultScale);
expected[i] = Math.Abs(value) > defaultScale ? (value > 0 ? value - defaultScale : value + defaultScale) : 0;
}
CpuMathUtils.SdcaL1UpdateDense(defaultScale, src.Length, src, defaultScale, v, w);
var actual = w;
Assert.Equal(expected, actual, _comparer);
return(RemoteExecutor.SuccessExitCode);
}, mode, test, scale, new RemoteInvokeOptions(environmentVariables));
}
public void HttpClientUsesSslCertEnvironmentVariables()
{
// We set SSL_CERT_DIR and SSL_CERT_FILE to empty locations.
// The HttpClient should fail to validate the server certificate.
var psi = new ProcessStartInfo();
string sslCertDir = GetTestFilePath();
Directory.CreateDirectory(sslCertDir);
psi.Environment.Add("SSL_CERT_DIR", sslCertDir);
string sslCertFile = GetTestFilePath();
File.WriteAllText(sslCertFile, "");
psi.Environment.Add("SSL_CERT_FILE", sslCertFile);
RemoteExecutor.Invoke(async (useVersionString) =>
{
const string Url = "https://www.microsoft.com";
using (HttpClient client = CreateHttpClient(useVersionString))
{
await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(Url));
}
}, UseVersion.ToString(), new RemoteInvokeOptions { StartInfo = psi }).Dispose();
}
public void InputEncoding_SetWithInInitialized_ResetsIn()
{
RemoteExecutor.Invoke(() =>
{
// Initialize Console.In
TextReader inReader = Console.In;
Assert.NotNull(inReader);
Assert.Same(inReader, Console.In);
// Change the InputEncoding
Console.InputEncoding = Encoding.Unicode; // Not ASCII: not supported by Windows Nano
Assert.Equal(Encoding.Unicode, Console.InputEncoding);
if (PlatformDetection.IsWindows)
{
// Console.set_InputEncoding is effectively a nop on Unix,
// so although the reader accessed by Console.In will be reset,
// it'll be re-initialized on re-access to the same singleton,
// (assuming input isn't redirected).
Assert.NotSame(inReader, Console.In);
}
}).Dispose();
}
public void Ctor_TypeDescriptorNotFound_ExceptionFallback(Type type, bool returnNull, string stringToConvert, int expectedValue)
{
RemoteExecutor.Invoke((innerType, innerReturnNull, innerStringToConvert, innerExpectedValue) =>
{
FieldInfo s_convertFromInvariantString = typeof(DefaultValueAttribute).GetField("s_convertFromInvariantString", BindingFlags.GetField | Reflection.BindingFlags.NonPublic | Reflection.BindingFlags.Static);
Assert.NotNull(s_convertFromInvariantString);
// simulate TypeDescriptor.ConvertFromInvariantString not found
s_convertFromInvariantString.SetValue(null, new object());
// we fallback to empty catch in DefaultValueAttribute constructor
DefaultValueAttribute attr = new DefaultValueAttribute(Type.GetType(innerType), innerStringToConvert);
if (bool.Parse(innerReturnNull))
{
Assert.Null(attr.Value);
}
else
{
Assert.Equal(int.Parse(innerExpectedValue), attr.Value);
}
}, type.ToString(), returnNull.ToString(), stringToConvert, expectedValue.ToString()).Dispose();
}
public void AddSUTest(string mode, string test, Dictionary <string, string> environmentVariables)
{
RemoteExecutor.RemoteInvoke((arg0, arg1) =>
{
CheckProperFlag(arg0);
float[] src = (float[])_testArrays[int.Parse(arg1)].Clone();
float[] dst = (float[])src.Clone();
int[] idx = _testIndexArray;
int limit = int.Parse(arg1) == 2 ? 9 : 18;
float[] expected = (float[])dst.Clone();
for (int i = 0; i < limit; i++)
{
int index = idx[i];
expected[index] += src[i];
}
CpuMathUtils.Add(src, idx, dst, limit);
var actual = dst;
Assert.Equal(expected, actual, _comparer);
return(RemoteExecutor.SuccessExitCode);
}, mode, test, new RemoteInvokeOptions(environmentVariables));
}
public void FailFast_ExceptionStackTrace_StackOverflowException()
{
// Test using another type of exception
var psi = new ProcessStartInfo();
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(
() => { Environment.FailFast("message", new StackOverflowException("SO exception")); return(RemoteExecutor.SuccessExitCode); },
new RemoteInvokeOptions {
StartInfo = psi
}))
{
Process p = handle.Process;
handle.Process = null;
p.WaitForExit();
string consoleOutput = p.StandardError.ReadToEnd();
Assert.Contains("Exception details:", consoleOutput);
Assert.Contains("StackOverflowException", consoleOutput);
Assert.Contains("SO exception", consoleOutput);
}
}
public void CurrentCulture()
{
if (PlatformDetection.IsNetNative && !PlatformDetection.IsInAppContainer) // Tide us over until .NET Native ILC tests run are run inside an appcontainer.
{
return;
}
RemoteExecutor.Invoke(() =>
{
CultureInfo newCulture = new CultureInfo(CultureInfo.CurrentCulture.Name.Equals("ja-JP", StringComparison.OrdinalIgnoreCase) ? "ar-SA" : "ja-JP");
CultureInfo.CurrentCulture = newCulture;
Assert.Equal(CultureInfo.CurrentCulture, newCulture);
newCulture = new CultureInfo("de-DE_phoneb");
CultureInfo.CurrentCulture = newCulture;
Assert.Equal(CultureInfo.CurrentCulture, newCulture);
Assert.Equal("de-DE_phoneb", newCulture.CompareInfo.Name);
return(RemoteExecutor.SuccessExitCode);
}).Dispose();
}
public void AddScaleSUTest(string mode, string test, string scale, Dictionary <string, string> environmentVariables)
{
RemoteExecutor.RemoteInvoke((arg0, arg1, arg2) =>
{
CheckProperFlag(arg0);
float defaultScale = float.Parse(arg2, CultureInfo.InvariantCulture);
float[] src = (float[])_testArrays[int.Parse(arg1)].Clone();
float[] dst = (float[])src.Clone();
int[] idx = _testIndexArray;
int limit = int.Parse(arg1) == 2 ? 9 : 18;
float[] expected = (float[])dst.Clone();
CpuMathUtils.AddScale(defaultScale, src, idx, dst, limit);
for (int i = 0; i < limit; i++)
{
int index = idx[i];
expected[index] += defaultScale * src[i];
}
Assert.Equal(expected, dst, _comparer);
return(RemoteExecutor.SuccessExitCode);
}, mode, test, scale, new RemoteInvokeOptions(environmentVariables));
}
public void CurrentCulture_BasedOnLangEnvVar(string langEnvVar, string expectedCultureName)
{
var psi = new ProcessStartInfo();
psi.Environment.Clear();
CopyEssentialTestEnvironment(psi.Environment);
psi.Environment["LANG"] = langEnvVar;
RemoteExecutor.Invoke(expected =>
{
Assert.NotNull(CultureInfo.CurrentCulture);
Assert.NotNull(CultureInfo.CurrentUICulture);
Assert.Equal(expected, CultureInfo.CurrentCulture.Name);
Assert.Equal(expected, CultureInfo.CurrentUICulture.Name);
return(RemoteExecutor.SuccessExitCode);
}, expectedCultureName, new RemoteInvokeOptions {
StartInfo = psi
}).Dispose();
}
public static void CurrentPrincipal_SetNull()
{
// We run test on remote process because we need to set same principal policy
// On netfx default principal policy is PrincipalPolicy.UnauthenticatedPrincipal
RemoteExecutor.Invoke(() =>
{
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.NoPrincipal);
Assert.Null(Thread.CurrentPrincipal);
Thread.CurrentPrincipal = null;
Assert.Null(Thread.CurrentPrincipal);
Thread.CurrentPrincipal = new ClaimsPrincipal();
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
Thread.CurrentPrincipal = null;
Assert.Null(Thread.CurrentPrincipal);
Thread.CurrentPrincipal = new ClaimsPrincipal();
Assert.IsType <ClaimsPrincipal>(Thread.CurrentPrincipal);
}).Dispose();
}
public void PingPong(EventResetMode mode)
{
// Create names for the two events
string outboundName = Guid.NewGuid().ToString("N");
string inboundName = Guid.NewGuid().ToString("N");
// Create the two events and the other process with which to synchronize
using (var inbound = new EventWaitHandle(true, mode, inboundName))
using (var outbound = new EventWaitHandle(false, mode, outboundName))
using (var remote = RemoteExecutor.Invoke(PingPong_OtherProcess, mode.ToString(), outboundName, inboundName))
{
// Repeatedly wait for one event and then set the other
for (int i = 0; i < 10; i++)
{
Assert.True(inbound.WaitOne(RemoteExecutor.FailWaitTimeoutMilliseconds));
if (mode == EventResetMode.ManualReset)
{
inbound.Reset();
}
outbound.Set();
}
}
}
public void ToBitmap_PngIconNotSupportedInSwitches_ThrowsArgumentOutOfRangeException()
{
void VerifyPngNotSupported()
{
using (Icon icon = GetPngIcon())
{
AssertExtensions.Throws <ArgumentOutOfRangeException>(null, () => icon.ToBitmap());
}
}
if (RemoteExecutor.IsSupported && (!AppContext.TryGetSwitch(DontSupportPngFramesInIcons, out bool isEnabled) || !isEnabled))
{
RemoteExecutor.Invoke(() =>
{
AppContext.SetSwitch(DontSupportPngFramesInIcons, true);
VerifyPngNotSupported();
}).Dispose();
}
else
{
VerifyPngNotSupported();
}
}
public void ProfileOptimization_CheckFileExists()
{
string profileFile = GetTestFileName();
RemoteExecutor.Invoke((_profileFile) =>
{
// tracking down why test sporadically fails on RedHat69
// write to the file first to check permissions
// See https://github.com/dotnet/corefx/issues/31792
File.WriteAllText(_profileFile, "42");
// Verify this write succeeded
Assert.True(File.Exists(_profileFile), $"'{_profileFile}' does not exist");
Assert.True(new FileInfo(_profileFile).Length > 0, $"'{_profileFile}' is empty");
// Delete the file and verify the delete
File.Delete(_profileFile);
Assert.True(!File.Exists(_profileFile), $"'{_profileFile} ought to not exist now");
// Perform the test work
ProfileOptimization.SetProfileRoot(Path.GetDirectoryName(_profileFile));
ProfileOptimization.StartProfile(Path.GetFileName(_profileFile));
}, profileFile).Dispose();
// profileFile should deterministically exist now -- if not, wait 5 seconds
bool existed = File.Exists(profileFile);
if (!existed)
{
Thread.Sleep(5000);
}
Assert.True(File.Exists(profileFile), $"'{profileFile}' does not exist");
Assert.True(new FileInfo(profileFile).Length > 0, $"'{profileFile}' is empty");
Assert.True(existed, $"'{profileFile}' did not immediately exist, but did exist 5 seconds later");
}
public void ExitDetectionNotBlockedByHandler()
{
// .NET Core respects ignored disposition for SIGINT/SIGQUIT.
if (IsSignalIgnored(SIGINT))
{
return;
}
RemoteExecutor.Invoke(() =>
{
var mre = new ManualResetEventSlim();
var tcs = new TaskCompletionSource();
// CancelKeyPress is triggered by SIGINT/SIGQUIT
Console.CancelKeyPress += (sender, e) =>
{
tcs.SetResult();
// Block CancelKeyPress
Assert.True(mre.Wait(WaitFailTestTimeoutSeconds * 1000));
};
// Generate CancelKeyPress
Assert.Equal(0, kill(Environment.ProcessId, SIGINT));
// Wait till we block CancelKeyPress
Assert.True(tcs.Task.Wait(WaitFailTestTimeoutSeconds * 1000));
// Create a process and wait for it to exit.
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(() => RemoteExecutor.SuccessExitCode))
{
// Process exit is detected on SIGCHLD
Assert.Equal(RemoteExecutor.SuccessExitCode, handle.ExitCode);
}
// Release CancelKeyPress
mre.Set();
}).Dispose();
}
public void PingPong()
{
// Create two anonymous pipes, one for each direction of communication.
// Then spawn another process to communicate with.
using (var outbound = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
using (var inbound = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable))
using (var remote = RemoteExecutor.Invoke(new Func <string, string, int>(ChildFunc), outbound.GetClientHandleAsString(), inbound.GetClientHandleAsString()))
{
// Close our local copies of the handles now that we've passed them of to the other process
outbound.DisposeLocalCopyOfClientHandle();
inbound.DisposeLocalCopyOfClientHandle();
// Ping-pong back and forth by writing then reading bytes one at a time.
for (byte i = 0; i < 10; i++)
{
outbound.WriteByte(i);
int received = inbound.ReadByte();
Assert.Equal(i, received);
}
}
int ChildFunc(string inHandle, string outHandle)
{
// Create the clients associated with the supplied handles
using (var inbound = new AnonymousPipeClientStream(PipeDirection.In, inHandle))
using (var outbound = new AnonymousPipeClientStream(PipeDirection.Out, outHandle))
{
// Repeatedly read then write a byte from and to the server
for (int i = 0; i < 10; i++)
{
int b = inbound.ReadByte();
outbound.WriteByte((byte)b);
}
}
return(RemoteExecutor.SuccessExitCode);
}
}
public static void GetGCMemoryInfo()
{
RemoteExecutor.Invoke(() =>
{
// Allows to update the value returned by GC.GetGCMemoryInfo
GC.Collect();
GCMemoryInfo memoryInfo1 = GC.GetGCMemoryInfo();
Assert.InRange(memoryInfo1.HighMemoryLoadThresholdBytes, 1, long.MaxValue);
Assert.InRange(memoryInfo1.MemoryLoadBytes, 1, long.MaxValue);
Assert.InRange(memoryInfo1.TotalAvailableMemoryBytes, 1, long.MaxValue);
Assert.InRange(memoryInfo1.HeapSizeBytes, 1, long.MaxValue);
Assert.InRange(memoryInfo1.FragmentedBytes, 0, long.MaxValue);
GCHandle[] gch = new GCHandle[64 * 1024];
for (int i = 0; i < gch.Length * 2; ++i)
{
byte[] arr = new byte[64];
if (i % 2 == 0)
{
gch[i / 2] = GCHandle.Alloc(arr, GCHandleType.Pinned);
}
}
// Allows to update the value returned by GC.GetGCMemoryInfo
GC.Collect();
GCMemoryInfo memoryInfo2 = GC.GetGCMemoryInfo();
Assert.Equal(memoryInfo2.HighMemoryLoadThresholdBytes, memoryInfo1.HighMemoryLoadThresholdBytes);
Assert.InRange(memoryInfo2.MemoryLoadBytes, memoryInfo1.MemoryLoadBytes, long.MaxValue);
Assert.Equal(memoryInfo2.TotalAvailableMemoryBytes, memoryInfo1.TotalAvailableMemoryBytes);
Assert.InRange(memoryInfo2.HeapSizeBytes, memoryInfo1.HeapSizeBytes + 1, long.MaxValue);
Assert.InRange(memoryInfo2.FragmentedBytes, memoryInfo1.FragmentedBytes + 1, long.MaxValue);
}).Dispose();
}
/// <summary>
/// Runs the given test <paramref name="action"/> within an environment
/// where the given <paramref name="intrinsics"/> features.
/// </summary>
/// <param name="action">The test action to run.</param>
/// <param name="arg0">The value to pass as a parameter #0 to the test action.</param>
/// <param name="arg1">The value to pass as a parameter #1 to the test action.</param>
/// <param name="intrinsics">The intrinsics features.</param>
public static void RunWithHwIntrinsicsFeature <T>(
Action <string, string> action,
T arg0,
T arg1,
HwIntrinsics intrinsics)
where T : IConvertible
{
if (!RemoteExecutor.IsSupported)
{
return;
}
foreach (KeyValuePair <HwIntrinsics, string> intrinsic in intrinsics.ToFeatureKeyValueCollection())
{
var processStartInfo = new ProcessStartInfo();
if (intrinsic.Key != HwIntrinsics.AllowAll)
{
processStartInfo.Environment[$"COMPlus_{intrinsic.Value}"] = "0";
RemoteExecutor.Invoke(
action,
arg0.ToString(),
arg1.ToString(),
new RemoteInvokeOptions
{
StartInfo = processStartInfo
})
.Dispose();
}
else
{
// Since we are running using the default architecture there is no
// point creating the overhead of running the action in a separate process.
action(arg0.ToString(), arg1.ToString());
}
}
}
public void AssemblyResolve()
{
CopyTestAssemblies();
RemoteExecutor.Invoke(() => {
// bool AssemblyResolveFlag = false;
ResolveEventHandler handler = (sender, args) =>
{
Assert.Same(AppDomain.CurrentDomain, sender);
Assert.NotNull(args);
Assert.NotNull(args.Name);
Assert.NotNull(args.RequestingAssembly);
// AssemblyResolveFlag = true;
return(Assembly.LoadFile(Path.Combine(Environment.CurrentDirectory, "AssemblyResolveTestApp.dll")));
};
AppDomain.CurrentDomain.AssemblyResolve += handler;
Type t = Type.GetType("AssemblyResolveTestApp.Class1, AssemblyResolveTestApp", true);
Assert.NotNull(t);
// https://github.com/dotnet/runtime/issues/29817
// Assert.True(AssemblyResolveFlag);
}).Dispose();
}
public void FirstChanceException_Called()
{
RemoteExecutor.Invoke(() => {
bool flag = false;
EventHandler <FirstChanceExceptionEventArgs> handler = (sender, e) =>
{
Exception ex = e.Exception;
if (ex is FirstChanceTestException)
{
flag = !flag;
}
};
AppDomain.CurrentDomain.FirstChanceException += handler;
try
{
throw new FirstChanceTestException("testing");
}
catch
{
}
AppDomain.CurrentDomain.FirstChanceException -= handler;
Assert.True(flag, "FirstChanceHandler not called");
}).Dispose();
}
public void MemberInfoGeneric_IsCollectibleTrue_WhenUsingAssemblyLoadContext(string memberName)
{
RemoteExecutor.Invoke((marshalledName) =>
{
AssemblyLoadContext alc = new TestAssemblyLoadContext();
Type t1 = Type.GetType(
"TestCollectibleAssembly.MyGenericTestClass`1[System.Int32], TestCollectibleAssembly, Version=1.0.0.0",
collectibleAssemblyResolver(alc),
typeResolver(false),
true
);
Assert.NotNull(t1);
var member = t1.GetMember(marshalledName).FirstOrDefault();
Assert.NotNull(member);
Assert.True(member.IsCollectible);
return(RemoteExecutor.SuccessExitCode);
}, memberName).Dispose();
}
public void PingPong_Sync()
{
// Create names for two pipes
string outName = PipeStreamConformanceTests.GetUniquePipeName();
string inName = PipeStreamConformanceTests.GetUniquePipeName();
// Create the two named pipes, one for each direction, then create
// another process with which to communicate
using (var outbound = new NamedPipeServerStream(outName, PipeDirection.Out))
using (var inbound = new NamedPipeClientStream(".", inName, PipeDirection.In))
using (RemoteExecutor.Invoke(new Action <string, string>(PingPong_OtherProcess), outName, inName))
{
// Wait for both pipes to be connected
Task.WaitAll(outbound.WaitForConnectionAsync(), inbound.ConnectAsync());
// Repeatedly write then read a byte to and from the other process
for (byte i = 0; i < 10; i++)
{
outbound.WriteByte(i);
int received = inbound.ReadByte();
Assert.Equal(i, received);
}
}
}
public void Authentication_UseMemoryStreamVisibleBufferContent_Success()
{
RemoteExecutor.Invoke(async(useSocketsHttpHandlerString, useHttp2String) =>
{
string username = "******";
string password = "******";
Uri uri = Configuration.Http.RemoteHttp11Server.BasicAuthUriForCreds(userName: username, password: password);
HttpClientHandler handler = CreateHttpClientHandler(useSocketsHttpHandlerString, useHttp2String);
handler.Credentials = new NetworkCredential(username, password);
using (HttpClient client = CreateHttpClient(handler, useHttp2String))
{
byte[] postData = Encoding.UTF8.GetBytes("This is data to post.");
var stream = new MemoryStream(postData, 0, postData.Length, false, true);
var content = new MultiInterfaceStreamContent(stream);
using (HttpResponseMessage response = await client.PostAsync(uri, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
string responseContent = await response.Content.ReadAsStringAsync();
}
}
}, UseSocketsHttpHandler.ToString(), UseHttp2.ToString()).Dispose();
}
public void ProfileOptimization_CheckFileExists()
{
string profileFile = GetTestFileName();
RemoteExecutor.Invoke((_profileFile) =>
{
// Perform the test work
ProfileOptimization.SetProfileRoot(Path.GetDirectoryName(_profileFile));
ProfileOptimization.StartProfile(Path.GetFileName(_profileFile));
}, profileFile).Dispose();
// profileFile should deterministically exist now -- if not, wait 5 seconds
bool existed = File.Exists(profileFile);
if (!existed)
{
Thread.Sleep(5000);
}
Assert.True(File.Exists(profileFile), $"'{profileFile}' does not exist");
Assert.True(new FileInfo(profileFile).Length > 0, $"'{profileFile}' is empty");
Assert.True(existed, $"'{profileFile}' did not immediately exist, but did exist 5 seconds later");
}
public void HttpProxy_Uri_Parsing(string _input, string _host, string _port, string _user, string _password)
{
RemoteExecutor.Invoke((input, host, port, user, password) =>
{
// Remote exec does not allow to pass null at this moment.
if (user == "null")
{
user = null;
}
if (password == "null")
{
password = null;
}
Environment.SetEnvironmentVariable("all_proxy", input);
IWebProxy p;
Uri u;
Assert.True(HttpEnvironmentProxy.TryCreate(out p));
Assert.NotNull(p);
u = p.GetProxy(fooHttp);
Assert.Equal(host, u.Host);
Assert.Equal(Convert.ToInt32(port), u.Port);
if (user != null)
{
NetworkCredential nc = p.Credentials.GetCredential(u, "Basic");
Assert.NotNull(nc);
Assert.Equal(user, nc.UserName);
Assert.Equal(password, nc.Password);
}
return(RemoteExecutor.SuccessExitCode);
}, _input, _host, _port, _user ?? "null", _password ?? "null").Dispose();
}
public void FailFast_ExceptionStackTrace_InnerException()
{
// Test if inner exception details are also logged
var psi = new ProcessStartInfo();
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(
() => Environment.FailFast("message", new ArgumentException("first exception", new NullReferenceException("inner exception"))),
new RemoteInvokeOptions {
StartInfo = psi
}))
{
Process p = handle.Process;
handle.Process = null;
p.WaitForExit();
string consoleOutput = p.StandardError.ReadToEnd();
Assert.Contains("first exception", consoleOutput);
Assert.Contains("inner exception", consoleOutput);
Assert.Contains("ArgumentException", consoleOutput);
Assert.Contains("NullReferenceException", consoleOutput);
}
}
public static void ProcessExit_Called()
{
// We expect the launched process to crash; don't let it write the resulting AV message to the console.
var psi = new ProcessStartInfo()
{
RedirectStandardError = true, RedirectStandardOutput = true
};
using (RemoteInvokeHandle handle = RemoteExecutor.Invoke(() => { CauseAVInNative(); return(RemoteExecutor.SuccessExitCode); }, new RemoteInvokeOptions {
CheckExitCode = false, StartInfo = psi
}))
{
Process p = handle.Process;
p.WaitForExit();
if (PlatformDetection.IsFullFramework)
{
Assert.Equal(RemoteExecutor.SuccessExitCode, p.ExitCode);
}
else
{
Assert.NotEqual(RemoteExecutor.SuccessExitCode, p.ExitCode);
}
}
}
private void HandlerInvokedForSignal(int signalOuter)
{
// On Windows we could use GenerateConsoleCtrlEvent to send a ctrl-C to the process,
// however that'll apply to all processes associated with the same group, which will
// include processes like the code coverage tool when doing code coverage runs, causing
// those other processes to exit. As such, we test this only on Unix, where we can
// send a SIGINT signal to this specific process only.
// This test sends a SIGINT back to itself... if run in the xunit process, this would end
// up canceling the rest of xunit's tests. So we run the test itself in a separate process.
RemoteExecutor.Invoke(signalStr =>
{
var tcs = new TaskCompletionSource <ConsoleSpecialKey>();
ConsoleCancelEventHandler handler = (sender, e) =>
{
e.Cancel = true;
tcs.SetResult(e.SpecialKey);
};
Console.CancelKeyPress += handler;
try
{
int signalInner = int.Parse(signalStr);
Assert.Equal(0, kill(Process.GetCurrentProcess().Id, signalInner));
Assert.True(tcs.Task.Wait(WaitFailTestTimeoutSeconds * 1000));
Assert.Equal(
signalInner == SIGINT ? ConsoleSpecialKey.ControlC : ConsoleSpecialKey.ControlBreak,
tcs.Task.Result);
}
finally
{
Console.CancelKeyPress -= handler;
}
}, signalOuter.ToString()).Dispose();
}
public void CurrentCulture_DefaultWithNoLang(string langEnvVar)
{
var psi = new ProcessStartInfo();
psi.Environment.Clear();
CopyEssentialTestEnvironment(psi.Environment);
if (langEnvVar != null)
{
psi.Environment["LANG"] = langEnvVar;
}
RemoteExecutor.Invoke(() =>
{
Assert.NotNull(CultureInfo.CurrentCulture);
Assert.NotNull(CultureInfo.CurrentUICulture);
Assert.Equal("", CultureInfo.CurrentCulture.Name);
Assert.Equal("", CultureInfo.CurrentUICulture.Name);
}, new RemoteInvokeOptions {
StartInfo = psi
}).Dispose();
}
