Add test coverage to System.Diagnostics.Process types.

Lakshmi Priya Sekar · Lakshmi Priya Sekar · commit b1fede30ac2d · 2015-07-22T14:43:15.000-07:00
In this commit, represented internal ThreadInfo.threadId to ulong, as OSX
threadIds are 64 bit. Changed implementation of PriorityLevel property on
a Thread on OSX to throw PNSE. Added tests to types ProcessModule and
ProcessThread.
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/Process.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/Process.cs
@@ -511,6 +511,7 @@ public ProcessThreadCollection Threads
                     {
                         newThreadsArray[i] = new ProcessThread(_isRemoteMachine, _processId, (ThreadInfo)_processInfo._threadInfoList[i]);
                     }
+
                     ProcessThreadCollection newThreads = new ProcessThreadCollection(newThreadsArray);
                     _threads = newThreads;
                 }
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Linux.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Linux.cs
@@ -118,7 +118,7 @@ private static ProcessInfo CreateProcessInfo(int pid)
                         pi._threadInfoList.Add(new ThreadInfo
                         {
                             _processId = pid,
-                            _threadId = tid,
+                            _threadId = (ulong)tid,
                             _basePriority = pi.BasePriority,
                             _currentPriority = (int)stat.nice,
                             _startAddress = (IntPtr)stat.startstack,
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.OSX.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.OSX.cs
@@ -56,8 +56,8 @@ private static ProcessInfo CreateProcessInfo(int pid)
                 var ti = new ThreadInfo()
                 {
                     _processId = pid,
-                    _threadId = (int)t.Key, // The OS X thread ID is 64-bits, but we're forced to truncate due to the public API signature
-                    _basePriority = 0,
+                    _threadId = t.Key,
+                    _basePriority = procInfo.BasePriority,
                     _startAddress = IntPtr.Zero
                 };
 
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Windows.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Windows.cs
@@ -677,7 +677,7 @@ static ThreadInfo GetThreadInfo(Interop.mincore.PERF_OBJECT_TYPE type, IntPtr in
                         threadInfo._processId = (int)value;
                         break;
                     case ValueId.ThreadId:
-                        threadInfo._threadId = (int)value;
+                        threadInfo._threadId = (ulong)value;
                         break;
                     case ValueId.BasePriority:
                         threadInfo._basePriority = (int)value;
@@ -992,7 +992,7 @@ static ProcessInfo[] GetProcessInfos(IntPtr dataPtr)
                     ThreadInfo threadInfo = new ThreadInfo();
 
                     threadInfo._processId = (int)ti.UniqueProcess;
-                    threadInfo._threadId = (int)ti.UniqueThread;
+                    threadInfo._threadId = (ulong)ti.UniqueThread;
                     threadInfo._basePriority = ti.BasePriority;
                     threadInfo._currentPriority = ti.Priority;
                     threadInfo._startAddress = ti.StartAddress;
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.OSX.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.OSX.cs
@@ -16,22 +16,11 @@ private ThreadPriorityLevel PriorityLevelCore
         {
             get
             {
-                int nice = 0;
-                int result = Interop.libc.getpriority(Interop.libc.PriorityWhich.PRIO_DARWIN_THREAD, _threadInfo._threadId, out nice);
-                if (result != 0)
-                {
-                    throw new System.ComponentModel.Win32Exception();
-                }
-
-                return Interop.libc.GetThreadPriorityFromNiceValue(nice);
+                throw new PlatformNotSupportedException();
             }
             set
             {
-                int result = Interop.libc.setpriority(Interop.libc.PriorityWhich.PRIO_DARWIN_THREAD, _threadInfo._threadId, Interop.libc.GetNiceValueFromThreadPriority(value));
-                if (result != 0)
-                {
-                    throw new System.ComponentModel.Win32Exception();
-                }
+                throw new PlatformNotSupportedException();
             }
         }
 
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.Windows.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.Windows.cs
@@ -171,7 +171,7 @@ private ProcessThreadTimes GetThreadTimes()
         private SafeThreadHandle OpenThreadHandle(int access)
         {
             EnsureState(State.IsLocal);
-            return ProcessManager.OpenThread(_threadInfo._threadId, access);
+            return ProcessManager.OpenThread((int)_threadInfo._threadId, access);
         }
     }
 }
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessThread.cs
@@ -53,7 +53,7 @@ public int CurrentPriority
         /// </devdoc>
         public int Id
         {
-            get { return _threadInfo._threadId; }
+            get { return (int)_threadInfo._threadId; }
         }
 
         /// <devdoc>
diff --git a/src/System.Diagnostics.Process/src/System/Diagnostics/ThreadInfo.cs b/src/System.Diagnostics.Process/src/System/Diagnostics/ThreadInfo.cs
@@ -12,7 +12,7 @@ namespace System.Diagnostics
     /// <internalonly/>
     internal sealed class ThreadInfo
     {
-        internal int _threadId;
+        internal ulong _threadId;
         internal int _processId;
         internal int _basePriority;
         internal int _currentPriority;
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessModuleTests.cs b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessModuleTests.cs
@@ -0,0 +1,52 @@
+﻿// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Security;
+using System.IO;
+using Xunit;
+using System.Threading;
+
+namespace System.Diagnostics.ProcessTests
+{
+    public class ProcessModuleTests : ProcessTestBase
+    {
+        [Fact, PlatformSpecific(~PlatformID.OSX)]
+        public void TestModulePropertiesExceptOnOSX()
+        {
+            string fileName = CoreRunName;
+            if (global::Interop.IsWindows)
+                fileName = string.Format("{0}.exe", CoreRunName);
+
+            // Ensure the process has loaded the modules.
+            Assert.True(SpinWait.SpinUntil(() =>
+            {
+                if (_process.Modules.Count > 0)
+                    return true;
+                _process.Refresh();
+                return false;
+            }, WaitInMS));
+
+            ProcessModuleCollection moduleCollection = _process.Modules;
+            Assert.True(moduleCollection.Count > 0);
+
+            ProcessModule coreRunModule = _process.MainModule;
+            Assert.True(coreRunModule.BaseAddress.ToInt64() > 0);
+            Assert.True(coreRunModule.EntryPointAddress.ToInt64() >= 0);
+            Assert.Equal(fileName, coreRunModule.ModuleName);
+            Assert.True(coreRunModule.ModuleMemorySize > 0);
+            Assert.EndsWith(fileName, coreRunModule.FileName);
+
+            Assert.Equal(string.Format("System.Diagnostics.ProcessModule ({0})", fileName), coreRunModule.ToString());
+        }
+
+        [Fact, PlatformSpecific(PlatformID.OSX)]
+        public void TestModulePropertiesOnOSX()
+        {
+            // Getting modules for a process given a pid is not supported on OSX.
+            ProcessModuleCollection moduleCollection = _process.Modules;
+            Assert.Equal(0, moduleCollection.Count);
+            Assert.Null(_process.MainModule);
+        }
+    }
+}
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessStartInfoTests.cs b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessStartInfoTests.cs
@@ -2,6 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.Security;
+using System.IO;
 using Xunit;
 
 namespace System.Diagnostics.ProcessTests
@@ -186,5 +188,59 @@ public void TestUseShellExecuteProperty()
             // Calling the getter
             Assert.False(psi.UseShellExecute, "UseShellExecute=true is not supported on onecore.");
         }
+
+        [Fact]
+        public void TestArgumentsProperty()
+        {
+            ProcessStartInfo psi = new ProcessStartInfo();
+            Assert.Equal(string.Empty, psi.Arguments);
+
+            psi = new ProcessStartInfo("filename", "-arg1 -arg2");
+            Assert.Equal("-arg1 -arg2", psi.Arguments);
+        }
+
+        [Fact]
+        public void TestCreateNoWindowProperty()
+        {
+            Process testProcess = CreateProcessInfinite();
+            try
+            {
+                testProcess.StartInfo.CreateNoWindow = true;
+                testProcess.Start();
+
+                Assert.True(testProcess.StartInfo.CreateNoWindow);
+            }
+            finally
+            {
+                if (!testProcess.HasExited)
+                    testProcess.Kill();
+
+                Assert.True(testProcess.WaitForExit(WaitInMS));
+            }
+        }
+
+        [Fact, PlatformSpecific(PlatformID.Windows)]
+        public void TestUserCredentialsPropertiesOnWindows()
+        {
+            // test the defaults here.
+            Assert.Equal(string.Empty, _process.StartInfo.Domain);
+            Assert.Equal(string.Empty, _process.StartInfo.UserName);
+            Assert.Equal(default(SecureString), _process.StartInfo.Password);
+            Assert.False(_process.StartInfo.LoadUserProfile);
+        }
+
+        [Fact, PlatformSpecific(PlatformID.AnyUnix)]
+        public void TestUserCredentialsPropertiesOnUnix()
+        {
+            Assert.Throws<PlatformNotSupportedException>(() => _process.StartInfo.Domain);
+            Assert.Throws<PlatformNotSupportedException>(() => _process.StartInfo.UserName);
+            Assert.Throws<PlatformNotSupportedException>(() => _process.StartInfo.Password);
+            Assert.Throws<PlatformNotSupportedException>(() => _process.StartInfo.LoadUserProfile);
+        }
+
+        public void TestWorkingDirectoryProperty()
+        {
+            Assert.Equal(Directory.GetCurrentDirectory(), _process.StartInfo.WorkingDirectory);
+        }
     }
 }
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessTests.cs b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessTests.cs
@@ -1,11 +1,9 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.Win32.SafeHandles;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Threading;
 using Xunit;
 
@@ -373,6 +371,9 @@ public void TestProcessStartTime()
             try
             {
                 p.Start();
+
+                // Ensure process has been started, should not throw.
+                Process accessProcessFromMachine = Process.GetProcessById(p.Id);
                 Assert.True(p.StartTime.ToUniversalTime() <= DateTime.UtcNow, string.Format("Process StartTime is larger than later time."));
             }
             finally
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessThreadTests.cs b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessThreadTests.cs
@@ -0,0 +1,100 @@
+﻿// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Security;
+using System.IO;
+using Xunit;
+
+namespace System.Diagnostics.ProcessTests
+{
+    public class ProcessThreadTests : ProcessTestBase
+    {
+        [Fact]
+        public void TestCommonPriorityAndTimeProperties()
+        {
+            ProcessThreadCollection threadCollection = _process.Threads;
+            Assert.True(threadCollection.Count > 0);
+
+            ProcessThread thread = threadCollection[0];
+
+            if (ThreadState.Terminated != thread.ThreadState)
+            {
+                Assert.Equal(_process.BasePriority, thread.BasePriority);
+                Assert.True(thread.CurrentPriority >= 0, "Thread CurrentPriority");
+                Assert.True(thread.PrivilegedProcessorTime.TotalSeconds >= 0, "Thread PrivilegedProcessorTime");
+                Assert.True(thread.UserProcessorTime.TotalSeconds >= 0, "Thread UserProcessorTime");
+                Assert.True(thread.TotalProcessorTime.TotalSeconds >= 0, "Thread TotalProcessorTime");
+            }
+        }
+
+        [Fact]
+        public void TestStartTimeProperty()
+        {
+            ProcessThreadCollection threadCollection = _process.Threads;
+            Assert.True(threadCollection.Count > 0);
+
+            ProcessThread thread = threadCollection[0];
+
+            if (global::Interop.IsOSX)
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => thread.StartTime);
+                return;
+            }
+
+            if (ThreadState.Initialized != thread.ThreadState)
+            {
+                Assert.True(thread.StartTime.ToUniversalTime() <= DateTime.UtcNow, "Thread StartTime");
+            }
+        }
+
+        [Fact]
+        public void TestStartAddressProperty()
+        {
+            ProcessThread thread = _process.Threads[0];
+            Assert.Equal(global::Interop.IsOSX, thread.StartAddress == IntPtr.Zero);
+        }
+
+        [Fact]
+        public void TestPriorityLevelProperty()
+        {
+            ProcessThread thread = _process.Threads[0];
+
+            if (global::Interop.IsOSX)
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => thread.PriorityLevel);
+                Assert.Throws<PlatformNotSupportedException>(() => thread.PriorityLevel = ThreadPriorityLevel.AboveNormal);
+                return;
+            }
+
+            ThreadPriorityLevel originalPriority = thread.PriorityLevel;
+
+            if (global::Interop.IsLinux)
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => thread.PriorityLevel = ThreadPriorityLevel.AboveNormal);
+                return;
+            }
+
+            try
+            {
+                thread.PriorityLevel = ThreadPriorityLevel.AboveNormal;
+                Assert.Equal(ThreadPriorityLevel.AboveNormal, thread.PriorityLevel);
+            }
+            finally
+            {
+                thread.PriorityLevel = originalPriority;
+                Assert.Equal(originalPriority, thread.PriorityLevel);
+            }
+        }
+
+        [Fact]
+        public void TestThreadStateProperty()
+        {
+            ProcessThread thread = _process.Threads[0];
+            if (ThreadState.Wait != thread.ThreadState)
+            {
+                Assert.Throws<InvalidOperationException>(() => thread.WaitReason);
+            }
+        }
+    }
+}
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/System.Diagnostics.Process.Tests.csproj b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/System.Diagnostics.Process.Tests.csproj
@@ -16,6 +16,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="ProcessModuleTests.cs" />
     <Compile Include="ProcessStartInfoTests.cs" />
     <Compile Include="Interop.cs" />
     <Compile Include="ProcessTests.cs" />
@@ -25,6 +26,7 @@
       <Link>Common\Interop\Interop.PlatformDetection.cs</Link>
     </Compile>
     <Compile Include="ProcessTestBase.cs" />
+    <Compile Include="ProcessThreadTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="project.json" />
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/project.json b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/project.json
@@ -4,6 +4,7 @@
     "System.Collections": "4.0.10-beta-*",
     "System.Console": "4.0.0-beta-*",
     "System.IO": "4.0.10-beta-*",
+    "System.IO.FileSystem": "4.0.0-beta-*",
     "System.IO.Pipes": "4.0.0-beta-*",
     "System.Linq": "4.0.0-beta-*",
     "System.Runtime": "4.0.20-beta-*",
diff --git a/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/project.lock.json b/src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/project.lock.json

Original file line number	Diff line number	Diff line change
`@@ -511,6 +511,7 @@ public ProcessThreadCollection Threads`
`511`	`511`	`{`
`512`	`512`	`newThreadsArray[i] = new ProcessThread(_isRemoteMachine, _processId, (ThreadInfo)_processInfo._threadInfoList[i]);`
`513`	`513`	`}`
	`514`	`+`
`514`	`515`	`ProcessThreadCollection newThreads = new ProcessThreadCollection(newThreadsArray);`
`515`	`516`	`_threads = newThreads;`
`516`	`517`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ private static ProcessInfo CreateProcessInfo(int pid)`
`118`	`118`	`pi._threadInfoList.Add(new ThreadInfo`
`119`	`119`	`{`
`120`	`120`	`_processId = pid,`
`121`		`- _threadId = tid,`
	`121`	`+ _threadId = (ulong)tid,`
`122`	`122`	`_basePriority = pi.BasePriority,`
`123`	`123`	`_currentPriority = (int)stat.nice,`
`124`	`124`	`_startAddress = (IntPtr)stat.startstack,`
Original file line number	Diff line number	Diff line change
`@@ -16,22 +16,11 @@ private ThreadPriorityLevel PriorityLevelCore`
`16`	`16`	`{`
`17`	`17`	`get`
`18`	`18`	`{`
`19`		`- int nice = 0;`
`20`		`- int result = Interop.libc.getpriority(Interop.libc.PriorityWhich.PRIO_DARWIN_THREAD, _threadInfo._threadId, out nice);`
`21`		`- if (result != 0)`
`22`		`- {`
`23`		`- throw new System.ComponentModel.Win32Exception();`
`24`		`- }`
`25`		`-`
`26`		`- return Interop.libc.GetThreadPriorityFromNiceValue(nice);`
	`19`	`+ throw new PlatformNotSupportedException();`
`27`	`20`	`}`
`28`	`21`	`set`
`29`	`22`	`{`
`30`		`- int result = Interop.libc.setpriority(Interop.libc.PriorityWhich.PRIO_DARWIN_THREAD, _threadInfo._threadId, Interop.libc.GetNiceValueFromThreadPriority(value));`
`31`		`- if (result != 0)`
`32`		`- {`
`33`		`- throw new System.ComponentModel.Win32Exception();`
`34`		`- }`
	`23`	`+ throw new PlatformNotSupportedException();`
`35`	`24`	`}`
`36`	`25`	`}`
`37`	`26`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ private ProcessThreadTimes GetThreadTimes()`
`171`	`171`	`private SafeThreadHandle OpenThreadHandle(int access)`
`172`	`172`	`{`
`173`	`173`	`EnsureState(State.IsLocal);`
`174`		`- return ProcessManager.OpenThread(_threadInfo._threadId, access);`
	`174`	`+ return ProcessManager.OpenThread((int)_threadInfo._threadId, access);`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public int CurrentPriority`
`53`	`53`	`/// </devdoc>`
`54`	`54`	`public int Id`
`55`	`55`	`{`
`56`		`- get { return _threadInfo._threadId; }`
	`56`	`+ get { return (int)_threadInfo._threadId; }`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/// <devdoc>`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace System.Diagnostics`
`12`	`12`	`/// <internalonly/>`
`13`	`13`	`internal sealed class ThreadInfo`
`14`	`14`	`{`
`15`		`- internal int _threadId;`
	`15`	`+ internal ulong _threadId;`
`16`	`16`	`internal int _processId;`
`17`	`17`	`internal int _basePriority;`
`18`	`18`	`internal int _currentPriority;`