Merge pull request #2872 from Sridhar-MS/system-runtime-tests

Add tests for System.Runtime based on mscorlib code coverage data

Author: stephentoub

src/System.Runtime/tests/System.Runtime.Tests.csproj

@@ -67,6 +67,7 @@
     <Compile Include="System\MulticastDelegate.cs" />
     <Compile Include="System\Nullable.cs" />
     <Compile Include="System\Object.cs" />
+    <Compile Include="System\Runtime\CompilerServices\ConditionalWeakTable.cs" />
     <Compile Include="System\Runtime\CompilerServices\StrongBox.cs" />
     <Compile Include="System\Runtime\CompilerServices\RuntimeHelpers.cs" />
     <Compile Include="System\SByte.cs" />
@@ -83,6 +84,7 @@
     <Compile Include="System\UInt32.cs" />
     <Compile Include="System\UInt64.cs" />
     <Compile Include="System\UIntPtr.cs" />
+    <Compile Include="System\Uri.cs" />
     <Compile Include="System\ValueType.cs" />
     <Compile Include="System\Version.cs" />
     <Compile Include="System\WeakReference.cs" />
@@ -98,6 +100,12 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <Targets>Build;DebugSymbolsProjectOutputGroup</Targets>
     </ProjectReference>
+    <ProjectReference Include="..\..\System.Private.Uri\src\System.Private.Uri.CoreCLR.csproj">
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+      <OutputItemType>Content</OutputItemType>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Targets>Build;DebugSymbolsProjectOutputGroup</Targets>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
 </Project>

src/System.Runtime/tests/System/Array.cs

@@ -94,6 +94,7 @@ public static void TestTrivials()
         Assert.Equal(a.Rank, 1);
         IList il = (IList)a;
         Assert.Equal(il.Count, 3);
+        Assert.Equal(il.SyncRoot, a);
         Assert.False(il.IsSynchronized);
         Assert.True(il.IsFixedSize);
         Assert.False(il.IsReadOnly);
@@ -222,78 +223,85 @@ public static void TestTrivials()
         Assert.Throws<RankException>(() => il4.IndexOf(0));
     }
 
-    [Fact]
-    public static void TestBinarySearch()
+    public static IEnumerable<object[]> BinarySearchTestData
     {
-        //@todo: Must pass in a non-null comparer for now (due to incomplete support in underlying Compare class)
-        //
-        IComparer comparer = new IntegerComparer();
-        IComparer<int> icomparer = new IntegerComparer();
-        int idx;
-        int[] ia = { 1, 3, 6, 6, 8, 10, 12, 16 };
-        idx = Array.BinarySearch((Array)ia, 8, comparer);
-        Assert.Equal(idx, 4);
-
-        //Return value semantics: Quoted from MSDN without comment.
-        //
-        //The index of the specified value in the specified array, 
-        //if value is found. If value is not found and value is 
-        //less than one or more elements in array, a negative 
-        //number which is the bitwise complement of the index of 
-        //the first element that is larger than value. 
-        //If value is not found and value is greater than any 
-        //of the elements in array, a negative number which is the bitwise complement of (the index of the last element plus 1).
-        idx = Array.BinarySearch((Array)ia, 99, comparer);
-        Assert.Equal(idx, ~(ia.Length));
-
-        idx = Array.BinarySearch<int>(ia, 0, 8, 99, icomparer);
-        Assert.Equal(idx, ~(ia.Length));
-
-        idx = Array.BinarySearch((Array)ia, 6, comparer);
-        Assert.True(idx == 2 || idx == 3); // Duplicates are allowed but no promises on which one 
+        get
+        {
+            int[] intArray = { 1, 3, 6, 6, 8, 10, 12, 16 };
+            IComparer intComparer = new IntegerComparer();
+            IComparer<int> intGenericComparer = new IntegerComparer();
 
-        idx = Array.BinarySearch<int>(ia, 0, 8, 6, icomparer);
-        Assert.True(idx == 2 || idx == 3); // Duplicates are allowed but no promises on which one 
+            string[] strArray = { null, "aa", "bb", "bb", "cc", "dd", "ee" };
+            IComparer strComparer = new StringComparer();
+            IComparer<string> strGenericComparer = new StringComparer();
 
-        idx = Array.BinarySearch((Array)ia, 6, comparer);
-        Assert.True(idx == 2 || idx == 3); // Duplicates are allowed but no promises on which one 
+            return new[]
+            {
+               new object[] { intArray, 8, intComparer, intGenericComparer, new Func<int, bool>(i => i == 4) },
+               new object[] { intArray, 99, intComparer, intGenericComparer, new Func<int, bool>(i => i == ~(intArray.Length))  },
+               new object[] { intArray, 6, intComparer, intGenericComparer, new Func<int, bool>(i => i == 2 || i == 3)  },
+               new object[] { strArray, "bb", strComparer, strGenericComparer, new Func<int, bool>(i => i == 2 || i == 3)  },
+               new object[] { strArray, null, strComparer, null, new Func<int, bool>(i => i == 0)  },
+           };
+        }
+    }
 
-        idx = Array.BinarySearch<int>(ia, 0, 8, 6, icomparer);
-        Assert.True(idx == 2 || idx == 3); // Duplicates are allowed but no promises on which one
+    [Theory, MemberData("BinarySearchTestData")]
+    public static void TestBinarySearch<T>(T[] array, T value, IComparer comparer, IComparer<T> genericComparer, Func<int, bool> verifier)
+    {
+        int idx = Array.BinarySearch((Array)array, value, comparer);
+        Assert.True(verifier(idx));
 
-        comparer = new StringComparer();
-        IComparer<String> scomparer = new StringComparer();
+        idx = Array.BinarySearch<T>(array, value, genericComparer);
+        Assert.True(verifier(idx));
 
-        String[] sa = { null, "aa", "bb", "bb", "cc", "dd", "ee" };
-        idx = Array.BinarySearch((Array)sa, "bb", comparer);
-        Assert.Equal(idx, 3);
+        idx = Array.BinarySearch((Array)array, value);
+        Assert.True(verifier(idx));
 
-        idx = Array.BinarySearch<String>(sa, 0, sa.Length, "bb", scomparer);
-        Assert.Equal(idx, 3);
-
-        idx = Array.BinarySearch((Array)sa, 3, 4, "bb", comparer);
-        Assert.Equal(idx, 3);
+        idx = Array.BinarySearch<T>(array, value);
+        Assert.True(verifier(idx));
+    }
 
-        idx = Array.BinarySearch<String>(sa, 3, 4, "bb", scomparer);
-        Assert.Equal(idx, 3);
+    public static IEnumerable<object[]> BinarySearchTestDataInRange
+    {
+        get
+        {
+            int[] intArray = { 1, 3, 6, 6, 8, 10, 12, 16 };
+            IComparer intComparer = new IntegerComparer();
+            IComparer<int> intGenericComparer = new IntegerComparer();
 
-        idx = Array.BinarySearch((Array)sa, 4, 3, "bb", comparer);
-        Assert.Equal(idx, -5);
+            string[] strArray = { null, "aa", "bb", "bb", "cc", "dd", "ee" };
+            IComparer strComparer = new StringComparer();
+            IComparer<string> strGenericComparer = new StringComparer();
 
-        idx = Array.BinarySearch<String>(sa, 4, 3, "bb", scomparer);
-        Assert.Equal(idx, -5);
+            return new[]
+            {
+               new object[] { intArray, 0, 8, 99, intComparer, intGenericComparer, new Func<int, bool>(i => i == ~(intArray.Length))  },
+               new object[] { intArray, 0, 8, 6, intComparer, intGenericComparer, new Func<int, bool>(i => i == 2 || i == 3)  },
+               new object[] { intArray, 1, 5, 16, intComparer, intGenericComparer, new Func<int, bool>(i => i == -7)  },
+               new object[] { strArray, 0, strArray.Length, "bb", strComparer, strGenericComparer, new Func<int, bool>(i => i == 2 || i == 3)  },
+               new object[] { strArray, 3, 4, "bb", strComparer, strGenericComparer, new Func<int, bool>(i => i == 3)  },
+               new object[] { strArray, 4, 3, "bb", strComparer, strGenericComparer, new Func<int, bool>(i => i == -5)  },
+               new object[] { strArray, 4, 0, "bb", strComparer, strGenericComparer, new Func<int, bool>(i => i == -5)  },
+               new object[] { strArray, 0, 7, null, strComparer, null, new Func<int, bool>(i => i == 0)  },
+           };
+        }
+    }
 
-        idx = Array.BinarySearch((Array)sa, 4, 0, "bb", comparer);
-        Assert.Equal(idx, -5);
+    [Theory, MemberData("BinarySearchTestDataInRange")]
+    public static void TestBinarySearchInRange<T>(T[] array, int index, int length, T value, IComparer comparer, IComparer<T> genericComparer, Func<int, bool> verifier)
+    {
+        int idx = Array.BinarySearch((Array)array, index, length, value, comparer);
+        Assert.True(verifier(idx));
 
-        idx = Array.BinarySearch<String>(sa, 4, 0, "bb", scomparer);
-        Assert.Equal(idx, -5);
+        idx = Array.BinarySearch<T>(array, index, length, value, genericComparer);
+        Assert.True(verifier(idx));
 
-        idx = Array.BinarySearch((Array)sa, 0, 7, null, comparer);
-        Assert.Equal(idx, 0);
+        idx = Array.BinarySearch((Array)array, index, length, value);
+        Assert.True(verifier(idx));
 
-        idx = Array.BinarySearch<String>(sa, 0, 7, null, scomparer);
-        Assert.Equal(idx, 0);
+        idx = Array.BinarySearch<T>(array, index, length, value);
+        Assert.True(verifier(idx));
     }
 
     [Fact]

src/System.Runtime/tests/System/Buffer.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using Xunit;
 
 public static unsafe class BufferTests
@@ -69,16 +71,46 @@ public static void TestBlockCopy()
         }
     }
 
-    [Fact]
-    public static void TestByteLength()
+    public static IEnumerable<object[]> ByteLengthTestData
     {
-        int i;
-
-        i = Buffer.ByteLength(new int[7]);
-        Assert.Equal(i, 7 * sizeof(int));
+        get
+        {
+           return new[]
+           {
+               new object[] {typeof(byte), sizeof(byte) },
+               new object[] {typeof(sbyte), sizeof(sbyte) },
+               new object[] {typeof(short), sizeof(short) },
+               new object[] {typeof(ushort), sizeof(ushort) },
+               new object[] {typeof(int), sizeof(int) },
+               new object[] {typeof(uint), sizeof(uint) },
+               new object[] {typeof(long), sizeof(long) },
+               new object[] {typeof(ulong), sizeof(ulong) },
+               new object[] {typeof(IntPtr), sizeof(IntPtr) },
+               new object[] {typeof(UIntPtr), sizeof(UIntPtr) },
+               new object[] {typeof(double), sizeof(double) },
+               new object[] {typeof(float), sizeof(float) },
+               new object[] {typeof(bool), sizeof(bool) },
+               new object[] {typeof(char), sizeof(char) },
+               new object[] {typeof(decimal), sizeof(decimal) },
+               new object[] {typeof(DateTime), sizeof(DateTime) },
+               new object[] {typeof(string), -1 },
+           };
+        }
+    }
 
-        i = Buffer.ByteLength(new double[33]);
-        Assert.Equal(i, 33 * sizeof(double));
+    [Theory, MemberData("ByteLengthTestData")]
+    public static void TestByteLength(Type type, int size)
+    {
+        const int length = 25;
+        Array array = Array.CreateInstance(type, length);
+        if (type.GetTypeInfo().IsPrimitive)
+        {
+            Assert.Equal(length * size, Buffer.ByteLength(array));
+        }
+        else
+        {
+            Assert.Throws<ArgumentException>(() => Buffer.ByteLength(array));
+        }
     }
 
     [Fact]

src/System.Runtime/tests/System/DateTime.cs

@@ -2,7 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 public static unsafe class DateTimeTests
@@ -291,6 +294,46 @@ public static void TestTryParseExactA()
         Assert.Equal(s, actual);
     }
 
+    [Fact]
+    public static void TestGetDateTimeFormats()
+    {        
+        char[] allStandardFormats =
+        {
+            'd', 'D', 'f', 'F', 'g', 'G',
+            'm', 'M', 'o', 'O', 'r', 'R',
+            's', 't', 'T', 'u', 'U', 'y', 'Y',
+        };
+
+        DateTime july28 = new DateTime(2009, 7, 28, 5, 23, 15);
+        List<string> july28Formats = new List<string>();
+
+        foreach (char format in allStandardFormats)
+        {
+            string[] dates = july28.GetDateTimeFormats(format);
+
+            Assert.True(dates.Length > 0);
+
+            DateTime parsedDate;
+            Assert.True(DateTime.TryParseExact(dates[0], format.ToString(), CultureInfo.CurrentCulture, DateTimeStyles.None, out parsedDate));
+
+            july28Formats.AddRange(dates);
+        }
+
+        List<string> actualJuly28Formats = july28.GetDateTimeFormats().ToList();
+        Assert.Equal(july28Formats.OrderBy(t => t), actualJuly28Formats.OrderBy(t => t));
+
+        actualJuly28Formats = july28.GetDateTimeFormats(CultureInfo.CurrentCulture).ToList();
+        Assert.Equal(july28Formats.OrderBy(t => t), actualJuly28Formats.OrderBy(t => t));
+    }
+
+    [Fact]
+    public static void TestGetDateTimeFormats_FormatSpecifier_InvalidFormat()
+    {
+        DateTime july28 = new DateTime(2009, 7, 28, 5, 23, 15);
+
+        Assert.Throws<FormatException>(() => july28.GetDateTimeFormats('x'));
+    }
+
     internal static void ValidateYearMonthDay(DateTime dt, int year, int month, int day)
     {
         Assert.Equal(dt.Year, year);

src/System.Runtime/tests/System/Decimal.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using Xunit;
 
@@ -751,10 +752,41 @@ public static void TestToInt32()
         Assert.Equal(Int32.MinValue, Decimal.ToInt32((Decimal)Int32.MinValue));
     }
 
-    [Fact]
-    public static void TestGetBits()
+    public static IEnumerable<object[]> DecimalTestData
     {
-        // Int32[] Decimal.GetBits(Decimal)
+        get
+        {
+            return new[]
+            {
+                new object[] {1M, new int[] { 0x00000001, 0x00000000, 0x00000000, 0x00000000 } },
+                new object[] {100000000000000M, new int[] { 0x107A4000, 0x00005AF3, 0x00000000, 0x00000000 } },
+                new object[] {100000000000000.00000000000000M, new int[] { 0x10000000, 0x3E250261, 0x204FCE5E, 0x000E0000 } },
+                new object[] {1.0000000000000000000000000000M, new int[] { 0x10000000, 0x3E250261, 0x204FCE5E, 0x001C0000 } },
+                new object[] {123456789M, new int[] { 0x075BCD15, 0x00000000, 0x00000000, 0x00000000 } },
+                new object[] {0.123456789M, new int[] { 0x075BCD15, 0x00000000, 0x00000000, 0x00090000 } },
+                new object[] {0.000000000123456789M, new int[] { 0x075BCD15, 0x00000000, 0x00000000, 0x00120000 } },
+                new object[] {0.000000000000000000123456789M, new int[] { 0x075BCD15, 0x00000000, 0x00000000, 0x001B0000 } },
+                new object[] {4294967295M, new int[] { unchecked((int)0xFFFFFFFF), 0x00000000, 0x00000000, 0x00000000 } },
+                new object[] {18446744073709551615M, new int[] { unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), 0x00000000, 0x00000000 } },
+                new object[] {Decimal.MaxValue, new int[] { unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), 0x00000000 } },
+                new object[] {Decimal.MinValue, new int[] { unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), unchecked((int)0x80000000) } },
+                new object[] {-7.9228162514264337593543950335M, new int[] { unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), unchecked((int)0xFFFFFFFF), unchecked((int)0x801C0000) } }
+            };
+        }
+    }
+
+    [Theory, MemberData("DecimalTestData")]
+    public static void TestGetBits(Decimal input, int[] expectedBits)
+    {
+        int[] actualsBits = Decimal.GetBits(input);
+
+        Assert.Equal(expectedBits, actualsBits);
+
+        bool sign = (actualsBits[3] & 0x80000000) != 0;
+        byte scale = (byte)((actualsBits[3] >> 16) & 0x7F);
+        Decimal newValue = new Decimal(actualsBits[0], actualsBits[1], actualsBits[2], sign, scale);
+
+        Assert.Equal(input, newValue);
     }
 
     [Fact]