Tweak path related tests

src/CoreFx.Private.TestUtilities/ref/CoreFx.Private.TestUtilities.cs

@@ -35,6 +35,11 @@ public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType>(System.A
             where TFirstExceptionType : System.Exception
             where TSecondExceptionType : System.Exception
         { }
+        public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType, TThirdExceptionType>(Action action)
+            where TFirstExceptionType : Exception
+            where TSecondExceptionType : Exception
+            where TThirdExceptionType : Exception
+        { }
         public static void ThrowsIf<T>(bool condition, System.Action action) where T : System.Exception { }
         public static void GreaterThan<T>(T actual, T greaterThan, string userMessage = null) where T : System.IComparable { }
         public static void LessThan<T>(T actual, T lessThan, string userMessage = null) where T : System.IComparable { }

src/CoreFx.Private.TestUtilities/src/System/AssertExtensions.cs

@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Sdk;
+using System.Linq;
 
 namespace System
 {
@@ -93,27 +94,41 @@ public static void Throws<TNetCoreExceptionType, TNetFxExceptionType>(string net
         }
 
         public static void ThrowsAny(Type firstExceptionType, Type secondExceptionType, Action action)
+        {
+            ThrowsAnyInternal(action, firstExceptionType, secondExceptionType);
+        }
+
+        private static void ThrowsAnyInternal(Action action, params Type[] exceptionTypes)
         {
             try
             {
                 action();
             }
             catch (Exception e)
             {
-                if (e.GetType().Equals(firstExceptionType) || e.GetType().Equals(secondExceptionType))
-                {
+                Type exceptionType = e.GetType();
+                if (exceptionTypes.Any(t => t.Equals(exceptionType)))
                     return;
-                }
-                throw new XunitException($"Expected: ({firstExceptionType}) or ({secondExceptionType}) -> Actual: ({e.GetType()})");
+
+                throw new XunitException($"Expected one of: ({string.Join<Type>(", ", exceptionTypes)}) -> Actual: ({e.GetType()})");
             }
-            throw new XunitException("AssertExtensions.ThrowsAny<firstExceptionType, secondExceptionType> didn't throw any exception");
+
+            throw new XunitException($"Expected one of: ({string.Join<Type>(", ", exceptionTypes)}) -> Actual: No exception thrown");
         }
 
         public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType>(Action action)
             where TFirstExceptionType : Exception
             where TSecondExceptionType : Exception
         {
-           ThrowsAny(typeof(TFirstExceptionType), typeof(TSecondExceptionType), action);
+            ThrowsAnyInternal(action, typeof(TFirstExceptionType), typeof(TSecondExceptionType));
+        }
+
+        public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType, TThirdExceptionType>(Action action)
+            where TFirstExceptionType : Exception
+            where TSecondExceptionType : Exception
+            where TThirdExceptionType : Exception
+        {
+            ThrowsAnyInternal(action, typeof(TFirstExceptionType), typeof(TSecondExceptionType), typeof(TThirdExceptionType));
         }
 
         public static void ThrowsIf<T>(bool condition, Action action)

src/CoreFx.Private.TestUtilities/tests/AssertExtensionTests.cs

@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Sdk;
+
+namespace CoreFx.Private.TestUtilities.Tests
+{
+    public class AssertExtensionTests
+    {
+        public class OneException : Exception { }
+
+        public class TwoException : Exception { }
+
+        public class ThreeException : Exception { }
+
+        public class NotMyException : Exception { }
+
+        [Fact]
+        public void ThrowsAny_Two_ThrowsExpected()
+        {
+            Action throwExpected = () => { throw new OneException(); };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException>(throwExpected);
+            }
+            catch (Exception e)
+            {
+                Assert.False(true, $"Should not have thrown for first, threw {e}");
+            }
+
+            throwExpected = () => { throw new TwoException(); };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException>(throwExpected);
+            }
+            catch (Exception e)
+            {
+                Assert.False(true, $"Should not have thrown for second, threw {e}");
+            }
+        }
+
+        [Fact]
+        public void ThrowsAny_Two_ThrowsUnexpected()
+        {
+            Action throwUnexpected = () => { throw new NotMyException(); };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException>(throwUnexpected);
+            }
+            catch (XunitException e)
+            {
+                Assert.Equal(
+                    "Expected one of: (CoreFx.Private.TestUtilities.Tests.AssertExtensionTests+OneException, CoreFx.Private.TestUtilities.Tests.AssertExtensionTests+TwoException) -> Actual: (CoreFx.Private.TestUtilities.Tests.AssertExtensionTests+NotMyException)",
+                    e.Message);
+                return;
+            }
+
+            Assert.False(true, "Should have thrown");
+        }
+
+        [Fact]
+        public void ThrowsAny_Two_DoesNotThrow()
+        {
+            Action doNothing = () => { };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException>(doNothing);
+            }
+            catch (XunitException e)
+            {
+                Assert.Equal(
+                    "Expected one of: (CoreFx.Private.TestUtilities.Tests.AssertExtensionTests+OneException, CoreFx.Private.TestUtilities.Tests.AssertExtensionTests+TwoException) -> Actual: No exception thrown",
+                    e.Message);
+                return;
+            }
+
+            Assert.False(true, "Should have thrown");
+        }
+
+
+        [Fact]
+        public void ThrowsAny_Three_ThrowsExpected()
+        {
+            Action throwExpected = () => { throw new ThreeException(); };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException, ThreeException>(throwExpected);
+            }
+            catch (Exception e)
+            {
+                Assert.False(true, $"Should not have thrown for first, threw {e}");
+            }
+        }
+
+        [Fact]
+        public void ThrowsAny_Three_ThrowsUnexpected()
+        {
+            Action throwUnexpected = () => { throw new NotMyException(); };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException, ThreeException>(throwUnexpected);
+            }
+            catch (XunitException)
+            {
+                // We're ok
+                return;
+            }
+
+            Assert.False(true, "Should have thrown");
+        }
+
+        [Fact]
+        public void ThrowsAny_Three_DoesNotThrow()
+        {
+            Action doNothing = () => { };
+            try
+            {
+                AssertExtensions.ThrowsAny<OneException, TwoException, ThreeException>(doNothing);
+            }
+            catch (XunitException)
+            {
+                // We're ok
+                return;
+            }
+
+            Assert.False(true, "Should have thrown");
+        }
+    }
+}

src/CoreFx.Private.TestUtilities/tests/CoreFx.Private.TestUtilities.Tests.csproj

@@ -10,6 +10,7 @@
     <RootNamespace>CoreFx.Private.TestUtilities.Tests</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="AssertExtensionTests.cs" />
     <Compile Include="TheoryExtensionTests.cs" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

src/System.IO.FileSystem/tests/File/Move.cs

@@ -206,18 +206,17 @@ public void OverMaxPathWorks_Windows()
         }
 
         [Fact]
-        [PlatformSpecific(TestPlatforms.AnyUnix)]  // Path longer than max Windows path limit throws
+        [PlatformSpecific(TestPlatforms.AnyUnix)]
         public void LongPath()
         {
-            //Create a destination path longer than the traditional Windows limit of 256 characters
             string testFileSource = Path.Combine(TestDirectory, GetTestFileName());
             File.Create(testFileSource).Dispose();
 
             Assert.All(IOInputs.GetPathsLongerThanMaxLongPath(GetTestFilePath()), (path) =>
             {
-                AssertExtensions.ThrowsAny<PathTooLongException, FileNotFoundException>(() => Move(testFileSource, path));
+                AssertExtensions.ThrowsAny<PathTooLongException, FileNotFoundException, DirectoryNotFoundException>(() => Move(testFileSource, path));
                 File.Delete(testFileSource);
-                AssertExtensions.ThrowsAny<PathTooLongException, FileNotFoundException>(() => Move(path, testFileSource));
+                AssertExtensions.ThrowsAny<PathTooLongException, FileNotFoundException, DirectoryNotFoundException>(() => Move(path, testFileSource));
             });
         }
 

src/System.Runtime.Extensions/tests/System/IO/PathTests.cs

@@ -35,13 +35,28 @@ public static void ChangeExtension(string path, string newExtension, string expe
             Assert.Equal(expected, Path.ChangeExtension(path, newExtension));
         }
 
-        [Theory]
-        [InlineData("")]
-        [InlineData(" ")]
-        [InlineData("\r\n")]
-        public static void GetDirectoryName_EmptyOrWhitespace_Throws(string path)
+        [Fact]
+        public static void GetDirectoryName_EmptyThrows()
+        {
+            AssertExtensions.Throws<ArgumentException>("path", null, () => Path.GetDirectoryName(string.Empty));
+        }
+
+        [Theory,
+            InlineData(" "),
+            InlineData("\r\n")]
+        [ActiveIssue(21358)] // Pending CoreCLR behavior change
+        public static void GetDirectoryName_SpaceOrControlCharsThrowOnWindows(string path)
         {
-            AssertExtensions.Throws<ArgumentException>("path", null, () => Path.GetDirectoryName(path));
+            Action action = () => Path.GetDirectoryName(path);
+            if (PlatformDetection.IsWindows)
+            {
+                AssertExtensions.Throws<ArgumentException>("path", null, () => Path.GetDirectoryName(path));
+            }
+            else
+            {
+                // These are valid paths on Unix
+                action();
+            }
         }
 
         [Theory]
@@ -201,12 +216,20 @@ public static void GetFileNameWithoutExtension(string path, string expected)
         }
 
         [Fact]
-        public static void GetPathRoot()
+        public static void GetPathRoot_NullReturnsNull()
         {
             Assert.Null(Path.GetPathRoot(null));
+        }
+
+        [Fact]
+        public static void GetPathRoot_EmptyThrows()
+        {
             AssertExtensions.Throws<ArgumentException>("path", null, () => Path.GetPathRoot(string.Empty));
-            AssertExtensions.Throws<ArgumentException>("path", null, () => Path.GetPathRoot("\r\n"));
+        }
 
+        [Fact]
+        public static void GetPathRoot_Basic()
+        {
             string cwd = Directory.GetCurrentDirectory();
             Assert.Equal(cwd.Substring(0, cwd.IndexOf(Path.DirectorySeparatorChar) + 1), Path.GetPathRoot(cwd));
             Assert.True(Path.IsPathRooted(cwd));

src/System.Runtime/tests/System/IO/PathTooLongExceptionTests.cs

@@ -34,26 +34,5 @@ public static void Ctor_String_Exception()
             var exception = new PathTooLongException(message, innerException);
             ExceptionUtility.ValidateExceptionProperties(exception, hResult: HResults.COR_E_PATHTOOLONG, innerException: innerException, message: message);
         }
-
-        [Fact]
-        public static void OverlyLongPath_ThrowsPathTooLongException()
-        {
-            // This test case ensures that the PathTooLongException defined in System.IO.Primitives is the same that
-            // is thrown by Path.  The S.IO.FS.P implementation forwards to the core assembly to ensure this is true.
-
-            // Build up a path until GetFullPath throws, and verify that the right exception type
-            // emerges from it and related APIs.
-            var builder = new StringBuilder("directoryNameHere" + Path.DirectorySeparatorChar);
-            string path = null;
-            Assert.Throws<PathTooLongException>(new Action(() =>
-            {
-                while (true)
-                {
-                    path = builder.ToString();
-                    Path.GetFullPath(path); // will eventually throw when path is too long
-                builder.Append(path); // double the number of directories for the next time
-            }
-            }));
-        }
     }
 }