Add more process tests.

Author: Lakshmi Priya Sekar

src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessCollectionTests.cs

@@ -0,0 +1,139 @@
+// 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;
+using System.Linq;
+using Xunit;
+
+namespace System.Diagnostics.ProcessTests
+{
+    public class ProcessCollectionTests : ProcessTestBase
+    {
+        [Fact]
+        public void TestModuleCollectionBehavior()
+        {
+            ProcessModule[] mArray = _process.Modules.Cast<ProcessModule>().ToArray();
+
+            // Constructor
+            ProcessModuleCollection moduleCollection = new ProcessModuleCollection(mArray);
+
+            // Count
+            Assert.Equal(mArray.Count(), moduleCollection.Count);
+
+            // get_item, Contains, IndexOf
+            for (int i = 0; i < mArray.Count(); i++)
+            {
+                Assert.Equal(mArray[i], moduleCollection[i]);
+                Assert.True(moduleCollection.Contains(mArray[i]));
+                Assert.Equal(i, moduleCollection.IndexOf(mArray[i]));
+            }
+
+            // CopyTo
+            ProcessModule[] moduleArray = new ProcessModule[moduleCollection.Count + 1];
+            moduleCollection.CopyTo(moduleArray, 1);
+            for (int i = 0; i < mArray.Count(); i++)
+            {
+                Assert.Equal(mArray[i], moduleArray[i + 1]);
+            }
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => moduleCollection.CopyTo(moduleArray, -1));
+
+            // Explicit interface implementations
+            Assert.False(((ICollection)moduleCollection).IsSynchronized);
+            Assert.NotNull(((ICollection)moduleCollection).SyncRoot);
+
+            moduleArray = new ProcessModule[moduleCollection.Count];
+            ((ICollection)moduleCollection).CopyTo(moduleArray, 0);
+            Assert.Equal(moduleCollection.Cast<ProcessModule>().ToArray(), moduleArray);
+
+            // GetEnumerator
+            IEnumerator enumerator = moduleCollection.GetEnumerator();
+            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
+
+            for (int i = 0; i < moduleCollection.Count; i++)
+            {
+                enumerator.MoveNext();
+                Assert.Equal(moduleCollection[i], enumerator.Current);
+            }
+        }
+
+        [Fact]
+        public void TestThreadCollectionBehavior()
+        {
+            ProcessThread[] tArray = _process.Threads.Cast<ProcessThread>().ToArray();
+            int countOfTArray = tArray.Count();
+
+            // constructor
+            ProcessThreadCollection threadCollection = new ProcessThreadCollection(tArray);
+
+            // Count
+            Assert.Equal(countOfTArray, threadCollection.Count);
+
+            // get_item, Contains, IndexOf
+            for (int i = 0; i < countOfTArray; i++)
+            {
+                Assert.Equal(tArray[i], threadCollection[i]);
+                Assert.True(threadCollection.Contains(tArray[i]));
+                Assert.Equal(i, threadCollection.IndexOf(tArray[i]));
+            }
+
+            // CopyTo
+            ProcessThread[] threadArray = new ProcessThread[threadCollection.Count + 1];
+            threadCollection.CopyTo(threadArray, 1);
+            for (int i = 0; i < countOfTArray; i++)
+            {
+                Assert.Equal(tArray[i], threadArray[i + 1]);
+            }
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => threadCollection.CopyTo(threadArray, -1));
+
+            // Remove
+            threadCollection.Remove(tArray[0]);
+            Assert.Equal(-1, threadCollection.IndexOf(tArray[0]));
+            Assert.False(threadCollection.Contains(tArray[0]));
+            // Try remove non existent member
+            threadCollection.Remove(tArray[0]);
+            // Cleanup after remove
+            threadCollection.Insert(0, tArray[0]);
+
+            // Add
+            threadCollection.Add(default(ProcessThread));
+            Assert.Equal(threadCollection.Count - 1, threadCollection.IndexOf(default(ProcessThread)));
+            // Add same member again
+            threadCollection.Add(default(ProcessThread));
+            Assert.Equal(threadCollection.Count - 2, threadCollection.IndexOf(default(ProcessThread)));
+            Assert.Equal(default(ProcessThread), threadCollection[threadCollection.Count - 1]);
+            // Cleanup after Add.
+            threadCollection.Remove(default(ProcessThread));
+            threadCollection.Remove(default(ProcessThread));
+            Assert.False(threadCollection.Contains(default(ProcessThread)));
+
+            // Insert
+            int index = threadCollection.Count / 2;
+            int initialCount = threadCollection.Count;
+            threadCollection.Insert(index, null);
+            Assert.Equal(index, threadCollection.IndexOf(null));
+            Assert.Equal(initialCount + 1, threadCollection.Count);
+            // Insert at invalid index
+            Assert.Throws<ArgumentOutOfRangeException>(() => threadCollection.Insert(-1, tArray[0]));
+
+            // Explicit interface implementations
+            Assert.False(((ICollection)threadCollection).IsSynchronized);
+            Assert.NotNull(((ICollection)threadCollection).SyncRoot);
+
+            threadArray = new ProcessThread[threadCollection.Count];
+            ((ICollection)threadCollection).CopyTo(threadArray, 0);
+            Assert.Equal(threadCollection.Cast<ProcessThread>().ToArray(), threadArray);
+
+            // GetEnumerator
+            IEnumerator enumerator = threadCollection.GetEnumerator();
+            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
+
+            for (int i = 0; i < threadCollection.Count; i++)
+            {
+                enumerator.MoveNext();
+                Assert.Equal(threadCollection[i], enumerator.Current);
+            }
+        }
+    }
+}

src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessTests.cs

@@ -544,6 +544,34 @@ public void TestGetProcessesByName()
             Assert.True(Process.GetProcessesByName(currentProcess.ProcessName, currentProcess.MachineName).Count() > 0, "TestGetProcessesByName001 failed");
         }
 
+        public static IEnumerable<object[]> GetTestProcess()
+        {
+            Process currentProcess = Process.GetCurrentProcess();
+            yield return new object[] { currentProcess, Process.GetProcessById(currentProcess.Id, "127.0.0.1") };
+            yield return new object[] { currentProcess, Process.GetProcessesByName(currentProcess.ProcessName, "127.0.0.1").Where(p => p.Id == currentProcess.Id).Single() };
+        }
+
+        [Theory, PlatformSpecific(PlatformID.Windows)]
+        [MemberData("GetTestProcess")]
+        public void TestProcessOnRemoteMachineWindows(Process currentProcess, Process remoteProcess)
+        {
+            Assert.Equal(currentProcess.Id, remoteProcess.Id);
+            Assert.Equal(currentProcess.BasePriority, remoteProcess.BasePriority);
+            Assert.Equal(currentProcess.EnableRaisingEvents, remoteProcess.EnableRaisingEvents);
+            Assert.Equal("127.0.0.1", remoteProcess.MachineName);
+            // This property throws exception only on remote processes.
+            Assert.Throws<NotSupportedException>(() => remoteProcess.MainModule);
+        }
+
+        [Fact, PlatformSpecific(PlatformID.AnyUnix)]
+        public void TestProcessOnRemoteMachineUnix()
+        {
+            Process currentProcess = Process.GetCurrentProcess();
+
+            Assert.Throws<PlatformNotSupportedException>(() => Process.GetProcessesByName(currentProcess.ProcessName, "127.0.0.1"));
+            Assert.Throws<PlatformNotSupportedException>(() => Process.GetProcessById(currentProcess.Id, "127.0.0.1"));
+        }
+
         [Fact]
         public void TestStartInfo()
         {

src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessThreadTests.cs

@@ -22,6 +22,7 @@ public void TestCommonPriorityAndTimeProperties()
 
             if (ThreadState.Terminated != thread.ThreadState)
             {
+                Assert.True(thread.Id >= 0);
                 Assert.Equal(_process.BasePriority, thread.BasePriority);
                 Assert.True(thread.CurrentPriority >= 0);
                 Assert.True(thread.PrivilegedProcessorTime.TotalSeconds >= 0);

src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/System.Diagnostics.Process.Tests.csproj

@@ -21,6 +21,7 @@
     <Compile Include="$(CommonTestPath)\System\Diagnostics\AssertWithCallerAttributes.cs">
       <Link>Common\tests\System\Diagnostics\AssertWithCallerAttributes.cs</Link>
     </Compile>
+    <Compile Include="ProcessCollectionTests.cs" />
     <Compile Include="ProcessModuleTests.cs" />
     <Compile Include="ProcessStartInfoTests.cs" />
     <Compile Include="Interop.cs" />