public void ProcessInfo_TestEqualishWorksAlwaysReturnsFalseForDifferentProcesses()
        {
            var info1 = new ProcessInfo("process.exe", "TestDocument.doc *");
            var info2 = new ProcessInfo("process2.exe", "TestDocument.doc");

            info1.IsEqualishTo(info2).Should().BeFalse("because they're different processes");
        }

        public void ProcessInfo_TestEverything()
        {
            ProcessInfo p1 = new ProcessInfo();
            Assert.AreEqual(0, p1.ProcessId);
            Assert.AreEqual(ProcessInfo.ProcessType.Unknown, p1.Type);
            Assert.IsNull(p1.EndPoint);
            Assert.IsNull(p1.Label);
            Assert.AreEqual(ProcessInfo.StatusCode.Unknown, p1.Status);
            Assert.IsNull(p1.AliveTimestamp);

            PublicEndPoint ep1 = new PublicEndPoint() { Host = "swcwin.serv.usu.edu", Port = 32541 };
            DateTime t1 = DateTime.Now;
            ProcessInfo p2 = new ProcessInfo()
                {
                    ProcessId = 10,
                    Type = ProcessInfo.ProcessType.Player,
                    EndPoint = ep1,
                    Label = "Test Process",
                    Status = ProcessInfo.StatusCode.Initializing,
                    AliveTimestamp = t1
                };
            Assert.AreEqual(10, p2.ProcessId);
            Assert.AreEqual(ProcessInfo.ProcessType.Player, p2.Type);
            Assert.AreEqual(ep1, p2.EndPoint);
            Assert.AreEqual("Test Process", p2.Label);
            Assert.AreEqual(ProcessInfo.StatusCode.Initializing, p2.Status);
            Assert.AreEqual("Initializing", p2.StatusString);
            Assert.AreEqual(t1, p2.AliveTimestamp);
        }

 public ProcessMonitor(Process p)
 {
     m_process = p;
     m_info = new ProcessInfo(p);
     UpdateDeltas();
     //m_cpucounter = new PerformanceCounter("Processor", "% Processor Time", GetPerformanceCounterProcessName(m_process.Id), true);
 }

 public void StreamEncodingCanBeChanged()
 {
     var info = new ProcessInfo("somewhere");
     var encoding = Encoding.UTF32;
     info.StreamEncoding = encoding;
     Assert.AreEqual(encoding, info.StreamEncoding);
 }

 public void StandardInputContentCanBeChanged()
 {
     var info = new ProcessInfo("somewhere");
     var expected = "some data to pass in";
     info.StandardInputContent = expected;
     Assert.AreEqual(expected, info.StandardInputContent);
 }

        public void Show(ProcessInfo process, string whatsHigh)
        {
            this._Process = process;

            this.Text = "Warning! Process taking high " + whatsHigh;
            this.TitleLabel.Text = "The following process is taking high " + whatsHigh + " and should be closed:";
            this.ProcessNameLabel.Text = process.Title;
            this.PostponeButton.Text = string.Format("Postpone {0} mins", Settings.Default.Default_Postpone_Time.TotalMinutes);
            this.CPULabel.Text = process.CpuUsage + "%";
            this.MemoryLabel.Text = (process.WorkingSet / 1048576) + " MB";
            try
            {
                Process realProcess = Process.GetProcessById(process.Id);
                this.ProcessNameLabel.Text = realProcess.MainWindowTitle;

            }
            catch
            {
            }

            this.Show();
            this.Refresh();
            this.TopMost = true;

            this.DummyTextBox.Focus();
        }

 public void MinimalConstructorSetsFilename()
 {
     var filename = "nameoffile";
     var info = new ProcessInfo(filename);
     Assert.AreEqual(filename, info.FileName);
     Assert.AreEqual(2, info.TimeOut.Minutes);
 }

        public static System.Diagnostics.Process CreateProcess(string path, string args, string currentDirectory)
        {
            if (!File.Exists(path))
            {
                throw new ArgumentException("File does not exist");
            }
            ProcessInfo proc = new ProcessInfo();
            try
            {
                var inf = new StartupInfo();

                inf.cb = (uint)Marshal.SizeOf(typeof(StartupInfo));
                var cmd = path;
                if(!string.IsNullOrWhiteSpace(args))
                {
                    cmd += " " + args;
                }
                if (!CreateProcess(null, cmd, IntPtr.Zero, IntPtr.Zero, false, CREATE_BREAKAWAY_FROM_JOB | CREATE_NO_WINDOW, IntPtr.Zero, currentDirectory, ref inf, out proc))
                {
                    throw new InvalidOperationException("Couldn't create process");
                }

                return System.Diagnostics.Process.GetProcessById(proc.ProcessId);
            }
            finally
            {
                if (proc.hProcess != IntPtr.Zero)
                {
                    Interop.CloseHandle(proc.hProcess);
                }
            }


        }

		public void ShouldNotUseATimeoutIfTimeoutSetToInfiniteOnProcessInfo()
		{
			ProcessInfo processInfo = new ProcessInfo("cmd.exe", "/C @echo Hello World");
			processInfo.TimeOut = ProcessInfo.InfiniteTimeout;
			ProcessResult result = executor.Execute(processInfo);
			AssertProcessExitsSuccessfully(result);
			Assert.AreEqual("Hello World", result.StandardOutput.Trim());			
		}

        public void ProcessInfo_TestEqualishWorksWithUnsavedDocumentMarkers()
        {
            var processName = "process.exe";
            var info1 = new ProcessInfo(processName, "TestDocument.doc *");
            var info2 = new ProcessInfo(processName, "TestDocument.doc");

            info1.IsEqualishTo(info2).Should().BeTrue("because the process name is the same and the window title is basically the same!");
        }

		public void IfStandardInputContentIsSetThenStandardInputIsRedirected()
		{
			ProcessInfo info = new ProcessInfo("temp");
			info.StandardInputContent = "Some content";

			Process process = info.CreateProcess();
			Assert.IsTrue(process.StartInfo.RedirectStandardInput);
			Assert.IsTrue(!process.StartInfo.UseShellExecute);
		}

		public void SetEnvironmentVariables()
		{
			ProcessInfo processInfo = new ProcessInfo("cmd.exe", "/C set foo", null);
			processInfo.EnvironmentVariables["foo"] = "bar";
			ProcessResult result = executor.Execute(processInfo);

			AssertProcessExitsSuccessfully(result);
			Assert.AreEqual("foo=bar\r\n", result.StandardOutput);
		}

 private static void WriteToStandardInput(Process process, ProcessInfo processInfo)
 {
     if (process.StartInfo.RedirectStandardInput)
     {
         process.StandardInput.Write(processInfo.StandardInputContent);
         process.StandardInput.Flush();
         process.StandardInput.Close();
     }
 }

        public void ProcessInfo_ConstructorShouldSetProperties()
        {
            var name = "process.exe";
            var title = "window title";
            var info = new ProcessInfo(name, title);

            info.Name.Should().BeEquivalentTo(name);
            info.WindowTitle.Should().BeEquivalentTo(title);
        }

		public void ForceProcessTimeoutBecauseTargetIsNonTerminating()
		{
			ProcessInfo processInfo = new ProcessInfo("sleeper.exe");
			processInfo.TimeOut = 100;
			ProcessResult result = executor.Execute(processInfo);

			Assert.IsTrue(result.TimedOut, "process did not time out, but it should have.");
			Assert.IsNotNull(result.StandardOutput, "some output should have been produced");
			AssertProcessExitsWithFailure(result);
		}

		public void IfExecutableIsFoundInWorkingDirectoryThenUseCombinedPathAsExecutablePath()
		{
			string workingDir = TempFileUtil.CreateTempDir("working");
			string executablePath = TempFileUtil.CreateTempFile("working", "myExecutable");

			ProcessInfo infoWithoutPathQualifiedExecutable = new ProcessInfo("myExecutable", "", workingDir);
			ProcessInfo infoWithPreQualifiedExecutable = new ProcessInfo(executablePath, "", workingDir);

			Assert.AreEqual(infoWithPreQualifiedExecutable, infoWithoutPathQualifiedExecutable);
		}

 public AppStatus(InstallDirectoryItem appInstallation, string iconUrl, ProcessInfo processInfo, string error)
 {
     Id = appInstallation.PackageId;
     Version = appInstallation.PackageVersion;
     Instance = appInstallation.Instance;
     FullName = $"{appInstallation.PackageId}.{appInstallation.PackageVersion}@{appInstallation.Instance}".TrimEnd('@');
     IconUrl = iconUrl;
     ProcessInfo = processInfo;
     Error = error;
 }

        public void ProcessInfo_TestEqualityWorks()
        {
            var info1 = new ProcessInfo("process.exe", "window title");
            var info2 = new ProcessInfo("process.exe", "window title");
            var info3 = new ProcessInfo("process.exe", "different window title");
            var info4 = new ProcessInfo("proc.exe", "window title");

            info1.Equals(info2).Should().BeTrue("because the two objects have the same process/window title");
            info1.Equals(info3).Should().BeFalse("because the window titles are different");
            info1.Equals(info4).Should().BeFalse("because the process titles are different");
        }

 public Player()
 {
     Label = "Drew's Player";
     MyProcessInfo = new ProcessInfo()
     {
         Status = ProcessInfo.StatusCode.NotInitialized,
         Label = Label,
         Type = ProcessInfo.ProcessType.Player
     };
     CleanupSession();
 }

 static extern bool CreateProcess(
     string lpApplicationName,
     string lpCommandLine, 
     ref SECURITY_ATTRIBUTES lpProcessAttributes,
     ref SECURITY_ATTRIBUTES lpThreadAttributes, 
     bool bInheritHandles,
     uint dwCreationFlags, 
     IntPtr lpEnvironment, 
     string lpCurrentDirectory,
     [In] ref StartupInfo lpStartupInfo,
     out ProcessInfo lpProcessInformation);