public void WhenManagingManyProcesses_ReturnsAllProcessIds()
{
processes = new[]
{
IFTestHelper.ExecuteWithWait("nop"),
IFTestHelper.ExecuteWithWait("nop"),
IFTestHelper.ExecuteWithWait("nop"),
IFTestHelper.ExecuteWithWait("nop"),
IFTestHelper.ExecuteWithWait("nop"),
IFTestHelper.ExecuteWithWait("nop"),
};
foreach (var process in processes)
{
jobObject.AssignProcessToJob(process);
}
var processIds = jobObject.GetProcessIds();
Assert.Collection(processIds,
x => Assert.Equal(processes[0].Id, x),
x => Assert.Equal(processes[1].Id, x),
x => Assert.Equal(processes[2].Id, x),
x => Assert.Equal(processes[3].Id, x),
x => Assert.Equal(processes[4].Id, x),
x => Assert.Equal(processes[5].Id, x)
);
}
public void WhenManagingOneProcess_ReturnsCpuStatistics()
{
IFTestHelper.ExecuteInJob(jobObject, "consume-cpu", "--duration 250");
var stats = jobObject.GetCpuStatistics();
Assert.NotEqual(TimeSpan.Zero, stats.TotalKernelTime + stats.TotalUserTime);
}
public void WhenMemoryIsNotLimited_GetMemoryPeakReturnsZero()
{
ulong allocateBytes = DefaultMemoryLimit * 2;
IFTestHelper.ExecuteInJob(jobObject, "allocate-memory", "--bytes", allocateBytes);
Assert.Equal(0UL, jobObject.GetPeakJobMemoryUsed());
}
public void ClipboardIsDisabledForWrites()
{
var proc = IFTestHelper.ExecuteInJob(jobObject, "write-clipboard", "Text from JobObject1");
proc.WaitForExit();
var output = proc.StandardOutput.ReadToEnd().Trim();
Assert.Contains("Could not write to clipboard", output);
}
public void CanLimitMemory()
{
ulong limitInBytes = DefaultMemoryLimit;
ulong allocateBytes = limitInBytes * 2;
jobObject.SetJobMemoryLimit(limitInBytes);
var process = IFTestHelper.ExecuteInJob(jobObject, "allocate-memory", "--bytes", allocateBytes);
Assert.True(IFTestHelper.Failed(process));
}
public void Dispose()
{
if (processes != null)
{
foreach (var process in processes)
{
IFTestHelper.ContinueAndWait(process);
}
}
jobObject.Dispose();
}
public void WhenManagingOneProcess_ReturnsSingleProcessId()
{
processes = new[]
{
IFTestHelper.ExecuteWithWait("nop"),
};
jobObject.AssignProcessToJob(processes[0]);
var processIds = jobObject.GetProcessIds();
Assert.Collection(processIds,
x => Assert.Equal(processes[0].Id, x)
);
}
public void GetQueuedCompletionStatus_ForkBomb_DoesHaveLimitViolation()
{
using (var jobObject = new JobObject())
{
jobObject.SetActiveProcessLimit(2);
var process = IFTestHelper.ExecuteWithWait("fork-bomb");
jobObject.AssignProcessToJob(process);
IFTestHelper.Continue(process);
process.WaitForExit(1000);
var msgs = jobObject.GetQueuedCompletionStatus();
Assert.Contains(msgs, x => x == JobObject.CompletionMsg.ActiveProcessLimit);
}
}
public void ClipboardIsDisabledForReads()
{
var clipboardText = "Text From Test";
IFTestHelper.Execute("write-clipboard", clipboardText).WaitForExit();
var proc = IFTestHelper.Execute("read-clipboard");
proc.WaitForExit();
Assert.Equal(clipboardText, proc.StandardOutput.ReadToEnd().Trim());
proc = IFTestHelper.ExecuteInJob(jobObject, "read-clipboard");
proc.WaitForExit();
Assert.DoesNotContain(clipboardText, proc.StandardOutput.ReadToEnd().Trim());
}
public void CanGetMemoryPeak()
{
jobObject.SetJobMemoryLimit(DefaultMemoryLimit);
ulong allocateBytes = DefaultMemoryLimit * 2;
var process = IFTestHelper.ExecuteInJob(jobObject, "allocate-memory", "--bytes", allocateBytes);
if (IFTestHelper.Succeeded(process))
{
Assert.True(DefaultMemoryLimit <= jobObject.GetPeakJobMemoryUsed());
}
else
{
Assert.NotEqual(0UL, jobObject.GetPeakJobMemoryUsed());
}
}
public void GetQueuedCompletionStatus_CanLimitMemory()
{
using (var jobObject = new JobObject())
{
const ulong limitInBytes = 1024 * 1024 * 25; // 25MB
const ulong allocateBytes = limitInBytes * 2;
jobObject.SetJobMemoryLimit(limitInBytes);
var process = IFTestHelper.ExecuteInJob(jobObject, "allocate-memory", "--bytes", allocateBytes);
process.WaitForExit(1000);
var msgs = jobObject.GetQueuedCompletionStatus();
Assert.Contains(msgs, x => x == JobObject.CompletionMsg.JobMemoryLimit);
}
}
public void WhenManagedProcessCreatesChildProcess_ReturnsAllProcessIds()
{
// Arrange:
var process = IFTestHelper.ExecuteWithWait("create-child");
jobObject.AssignProcessToJob(process);
process.StandardInput.WriteLine();
var pidLine = process.StandardOutput.ReadLine();
int pid = Int32.Parse(pidLine);
// Act:
var managedProcesses = jobObject.GetProcessIds();
// Assert:
Assert.Contains(process.Id, managedProcesses);
Assert.Contains(pid, managedProcesses);
process.StandardInput.WriteLine();
process.WaitForExit();
Assert.True(IFTestHelper.Succeeded(process));
}
public void SetActiveProcessLimit_StopsForkBomb()
{
using (var jobObject = new JobObject())
{
jobObject.SetActiveProcessLimit(2);
var process = IFTestHelper.ExecuteWithWait("fork-bomb");
jobObject.AssignProcessToJob(process);
IFTestHelper.Continue(process);
process.WaitForExit(1000);
var hasExited = process.HasExited;
if (!hasExited)
{
process.Kill();
}
if (!hasExited)
{
Console.WriteLine(process.StandardOutput.ReadToEnd());
Console.Error.WriteLine(process.StandardError.ReadToEnd());
}
Assert.True(hasExited, "Active process limit was not enforced");
}
}
public void CanLimitCpu()
{
jobObject.SetJobCpuLimit(1);
jobObject2.SetJobCpuLimit(9);
var thread1 = new Thread(() =>
{
IFTestHelper.ExecuteInJob(jobObject, "consume-cpu", "--duration", "2000").WaitForExit();
});
var thread2 = new Thread(() =>
{
IFTestHelper.ExecuteInJob(jobObject2, "consume-cpu", "--duration", "2000").WaitForExit();
});
thread1.Start();
thread2.Start();
thread1.Join();
thread2.Join();
var ratio = (float)jobObject.GetCpuStatistics().TotalUserTime.Ticks / jobObject2.GetCpuStatistics().TotalUserTime.Ticks;
Assert.InRange(ratio, 0.01, 0.4);
}
public void CanSetPriority()
{
jobObject.SetPriorityClass(ProcessPriorityClass.Idle);
jobObject2.SetPriorityClass(ProcessPriorityClass.AboveNormal);
var thread1 = new Thread(() =>
{
IFTestHelper.ExecuteInJob(jobObject, "consume-cpu", "--duration", "4000").WaitForExit();
});
var thread2 = new Thread(() =>
{
IFTestHelper.ExecuteInJob(jobObject2, "consume-cpu", "--duration", "4000").WaitForExit();
});
thread1.Start();
thread2.Start();
thread1.Join();
thread2.Join();
var ratio = (float)jobObject.GetCpuStatistics().TotalUserTime.Ticks / jobObject2.GetCpuStatistics().TotalUserTime.Ticks;
Assert.InRange(ratio, 0.01, 0.5);
}
public void CanTerminateAndWaitForObjectsUnderJobObject()
{
JobObject jobObject = new JobObject();
Process p = null;
try
{
p = IFTestHelper.ExecuteWithWait("nop");
jobObject.AssignProcessToJob(p);
jobObject.TerminateProcessesAndWait(1000);
IFTestHelper.ContinueAndWait(p, timeout: 1000);
Assert.True(p.HasExited);
}
finally
{
if (!p.HasExited)
{
p.Kill();
}
}
}
public void Dispose()
{
jobObject.Dispose();
IFTestHelper.Execute("write-clipboard").WaitForExit();
}
