From f52d0e5546c8c78965d9d5a4f5d978eb5b5da2de Mon Sep 17 00:00:00 2001 From: Santiago Fernandez Madero Date: Thu, 16 Jul 2020 13:46:03 -0700 Subject: [PATCH 1/2] WASM: enable System.Runtime.Tests (#39344) * WASM: fix System.Runtime.Tests * Enable System.Runtime.Tests * Disable test and don't strip link attributes on all product assemblies * PR feedback --- eng/illink.targets | 2 +- .../Common/tests/Tests/System/StringTests.cs | 648 ++++++++++-------- .../tests/System/ActivatorTests.cs | 4 +- .../tests/System/ArgIteratorTests.cs | 1 + .../System.Runtime/tests/System/CharTests.cs | 40 +- .../tests/System/DateTimeOffsetTests.cs | 13 +- .../tests/System/DateTimeTests.cs | 58 +- .../System/Reflection/InvokeRefReturn.cs | 1 + .../ExceptionDispatchInfoTests.cs | 1 + .../tests/System/StringTests.cs | 239 ++++--- .../tests/System/TimeSpanTests.cs | 74 +- .../tests/System/TimeZoneInfoTests.cs | 1 + .../System.Runtime/tests/System/TupleTests.cs | 2 +- .../tests/System/Uri.CreateStringTests.cs | 9 +- src/libraries/tests.proj | 1 - 15 files changed, 621 insertions(+), 473 deletions(-) diff --git a/eng/illink.targets b/eng/illink.targets index f255f7f2df812..601b0b798fbca 100644 --- a/eng/illink.targets +++ b/eng/illink.targets @@ -209,7 +209,7 @@ $(ILLinkArgs) --strip-substitutions false - $(ILLinkArgs) --strip-link-attributes false --ignore-link-attributes true + $(ILLinkArgs) --strip-link-attributes false --ignore-link-attributes true $(ILLinkArgs) --skip-unresolved true diff --git a/src/libraries/Common/tests/Tests/System/StringTests.cs b/src/libraries/Common/tests/Tests/System/StringTests.cs index 547e4fd249c06..74ceefc4cc6a4 100644 --- a/src/libraries/Common/tests/Tests/System/StringTests.cs +++ b/src/libraries/Common/tests/Tests/System/StringTests.cs @@ -482,144 +482,149 @@ public static void CopyTo_Invalid() AssertExtensions.Throws("sourceIndex", () => s.CopyTo(0, dst, 0, 6)); } + public static IEnumerable Compare_TestData() + { + // CurrentCulture + yield return new object[] { "", 0, "", 0, 0, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.CurrentCulture, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.CurrentCulture, -1 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.CurrentCulture, PlatformDetection.IsInvariantGlobalization ? -1 : 1 }; + yield return new object[] { "hello", 2, "HELLO", 2, 3, StringComparison.CurrentCulture, PlatformDetection.IsInvariantGlobalization ? 1 : -1 }; + yield return new object[] { "Hello", 2, "Hello", 2, 3, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "Hello", 2, "Goodbye", 2, 3, StringComparison.CurrentCulture, -1 }; + yield return new object[] { "A", 0, "B", 0, 1, StringComparison.CurrentCulture, -1 }; + yield return new object[] { "B", 0, "A", 0, 1, StringComparison.CurrentCulture, 1 }; + yield return new object[] { null, 0, null, 0, 0, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "Hello", 0, null, 0, 0, StringComparison.CurrentCulture, 1 }; + yield return new object[] { null, 0, "Hello", 0, 0, StringComparison.CurrentCulture, -1 }; + yield return new object[] { null, -1, null, -1, -1, StringComparison.CurrentCulture, 0 }; + yield return new object[] { "foo", -1, null, -1, -1, StringComparison.CurrentCulture, 1 }; + yield return new object[] { null, -1, "foo", -1, -1, StringComparison.CurrentCulture, -1 }; + // CurrentCultureIgnoreCase + yield return new object[] { "", 0, "", 0, 0, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "HELLO", 0, "hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Yellow", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.CurrentCultureIgnoreCase, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, -1 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Goodbye", 2, 3, StringComparison.CurrentCultureIgnoreCase, -1 }; + yield return new object[] { null, 0, null, 0, 0, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, null, 0, 0, StringComparison.CurrentCultureIgnoreCase, 1 }; + yield return new object[] { null, 0, "Hello", 0, 0, StringComparison.CurrentCultureIgnoreCase, -1 }; + yield return new object[] { null, -1, null, -1, -1, StringComparison.CurrentCultureIgnoreCase, 0 }; + yield return new object[] { "foo", -1, null, -1, -1, StringComparison.CurrentCultureIgnoreCase, 1 }; + yield return new object[] { null, -1, "foo", -1, -1, StringComparison.CurrentCultureIgnoreCase, -1 }; + // InvariantCulture + yield return new object[] { "", 0, "", 0, 0, StringComparison.InvariantCulture, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.InvariantCulture, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.InvariantCulture, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.InvariantCulture, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.InvariantCulture, -1 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.InvariantCulture, PlatformDetection.IsInvariantGlobalization ? -1 : 1 }; + yield return new object[] { "hello", 2, "HELLO", 2, 3, StringComparison.InvariantCulture, PlatformDetection.IsInvariantGlobalization ? 1 : -1 }; + yield return new object[] { null, 0, null, 0, 0, StringComparison.InvariantCulture, 0 }; + yield return new object[] { "Hello", 0, null, 0, 5, StringComparison.InvariantCulture, 1 }; + yield return new object[] { null, 0, "Hello", 0, 5, StringComparison.InvariantCulture, -1 }; + // InvariantCultureIgnoreCase + yield return new object[] { "", 0, "", 0, 0, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "HELLO", 0, "hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Yellow", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.InvariantCultureIgnoreCase, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, -1 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Goodbye", 2, 3, StringComparison.InvariantCultureIgnoreCase, -1 }; + yield return new object[] { null, 0, null, 0, 0, StringComparison.InvariantCultureIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, null, 0, 5, StringComparison.InvariantCultureIgnoreCase, 1 }; + yield return new object[] { null, 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, -1 }; + // Ordinal + yield return new object[] { "", 0, "", 0, 0, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.Ordinal, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.Ordinal, -1 }; + yield return new object[] { "Hello", 2, "Hello", 2, 3, StringComparison.Ordinal, 0 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.Ordinal, -1 }; + yield return new object[] { "Hello", 2, "Goodbye", 2, 3, StringComparison.Ordinal, -1 }; + yield return new object[] { "Hello", 0, "Hello", 0, 0, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 3, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 0, "He" + SoftHyphen + "llo", 0, 5, StringComparison.Ordinal, -1 }; + yield return new object[] { "Hello", 0, "-==-", 3, 5, StringComparison.Ordinal, 0 }; + yield return new object[] { "\uD83D\uDD53Hello\uD83D\uDD50", 1, "\uD83D\uDD53Hello\uD83D\uDD54", 1, 7, StringComparison.Ordinal, 0 }; // Surrogate split + yield return new object[] { "Hello", 0, "Hello123", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // Recalculated length, second string longer + yield return new object[] { "Hello123", 0, "Hello", 0, int.MaxValue, StringComparison.Ordinal, 1 }; // Recalculated length, first string longer + yield return new object[] { "---aaaaaaaaaaa", 3, "+++aaaaaaaaaaa", 3, 100, StringComparison.Ordinal, 0 }; // Equal long alignment 2, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 3, "aaaxaaaaaaaaaa", 3, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 2, different compare at n=1 + yield return new object[] { "-aaaaaaaaaaaaa", 1, "+aaaaaaaaaaaaa", 1, 100, StringComparison.Ordinal, 0 }; // Equal long alignment 6, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 1, "axaaaaaaaaaaaa", 1, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 6, different compare at n=1 + yield return new object[] { "aaaaaaaaaaaaaa", 0, "aaaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, 0 }; // Equal long alignment 4, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 0, "xaaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 4, different compare at n=1 + yield return new object[] { "aaaaaaaaaaaaaa", 0, "axaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 4, different compare at n=2 + yield return new object[] { "--aaaaaaaaaaaa", 2, "++aaaaaaaaaaaa", 2, 100, StringComparison.Ordinal, 0 }; // Equal long alignment 0, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 2, "aaxaaaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 0, different compare at n=1 + yield return new object[] { "aaaaaaaaaaaaaa", 2, "aaaxaaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 0, different compare at n=2 + yield return new object[] { "aaaaaaaaaaaaaa", 2, "aaaaxaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 0, different compare at n=3 + yield return new object[] { "aaaaaaaaaaaaaa", 2, "aaaaaxaaaaaaaa", 2, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 0, different compare at n=4 + yield return new object[] { "aaaaaaaaaaaaaa", 2, "aaaaaaxaaaaaaa", 2, 100, StringComparison.Ordinal, -1 }; // Equal long alignment 0, different compare at n=5 + yield return new object[] { "aaaaaaaaaaaaaa", 0, "+aaaaaaaaaaaaa", 1, 13, StringComparison.Ordinal, 0 }; // Different int alignment, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 0, "aaaaaaaaaaaaax", 1, 100, StringComparison.Ordinal, -1 }; // Different int alignment + yield return new object[] { "aaaaaaaaaaaaaa", 1, "aaaxaaaaaaaaaa", 3, 100, StringComparison.Ordinal, -1 }; // Different long alignment, abs of 4, one of them is 2, different at n=1 + yield return new object[] { "-aaaaaaaaaaaaa", 1, "++++aaaaaaaaaa", 4, 10, StringComparison.Ordinal, 0 }; // Different long alignment, equal compare + yield return new object[] { "aaaaaaaaaaaaaa", 1, "aaaaaaaaaaaaax", 4, 100, StringComparison.Ordinal, -1 }; // Different long alignment + yield return new object[] { "\0", 0, "", 0, 1, StringComparison.Ordinal, 1 }; // Same memory layout, except for m_stringLength (m_firstChars are both 0) + yield return new object[] { "\0\0", 0, "", 0, 2, StringComparison.Ordinal, 1 }; // Same as above, except m_stringLength for one is 2 + yield return new object[] { "", 0, "\0b", 0, 2, StringComparison.Ordinal, -1 }; // strA's second char != strB's second char codepath + yield return new object[] { "", 0, "b", 0, 1, StringComparison.Ordinal, -1 }; // Should hit strA.m_firstChar != strB.m_firstChar codepath + yield return new object[] { "abcxxxxxxxxxxxxxxxxxxxxxx", 0, "abdxxxxxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // 64-bit: first long compare is different + yield return new object[] { "abcdefgxxxxxxxxxxxxxxxxxx", 0, "abcdefhxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // 64-bit: second long compare is different + yield return new object[] { "abcdefghijkxxxxxxxxxxxxxx", 0, "abcdefghijlxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // 64-bit: third long compare is different + yield return new object[] { "abcdexxxxxxxxxxxxxxxxxxxx", 0, "abcdfxxxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // 32-bit: second int compare is different + yield return new object[] { "abcdefghixxxxxxxxxxxxxxxx", 0, "abcdefghjxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1 }; // 32-bit: fourth int compare is different + yield return new object[] { null, 0, null, 0, 0, StringComparison.Ordinal, 0 }; + yield return new object[] { "Hello", 0, null, 0, 5, StringComparison.Ordinal, 1 }; + yield return new object[] { null, 0, "Hello", 0, 5, StringComparison.Ordinal, -1 }; + yield return new object[] { null, -1, null, -1, -1, StringComparison.Ordinal, 0 }; + yield return new object[] { "foo", -1, null, -1, -1, StringComparison.Ordinal, 1 }; + yield return new object[] { null, -1, "foo", -1, -1, StringComparison.Ordinal, -1 }; + // OrdinalIgnoreCase + yield return new object[] { "", 0, "", 0, 0, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "HELLO", 0, "hello", 0, 5, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 3, 1, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Hello", 2, 3, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Yellow", 2, 3, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, "Goodbye", 0, 5, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "Goodbye", 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, -1 }; + yield return new object[] { "HELLO", 2, "hello", 2, 3, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 2, "Goodbye", 2, 3, StringComparison.OrdinalIgnoreCase, -1 }; + yield return new object[] { "A", 0, "x", 0, 1, StringComparison.OrdinalIgnoreCase, -1 }; + yield return new object[] { "a", 0, "X", 0, 1, StringComparison.OrdinalIgnoreCase, -1 }; + yield return new object[] { "[", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "[", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "\\", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "\\", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "]", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "]", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "^", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "^", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "_", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "_", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "`", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { "`", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { null, 0, null, 0, 0, StringComparison.OrdinalIgnoreCase, 0 }; + yield return new object[] { "Hello", 0, null, 0, 5, StringComparison.OrdinalIgnoreCase, 1 }; + yield return new object[] { null, 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, -1 }; + } + [Theory] - // CurrentCulture - [InlineData("", 0, "", 0, 0, StringComparison.CurrentCulture, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.CurrentCulture, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.CurrentCulture, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.CurrentCulture, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.CurrentCulture, -1)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.CurrentCulture, 1)] - [InlineData("hello", 2, "HELLO", 2, 3, StringComparison.CurrentCulture, -1)] - [InlineData("Hello", 2, "Hello", 2, 3, StringComparison.CurrentCulture, 0)] - [InlineData("Hello", 2, "Goodbye", 2, 3, StringComparison.CurrentCulture, -1)] - [InlineData("A", 0, "B", 0, 1, StringComparison.CurrentCulture, -1)] - [InlineData("B", 0, "A", 0, 1, StringComparison.CurrentCulture, 1)] - [InlineData(null, 0, null, 0, 0, StringComparison.CurrentCulture, 0)] - [InlineData("Hello", 0, null, 0, 0, StringComparison.CurrentCulture, 1)] - [InlineData(null, 0, "Hello", 0, 0, StringComparison.CurrentCulture, -1)] - [InlineData(null, -1, null, -1, -1, StringComparison.CurrentCulture, 0)] - [InlineData("foo", -1, null, -1, -1, StringComparison.CurrentCulture, 1)] - [InlineData(null, -1, "foo", -1, -1, StringComparison.CurrentCulture, -1)] - // CurrentCultureIgnoreCase - [InlineData("", 0, "", 0, 0, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("HELLO", 0, "hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Yellow", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.CurrentCultureIgnoreCase, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.CurrentCultureIgnoreCase, -1)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Goodbye", 2, 3, StringComparison.CurrentCultureIgnoreCase, -1)] - [InlineData(null, 0, null, 0, 0, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("Hello", 0, null, 0, 0, StringComparison.CurrentCultureIgnoreCase, 1)] - [InlineData(null, 0, "Hello", 0, 0, StringComparison.CurrentCultureIgnoreCase, -1)] - [InlineData(null, -1, null, -1, -1, StringComparison.CurrentCultureIgnoreCase, 0)] - [InlineData("foo", -1, null, -1, -1, StringComparison.CurrentCultureIgnoreCase, 1)] - [InlineData(null, -1, "foo", -1, -1, StringComparison.CurrentCultureIgnoreCase, -1)] - // InvariantCulture - [InlineData("", 0, "", 0, 0, StringComparison.InvariantCulture, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.InvariantCulture, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.InvariantCulture, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.InvariantCulture, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.InvariantCulture, -1)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.InvariantCulture, 1)] - [InlineData("hello", 2, "HELLO", 2, 3, StringComparison.InvariantCulture, -1)] - [InlineData(null, 0, null, 0, 0, StringComparison.InvariantCulture, 0)] - [InlineData("Hello", 0, null, 0, 5, StringComparison.InvariantCulture, 1)] - [InlineData(null, 0, "Hello", 0, 5, StringComparison.InvariantCulture, -1)] - // InvariantCultureIgnoreCase - [InlineData("", 0, "", 0, 0, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("HELLO", 0, "hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Yellow", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.InvariantCultureIgnoreCase, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, -1)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 2, "Goodbye", 2, 3, StringComparison.InvariantCultureIgnoreCase, -1)] - [InlineData(null, 0, null, 0, 0, StringComparison.InvariantCultureIgnoreCase, 0)] - [InlineData("Hello", 0, null, 0, 5, StringComparison.InvariantCultureIgnoreCase, 1)] - [InlineData(null, 0, "Hello", 0, 5, StringComparison.InvariantCultureIgnoreCase, -1)] - // Ordinal - [InlineData("", 0, "", 0, 0, StringComparison.Ordinal, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.Ordinal, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.Ordinal, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.Ordinal, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.Ordinal, -1)] - [InlineData("Hello", 2, "Hello", 2, 3, StringComparison.Ordinal, 0)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.Ordinal, -1)] - [InlineData("Hello", 2, "Goodbye", 2, 3, StringComparison.Ordinal, -1)] - [InlineData("Hello", 0, "Hello", 0, 0, StringComparison.Ordinal, 0)] - [InlineData("Hello", 0, "Hello", 0, 3, StringComparison.Ordinal, 0)] - [InlineData("Hello", 0, "He" + SoftHyphen + "llo", 0, 5, StringComparison.Ordinal, -1)] - [InlineData("Hello", 0, "-==-", 3, 5, StringComparison.Ordinal, 0)] - [InlineData("\uD83D\uDD53Hello\uD83D\uDD50", 1, "\uD83D\uDD53Hello\uD83D\uDD54", 1, 7, StringComparison.Ordinal, 0)] // Surrogate split - [InlineData("Hello", 0, "Hello123", 0, int.MaxValue, StringComparison.Ordinal, -1)] // Recalculated length, second string longer - [InlineData("Hello123", 0, "Hello", 0, int.MaxValue, StringComparison.Ordinal, 1)] // Recalculated length, first string longer - [InlineData("---aaaaaaaaaaa", 3, "+++aaaaaaaaaaa", 3, 100, StringComparison.Ordinal, 0)] // Equal long alignment 2, equal compare - [InlineData("aaaaaaaaaaaaaa", 3, "aaaxaaaaaaaaaa", 3, 100, StringComparison.Ordinal, -1)] // Equal long alignment 2, different compare at n=1 - [InlineData("-aaaaaaaaaaaaa", 1, "+aaaaaaaaaaaaa", 1, 100, StringComparison.Ordinal, 0)] // Equal long alignment 6, equal compare - [InlineData("aaaaaaaaaaaaaa", 1, "axaaaaaaaaaaaa", 1, 100, StringComparison.Ordinal, -1)] // Equal long alignment 6, different compare at n=1 - [InlineData("aaaaaaaaaaaaaa", 0, "aaaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, 0)] // Equal long alignment 4, equal compare - [InlineData("aaaaaaaaaaaaaa", 0, "xaaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, -1)] // Equal long alignment 4, different compare at n=1 - [InlineData("aaaaaaaaaaaaaa", 0, "axaaaaaaaaaaaa", 0, 100, StringComparison.Ordinal, -1)] // Equal long alignment 4, different compare at n=2 - [InlineData("--aaaaaaaaaaaa", 2, "++aaaaaaaaaaaa", 2, 100, StringComparison.Ordinal, 0)] // Equal long alignment 0, equal compare - [InlineData("aaaaaaaaaaaaaa", 2, "aaxaaaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1)] // Equal long alignment 0, different compare at n=1 - [InlineData("aaaaaaaaaaaaaa", 2, "aaaxaaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1)] // Equal long alignment 0, different compare at n=2 - [InlineData("aaaaaaaaaaaaaa", 2, "aaaaxaaaaaaaaa", 2, 100, StringComparison.Ordinal, -1)] // Equal long alignment 0, different compare at n=3 - [InlineData("aaaaaaaaaaaaaa", 2, "aaaaaxaaaaaaaa", 2, 100, StringComparison.Ordinal, -1)] // Equal long alignment 0, different compare at n=4 - [InlineData("aaaaaaaaaaaaaa", 2, "aaaaaaxaaaaaaa", 2, 100, StringComparison.Ordinal, -1)] // Equal long alignment 0, different compare at n=5 - [InlineData("aaaaaaaaaaaaaa", 0, "+aaaaaaaaaaaaa", 1, 13, StringComparison.Ordinal, 0)] // Different int alignment, equal compare - [InlineData("aaaaaaaaaaaaaa", 0, "aaaaaaaaaaaaax", 1, 100, StringComparison.Ordinal, -1)] // Different int alignment - [InlineData("aaaaaaaaaaaaaa", 1, "aaaxaaaaaaaaaa", 3, 100, StringComparison.Ordinal, -1)] // Different long alignment, abs of 4, one of them is 2, different at n=1 - [InlineData("-aaaaaaaaaaaaa", 1, "++++aaaaaaaaaa", 4, 10, StringComparison.Ordinal, 0)] // Different long alignment, equal compare - [InlineData("aaaaaaaaaaaaaa", 1, "aaaaaaaaaaaaax", 4, 100, StringComparison.Ordinal, -1)] // Different long alignment - [InlineData("\0", 0, "", 0, 1, StringComparison.Ordinal, 1)] // Same memory layout, except for m_stringLength (m_firstChars are both 0) - [InlineData("\0\0", 0, "", 0, 2, StringComparison.Ordinal, 1)] // Same as above, except m_stringLength for one is 2 - [InlineData("", 0, "\0b", 0, 2, StringComparison.Ordinal, -1)] // strA's second char != strB's second char codepath - [InlineData("", 0, "b", 0, 1, StringComparison.Ordinal, -1)] // Should hit strA.m_firstChar != strB.m_firstChar codepath - [InlineData("abcxxxxxxxxxxxxxxxxxxxxxx", 0, "abdxxxxxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1)] // 64-bit: first long compare is different - [InlineData("abcdefgxxxxxxxxxxxxxxxxxx", 0, "abcdefhxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1)] // 64-bit: second long compare is different - [InlineData("abcdefghijkxxxxxxxxxxxxxx", 0, "abcdefghijlxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1)] // 64-bit: third long compare is different - [InlineData("abcdexxxxxxxxxxxxxxxxxxxx", 0, "abcdfxxxxxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1)] // 32-bit: second int compare is different - [InlineData("abcdefghixxxxxxxxxxxxxxxx", 0, "abcdefghjxxxxxxxxx", 0, int.MaxValue, StringComparison.Ordinal, -1)] // 32-bit: fourth int compare is different - [InlineData(null, 0, null, 0, 0, StringComparison.Ordinal, 0)] - [InlineData("Hello", 0, null, 0, 5, StringComparison.Ordinal, 1)] - [InlineData(null, 0, "Hello", 0, 5, StringComparison.Ordinal, -1)] - [InlineData(null, -1, null, -1, -1, StringComparison.Ordinal, 0)] - [InlineData("foo", -1, null, -1, -1, StringComparison.Ordinal, 1)] - [InlineData(null, -1, "foo", -1, -1, StringComparison.Ordinal, -1)] - // OrdinalIgnoreCase - [InlineData("", 0, "", 0, 0, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("HELLO", 0, "hello", 0, 5, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 3, 1, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 2, "Hello", 2, 3, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 2, "Yellow", 2, 3, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 0, "Goodbye", 0, 5, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("Goodbye", 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, -1)] - [InlineData("HELLO", 2, "hello", 2, 3, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 2, "Goodbye", 2, 3, StringComparison.OrdinalIgnoreCase, -1)] - [InlineData("A", 0, "x", 0, 1, StringComparison.OrdinalIgnoreCase, -1)] - [InlineData("a", 0, "X", 0, 1, StringComparison.OrdinalIgnoreCase, -1)] - [InlineData("[", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("[", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("\\", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("\\", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("]", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("]", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("^", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("^", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("_", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("_", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("`", 0, "A", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData("`", 0, "a", 0, 1, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData(null, 0, null, 0, 0, StringComparison.OrdinalIgnoreCase, 0)] - [InlineData("Hello", 0, null, 0, 5, StringComparison.OrdinalIgnoreCase, 1)] - [InlineData(null, 0, "Hello", 0, 5, StringComparison.OrdinalIgnoreCase, -1)] + [MemberData(nameof(Compare_TestData))] public static void Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType, int expected) { bool hasNullInputs = (strA == null || strB == null); @@ -1606,66 +1611,84 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange_Char() } } + public static IEnumerable EndsWith_StringComparison_TestData() + { + // CurrentCulture + yield return new object[] { "", "Foo", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "llo", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "Hello", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "HELLO", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "Abc", StringComparison.CurrentCulture, false }; + yield return new object[] { "", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "", "a", StringComparison.CurrentCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.CurrentCulture, true }; + + // CurrentCultureIgnoreCase + yield return new object[] { "Hello", "llo", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "LLO", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.CurrentCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "", "a", StringComparison.CurrentCultureIgnoreCase, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true }; + + // InvariantCulture + yield return new object[] { "", "Foo", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "llo", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "Hello", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "HELLO", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "Abc", StringComparison.InvariantCulture, false }; + yield return new object[] { "", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "", "a", StringComparison.InvariantCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.InvariantCulture, true }; + + // InvariantCultureIgnoreCase + yield return new object[] { "Hello", "llo", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "LLO", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.InvariantCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "", "a", StringComparison.InvariantCultureIgnoreCase, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true }; + + // Ordinal + yield return new object[] { "Hello", "o", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "llo", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "Hello", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "LLO", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "Abc", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.Ordinal, false }; + yield return new object[] { "", "", StringComparison.Ordinal, true }; + yield return new object[] { "", "a", StringComparison.Ordinal, false }; + + // OrdinalIgnoreCase + yield return new object[] { "Hello", "llo", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "LLO", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "llo" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "", "a", StringComparison.OrdinalIgnoreCase, false }; + } + [Theory] - // CurrentCulture - [InlineData("", "Foo", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "llo", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "Hello", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "HELLO", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "Abc", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.CurrentCulture, true)] - [InlineData("", "", StringComparison.CurrentCulture, true)] - [InlineData("", "a", StringComparison.CurrentCulture, false)] - // CurrentCultureIgnoreCase - [InlineData("Hello", "llo", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "LLO", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.CurrentCultureIgnoreCase, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("", "a", StringComparison.CurrentCultureIgnoreCase, false)] - // InvariantCulture - [InlineData("", "Foo", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "llo", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "Hello", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "HELLO", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "Abc", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.InvariantCulture, true)] - [InlineData("", "", StringComparison.InvariantCulture, true)] - [InlineData("", "a", StringComparison.InvariantCulture, false)] - // InvariantCultureIgnoreCase - [InlineData("Hello", "llo", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "LLO", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.InvariantCultureIgnoreCase, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("", "a", StringComparison.InvariantCultureIgnoreCase, false)] - // Ordinal - [InlineData("Hello", "o", StringComparison.Ordinal, true)] - [InlineData("Hello", "llo", StringComparison.Ordinal, true)] - [InlineData("Hello", "Hello", StringComparison.Ordinal, true)] - [InlineData("Hello", "Larger Hello", StringComparison.Ordinal, false)] - [InlineData("Hello", "", StringComparison.Ordinal, true)] - [InlineData("Hello", "LLO", StringComparison.Ordinal, false)] - [InlineData("Hello", "Abc", StringComparison.Ordinal, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.Ordinal, false)] - [InlineData("", "", StringComparison.Ordinal, true)] - [InlineData("", "a", StringComparison.Ordinal, false)] - // OrdinalIgnoreCase - [InlineData("Hello", "llo", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Larger Hello", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "LLO", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "llo" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false)] - [InlineData("", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("", "a", StringComparison.OrdinalIgnoreCase, false)] + [MemberData(nameof(EndsWith_StringComparison_TestData))] public static void EndsWith_StringComparison(string s, string value, StringComparison comparisonType, bool expected) { if (comparisonType == StringComparison.CurrentCulture) @@ -2155,7 +2178,7 @@ public static void EndsWithUnknownComparisonType_StringComparison() Assert.Throws(() => value.AsSpan().CompareTo(value.AsSpan(), (StringComparison)6)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void EndsWithMatchNonOrdinal_StringComparison() { string s = "dabc"; @@ -2859,7 +2882,7 @@ public static void IndexOf_AllSubstrings(string s, string value, int startIndex, Assert.Equal(ignoringCase ? startIndex : -1, s.AsSpan().IndexOf(value.AsSpan(), comparison)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_TurkishI_TurkishCulture() { using (new ThreadCultureChange("tr-TR")) @@ -2942,7 +2965,7 @@ public static void IndexOf_TurkishI_EnglishUSCulture() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_HungarianDoubleCompression_HungarianCulture() { using (new ThreadCultureChange("hu-HU")) @@ -2992,7 +3015,7 @@ public static void IndexOf_HungarianDoubleCompression_InvariantCulture() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_EquivalentDiacritics_EnglishUSCulture() { using (new ThreadCultureChange("en-US")) @@ -3026,7 +3049,7 @@ public static void IndexOf_EquivalentDiacritics_EnglishUSCulture() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_EquivalentDiacritics_InvariantCulture() { using (new ThreadCultureChange(CultureInfo.InvariantCulture)) @@ -4590,72 +4613,89 @@ public void Replace_EmptyOldValue_ThrowsArgumentException() AssertExtensions.Throws("oldValue", () => "Hello".Replace("", "l")); } + public static IEnumerable StartsWith_StringComparison_TestData() + { + // CurrentCulture + yield return new object[] { "Hello", "Hel", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "Hello", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "HELLO", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "Abc", StringComparison.CurrentCulture, false }; + yield return new object[] { "", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "", "hello", StringComparison.CurrentCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", SoftHyphen + "Hel", StringComparison.CurrentCulture, true }; + + // CurrentCultureIgnoreCase + yield return new object[] { "Hello", "Hel", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "HEL", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.CurrentCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.CurrentCultureIgnoreCase, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", SoftHyphen + "Hel", StringComparison.CurrentCultureIgnoreCase, true }; + + // InvariantCulture + yield return new object[] { "Hello", "Hel", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "Hello", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "HELLO", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "Abc", StringComparison.InvariantCulture, false }; + yield return new object[] { "", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "", "hello", StringComparison.InvariantCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", SoftHyphen + "Hel", StringComparison.InvariantCulture, true }; + + // InvariantCultureIgnoreCase + yield return new object[] { "Hello", "Hel", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "HEL", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.InvariantCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.InvariantCultureIgnoreCase, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", SoftHyphen + "Hel", StringComparison.InvariantCultureIgnoreCase, true }; + + // Ordinal + yield return new object[] { "Hello", "H", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "Hel", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "Hello", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "Hello Larger", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "HEL", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "Abc", StringComparison.Ordinal, false }; + yield return new object[] { "", "", StringComparison.Ordinal, true }; + yield return new object[] { "", "hello", StringComparison.Ordinal, false }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", StringComparison.Ordinal, true }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwx", StringComparison.Ordinal, true }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdefghijklm", StringComparison.Ordinal, true }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "ab_defghijklmnopqrstu", StringComparison.Ordinal, false }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdef_hijklmn", StringComparison.Ordinal, false }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdefghij_lmn", StringComparison.Ordinal, false }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "a", StringComparison.Ordinal, true }; + yield return new object[] { "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyza", StringComparison.Ordinal, false }; + + // OrdinalIgnoreCase + yield return new object[] { "Hello", "Hel", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Hello", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Hello Larger", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "HEL", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Abc", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", SoftHyphen + "Hel", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.OrdinalIgnoreCase, false }; + } + [Theory] - // CurrentCulture - [InlineData("Hello", "Hel", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "Hello", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "HELLO", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "Abc", StringComparison.CurrentCulture, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.CurrentCulture, true)] - [InlineData("", "", StringComparison.CurrentCulture, true)] - [InlineData("", "hello", StringComparison.CurrentCulture, false)] - // CurrentCultureIgnoreCase - [InlineData("Hello", "Hel", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "HEL", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.CurrentCultureIgnoreCase, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("", "hello", StringComparison.CurrentCultureIgnoreCase, false)] - // InvariantCulture - [InlineData("Hello", "Hel", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "Hello", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "HELLO", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "Abc", StringComparison.InvariantCulture, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.InvariantCulture, true)] - [InlineData("", "", StringComparison.InvariantCulture, true)] - [InlineData("", "hello", StringComparison.InvariantCulture, false)] - // InvariantCultureIgnoreCase - [InlineData("Hello", "Hel", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "HEL", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.InvariantCultureIgnoreCase, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("", "hello", StringComparison.InvariantCultureIgnoreCase, false)] - // Ordinal - [InlineData("Hello", "H", StringComparison.Ordinal, true)] - [InlineData("Hello", "Hel", StringComparison.Ordinal, true)] - [InlineData("Hello", "Hello", StringComparison.Ordinal, true)] - [InlineData("Hello", "Hello Larger", StringComparison.Ordinal, false)] - [InlineData("Hello", "", StringComparison.Ordinal, true)] - [InlineData("Hello", "HEL", StringComparison.Ordinal, false)] - [InlineData("Hello", "Abc", StringComparison.Ordinal, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.Ordinal, false)] - [InlineData("", "", StringComparison.Ordinal, true)] - [InlineData("", "hello", StringComparison.Ordinal, false)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", StringComparison.Ordinal, true)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwx", StringComparison.Ordinal, true)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdefghijklm", StringComparison.Ordinal, true)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "ab_defghijklmnopqrstu", StringComparison.Ordinal, false)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdef_hijklmn", StringComparison.Ordinal, false)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdefghij_lmn", StringComparison.Ordinal, false)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "a", StringComparison.Ordinal, true)] - [InlineData("abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyza", StringComparison.Ordinal, false)] - // OrdinalIgnoreCase - [InlineData("Hello", "Hel", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Hello", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Hello Larger", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "HEL", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Abc", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", SoftHyphen + "Hel", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("", "hello", StringComparison.OrdinalIgnoreCase, false)] + [MemberData(nameof(StartsWith_StringComparison_TestData))] public static void StartsWith_StringComparison(string s, string value, StringComparison comparisonType, bool expected) { if (comparisonType == StringComparison.CurrentCulture) @@ -5072,7 +5112,7 @@ private static IEnumerable ToLower_Culture_TestData() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void Test_ToLower_Culture() { foreach (object[] testdata in ToLower_Culture_TestData()) @@ -5548,7 +5588,7 @@ public static IEnumerable ToUpper_Culture_TestData() yield return new object[] { "h\u0131 world", "H\u0131 WORLD", CultureInfo.InvariantCulture }; } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToUpper_Culture_TestData))] public static void Test_ToUpper_Culture(string actual, string expected, CultureInfo culture) { @@ -5606,7 +5646,7 @@ public static IEnumerable ToUpper_TurkishI_TurkishCulture_MemberData() new KeyValuePair('\u0130', '\u0130'), new KeyValuePair('\u0131', '\u0049')); - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToUpper_TurkishI_TurkishCulture_MemberData))] public static void ToUpper_TurkishI_TurkishCulture(string s, string expected) { @@ -5626,7 +5666,7 @@ public static IEnumerable ToUpper_TurkishI_EnglishUSCulture_MemberData new KeyValuePair('\u0130', '\u0130'), new KeyValuePair('\u0131', '\u0049')); - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToUpper_TurkishI_EnglishUSCulture_MemberData))] public static void ToUpper_TurkishI_EnglishUSCulture(string s, string expected) { @@ -5646,7 +5686,7 @@ public static IEnumerable ToUpper_TurkishI_InvariantCulture_MemberData new KeyValuePair('\u0130', '\u0130'), new KeyValuePair('\u0131', '\u0131')); - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToUpper_TurkishI_InvariantCulture_MemberData))] public static void ToUpper_TurkishI_InvariantCulture(string s, string expected) { @@ -6683,25 +6723,29 @@ public string Format(string format, object arg, IFormatProvider formatProvider) } } - public static IEnumerable Compare_TestData() + public static IEnumerable CompareTest_TestData() { // str1 str2 culture ignorecase expected - yield return new object[] { "abcd", "ABcd", "en-US", false, -1 }; - yield return new object[] { "abcd", "ABcd", null, false, -1 }; - yield return new object[] { "ABcd", "abcd", "en-US", false, 1 }; - yield return new object[] { "ABcd", "abcd", null, false, 1 }; + yield return new object[] { "abcd", "ABcd", "en-US", false, PlatformDetection.IsInvariantGlobalization ? 1 : -1 }; + yield return new object[] { "abcd", "ABcd", null, false, PlatformDetection.IsInvariantGlobalization ? 1 : -1 }; + yield return new object[] { "ABcd", "abcd", "en-US", false, PlatformDetection.IsInvariantGlobalization ? -1 : 1 }; + yield return new object[] { "ABcd", "abcd", null, false, PlatformDetection.IsInvariantGlobalization ? -1 : 1 }; yield return new object[] { "abcd", "ABcd", "en-US", true, 0 }; yield return new object[] { "abcd", "ABcd", null, true, 0 }; - yield return new object[] { "latin i", "Latin I", "tr-TR", false, 1 }; - yield return new object[] { "latin i", "Latin I", "tr-TR", true, 1 }; - yield return new object[] { "turkish \u0130", "Turkish i", "tr-TR", true, 0 }; - yield return new object[] { "turkish \u0131", "Turkish I", "tr-TR", true, 0 }; yield return new object[] { null, null, "en-us", true, 0 }; yield return new object[] { null, null, null, true, 0 }; yield return new object[] { null, "", "en-us", true, -1 }; yield return new object[] { null, "", null, true, -1 }; yield return new object[] { "", null, "en-us", true, 1 }; yield return new object[] { "", null, null, true, 1 }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "latin i", "Latin I", "tr-TR", false, 1 }; + yield return new object[] { "latin i", "Latin I", "tr-TR", true, 1 }; + yield return new object[] { "turkish \u0130", "Turkish i", "tr-TR", true, 0 }; + yield return new object[] { "turkish \u0131", "Turkish I", "tr-TR", true, 0 }; + } } public static IEnumerable UpperLowerCasing_TestData() @@ -6712,9 +6756,13 @@ public static IEnumerable UpperLowerCasing_TestData() yield return new object[] { "latin i", "LATIN I", "en-US" }; yield return new object[] { "latin i", "LATIN I", null }; yield return new object[] { "", "", null }; - yield return new object[] { "turky \u0131", "TURKY I", "tr-TR" }; - yield return new object[] { "turky i", "TURKY \u0130", "tr-TR" }; - yield return new object[] { "\ud801\udc29", PlatformDetection.IsWindows7 ? "\ud801\udc29" : "\ud801\udc01", "en-US" }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "turky \u0131", "TURKY I", "tr-TR" }; + yield return new object[] { "turky i", "TURKY \u0130", "tr-TR" }; + yield return new object[] { "\ud801\udc29", PlatformDetection.IsWindows7 ? "\ud801\udc29" : "\ud801\udc01", "en-US" }; + } } public static IEnumerable StartEndWith_TestData() @@ -6726,28 +6774,32 @@ public static IEnumerable StartEndWith_TestData() yield return new object[] { "abcd", "AB", "CD", null, false, false }; yield return new object[] { "ABcd", "ab", "CD", "en-US", false, false }; yield return new object[] { "abcd", "AB", "CD", "en-US", true, true }; - yield return new object[] { "i latin i", "I Latin", "I", "tr-TR", false, false }; - yield return new object[] { "i latin i", "I Latin", "I", "tr-TR", true, false }; - yield return new object[] { "\u0130 turkish \u0130", "i", "i", "tr-TR", true, true }; - yield return new object[] { "\u0131 turkish \u0131", "I", "I", "tr-TR", true, true }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "i latin i", "I Latin", "I", "tr-TR", false, false }; + yield return new object[] { "i latin i", "I Latin", "I", "tr-TR", true, false }; + yield return new object[] { "\u0130 turkish \u0130", "i", "i", "tr-TR", true, true }; + yield return new object[] { "\u0131 turkish \u0131", "I", "I", "tr-TR", true, true }; + } } [Theory] - [MemberData(nameof(Compare_TestData))] + [MemberData(nameof(CompareTest_TestData))] public static void CompareTest(string s1, string s2, string cultureName, bool ignoreCase, int expected) { CultureInfo ci = cultureName != null ? CultureInfo.GetCultureInfo(cultureName) : null; CompareOptions ignoreCaseOption = ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None; - Assert.Equal(expected, String.Compare(s1, s2, ignoreCase, ci)); - Assert.Equal(expected, String.Compare(s1, 0, s2, 0, s1 == null ? 0 : s1.Length, ignoreCase, ci)); - Assert.Equal(expected, String.Compare(s1, 0, s2, 0, s1 == null ? 0 : s1.Length, ci, ignoreCaseOption)); + Assert.Equal(expected, Math.Sign(String.Compare(s1, s2, ignoreCase, ci))); + Assert.Equal(expected, Math.Sign(String.Compare(s1, 0, s2, 0, s1 == null ? 0 : s1.Length, ignoreCase, ci))); + Assert.Equal(expected, Math.Sign(String.Compare(s1, 0, s2, 0, s1 == null ? 0 : s1.Length, ci, ignoreCaseOption))); - Assert.Equal(expected, String.Compare(s1, s2, ci, ignoreCaseOption)); - Assert.Equal(String.Compare(s1, s2, StringComparison.Ordinal), String.Compare(s1, s2, ci, CompareOptions.Ordinal)); - Assert.Equal(String.Compare(s1, s2, StringComparison.OrdinalIgnoreCase), String.Compare(s1, s2, ci, CompareOptions.OrdinalIgnoreCase)); + Assert.Equal(expected, Math.Sign(String.Compare(s1, s2, ci, ignoreCaseOption))); + Assert.Equal(Math.Sign(String.Compare(s1, s2, StringComparison.Ordinal)), Math.Sign(String.Compare(s1, s2, ci, CompareOptions.Ordinal))); + Assert.Equal(Math.Sign(String.Compare(s1, s2, StringComparison.OrdinalIgnoreCase)), Math.Sign(String.Compare(s1, s2, ci, CompareOptions.OrdinalIgnoreCase))); - if (ci != null) + if (ci != null && PlatformDetection.IsNotInvariantGlobalization) { using (new ThreadCultureChange(ci)) { @@ -6786,7 +6838,7 @@ public static void StartEndWithTest(string source, string start, string end, str Assert.Equal(expected, source.EndsWith(end, ignoreCase, ci)); } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [InlineData("", StringComparison.InvariantCulture, true)] [InlineData("", StringComparison.Ordinal, true)] [InlineData(ZeroWidthJoiner, StringComparison.InvariantCulture, true)] @@ -6970,7 +7022,7 @@ public static void StartsWithUnknownComparisonType_StringComparison() Assert.Throws(() => s1.AsSpan().CompareTo(s1.AsSpan(), (StringComparison)6)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void StartsWithMatchNonOrdinal_StringComparison() { string s1 = "abcd"; @@ -7247,7 +7299,7 @@ public static void InternalTestAotSubset() #pragma warning restore 0618 // restore warning when accessing obsolete members } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [ActiveIssue("https://github.com/dotnet/runtime/issues/34577", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)] public static unsafe void NormalizationTest() // basic test; more tests in globalization tests { diff --git a/src/libraries/System.Runtime/tests/System/ActivatorTests.cs b/src/libraries/System.Runtime/tests/System/ActivatorTests.cs index 8a92b10e7a606..05e07447a9616 100644 --- a/src/libraries/System.Runtime/tests/System/ActivatorTests.cs +++ b/src/libraries/System.Runtime/tests/System/ActivatorTests.cs @@ -619,7 +619,7 @@ public void CreateInstance_PublicOnlyValueTypeWithPrivateDefaultConstructor_Thro } [Theory] - [ActiveIssue("https://github.com/dotnet/runtime/issues/34030", TestPlatforms.Linux, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/34030", TestPlatforms.Linux | TestPlatforms.Browser, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)] [MemberData(nameof(TestingCreateInstanceFromObjectHandleData))] public static void TestingCreateInstanceFromObjectHandle(string physicalFileName, string assemblyFile, string type, string returnedFullNameType, Type exceptionType) { @@ -717,7 +717,7 @@ public static void TestingCreateInstanceObjectHandle(string assemblyName, string }; [Theory] - [ActiveIssue("https://github.com/dotnet/runtime/issues/34030", TestPlatforms.Linux, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/34030", TestPlatforms.Linux | TestPlatforms.Browser, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)] [MemberData(nameof(TestingCreateInstanceFromObjectHandleFullSignatureData))] public static void TestingCreateInstanceFromObjectHandleFullSignature(string physicalFileName, string assemblyFile, string type, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes, string returnedFullNameType) { diff --git a/src/libraries/System.Runtime/tests/System/ArgIteratorTests.cs b/src/libraries/System.Runtime/tests/System/ArgIteratorTests.cs index 29baaf32646f7..e194f4db7e043 100644 --- a/src/libraries/System.Runtime/tests/System/ArgIteratorTests.cs +++ b/src/libraries/System.Runtime/tests/System/ArgIteratorTests.cs @@ -9,6 +9,7 @@ namespace System.Tests { public static class ArgIteratorTests { + [ActiveIssue("https://github.com/dotnet/runtime/issues/39343", TestPlatforms.Browser)] [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsArgIteratorSupported))] public static void ArgIterator_GetRemainingCount_GetNextArg() { diff --git a/src/libraries/System.Runtime/tests/System/CharTests.cs b/src/libraries/System.Runtime/tests/System/CharTests.cs index cb8fb0394c3be..c8a14438e38e0 100644 --- a/src/libraries/System.Runtime/tests/System/CharTests.cs +++ b/src/libraries/System.Runtime/tests/System/CharTests.cs @@ -942,16 +942,28 @@ private static IEnumerable GetTestChars(params UnicodeCategory[] categorie { for (int i = 0; i < categories.Length; i++) { - char[] latinSet = s_latinTestSet[(int)categories[i]]; + UnicodeCategory category = categories[i]; + char[] latinSet = s_latinTestSet[(int)category]; for (int j = 0; j < latinSet.Length; j++) - yield return latinSet[j]; + if (ShouldTestCasingForChar(latinSet[j], category)) + yield return latinSet[j]; - char[] unicodeSet = s_unicodeTestSet[(int)categories[i]]; + char[] unicodeSet = s_unicodeTestSet[(int)category]; for (int k = 0; k < unicodeSet.Length; k++) - yield return unicodeSet[k]; + if (ShouldTestCasingForChar(unicodeSet[k], category)) + yield return unicodeSet[k]; } } + private static bool ShouldTestCasingForChar(char ch, UnicodeCategory category) + { + return PlatformDetection.IsNotInvariantGlobalization || + (category != UnicodeCategory.UppercaseLetter && + category != UnicodeCategory.LowercaseLetter) || + ch >= 'a' && ch <= 'z' || + ch >= 'A' && ch <= 'Z'; + } + private static char[][] s_latinTestSet = new char[][] { new char[] {'\u0047','\u004c','\u0051','\u0056','\u00c0','\u00c5','\u00ca','\u00cf','\u00d4','\u00da'}, // UnicodeCategory.UppercaseLetter @@ -1063,11 +1075,15 @@ private static IEnumerable GetTestChars(params UnicodeCategory[] categorie public static IEnumerable UpperLowerCasing_TestData() { // lower upper Culture - yield return new object[] { 'a', 'A', "en-US" }; - yield return new object[] { 'i', 'I', "en-US" }; - yield return new object[] { '\u0131', 'I', "tr-TR" }; - yield return new object[] { 'i', '\u0130', "tr-TR" }; - yield return new object[] { '\u0660', '\u0660', "en-US" }; + yield return new object[] { 'a', 'A', "en-US" }; + yield return new object[] { 'i', 'I', "en-US" }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { '\u0131', 'I', "tr-TR" }; + yield return new object[] { 'i', '\u0130', "tr-TR" }; + yield return new object[] { '\u0660', '\u0660', "en-US" }; + } } [Fact] @@ -1076,7 +1092,7 @@ public static void LatinRangeTest() StringBuilder sb = new StringBuilder(256); string latineString = sb.ToString(); - for (int i=0; i < latineString.Length; i++) + for (int i = 0; i < latineString.Length; i++) { Assert.Equal(s_categoryForLatin1[i], char.GetUnicodeCategory(latineString[i])); Assert.Equal(s_categoryForLatin1[i], char.GetUnicodeCategory(latineString, i)); @@ -1086,14 +1102,14 @@ public static void LatinRangeTest() [Fact] public static void NonLatinRangeTest() { - for (int i=256; i <= 0xFFFF; i++) + for (int i = 256; i <= 0xFFFF; i++) { Assert.Equal(CharUnicodeInfo.GetUnicodeCategory((char)i), char.GetUnicodeCategory((char)i)); } string nonLatinString = "\u0100\u0200\u0300\u0400\u0500\u0600\u0700\u0800\u0900\u0A00\u0B00\u0C00\u0D00\u0E00\u0F00" + "\u1000\u2000\u3000\u4000\u5000\u6000\u7000\u8000\u9000\uA000\uB000\uC000\uD000\uE000\uF000"; - for (int i=0; i < nonLatinString.Length; i++) + for (int i = 0; i < nonLatinString.Length; i++) { Assert.Equal(CharUnicodeInfo.GetUnicodeCategory(nonLatinString[i]), char.GetUnicodeCategory(nonLatinString, i)); } diff --git a/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs b/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs index 950a2860ed32f..940704fa9a044 100644 --- a/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs +++ b/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs @@ -1238,15 +1238,18 @@ public static IEnumerable ToString_MatchesExpected_MemberData() yield return new object[] { new DateTimeOffset(1617181518122280616, TimeSpan.FromSeconds(26280)), "O", null, "5125-08-24T20:50:12.2280616+07:18" }; // Year patterns - var enUS = new CultureInfo("en-US"); var thTH = new CultureInfo("th-TH"); yield return new object[] { new DateTimeOffset(new DateTime(1234, 5, 6)), "yy", enUS, "34" }; - yield return new object[] { DateTimeOffset.MaxValue, "yy", thTH, "42" }; + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { DateTimeOffset.MaxValue, "yy", thTH, "42" }; + for (int i = 3; i < 20; i++) { yield return new object[] { new DateTimeOffset(new DateTime(1234, 5, 6)), new string('y', i), enUS, 1234.ToString("D" + i) }; - yield return new object[] { DateTimeOffset.MaxValue, new string('y', i), thTH, 10542.ToString("D" + i) }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { DateTimeOffset.MaxValue, new string('y', i), thTH, 10542.ToString("D" + i) }; } } @@ -1268,7 +1271,7 @@ public static IEnumerable ToString_WithCulture_MatchesExpected_MemberD yield return new object[] { new DateTimeOffset(636572516255571994, TimeSpan.FromHours(-5)), "Y", new CultureInfo("da-DK"), "marts 2018" }; } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToString_WithCulture_MatchesExpected_MemberData))] public static void ToString_WithCulture_MatchesExpected(DateTimeOffset dateTimeOffset, string format, CultureInfo culture, string expected) { @@ -1349,7 +1352,7 @@ public static void TryFormat_ToString_EqualResults() Assert.Equal(0, actual[actual.Length - 1]); } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToString_MatchesExpected_MemberData))] public static void TryFormat_MatchesExpected(DateTimeOffset dateTimeOffset, string format, IFormatProvider provider, string expected) { diff --git a/src/libraries/System.Runtime/tests/System/DateTimeTests.cs b/src/libraries/System.Runtime/tests/System/DateTimeTests.cs index b7951f3787250..09aacebf83d09 100644 --- a/src/libraries/System.Runtime/tests/System/DateTimeTests.cs +++ b/src/libraries/System.Runtime/tests/System/DateTimeTests.cs @@ -1711,13 +1711,16 @@ public static IEnumerable Parse_ValidInput_Succeeds_MemberData() yield return new object[] { "2 2 2Z", CultureInfo.InvariantCulture, TimeZoneInfo.ConvertTimeFromUtc(new DateTime(2002, 2, 2, 0, 0, 0, DateTimeKind.Utc), TimeZoneInfo.Local) }; yield return new object[] { "#10/10/2095#\0", CultureInfo.InvariantCulture, new DateTime(2095, 10, 10, 0, 0, 0) }; - DateTime today = DateTime.Today; - var hebrewCulture = new CultureInfo("he-IL"); - hebrewCulture.DateTimeFormat.Calendar = new HebrewCalendar(); - yield return new object[] { today.ToString(hebrewCulture), hebrewCulture, today }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + DateTime today = DateTime.Today; + var hebrewCulture = new CultureInfo("he-IL"); + hebrewCulture.DateTimeFormat.Calendar = new HebrewCalendar(); + yield return new object[] { today.ToString(hebrewCulture), hebrewCulture, today }; - var mongolianCulture = new CultureInfo("mn-MN"); - yield return new object[] { today.ToString(mongolianCulture), mongolianCulture, today }; + var mongolianCulture = new CultureInfo("mn-MN"); + yield return new object[] { today.ToString(mongolianCulture), mongolianCulture, today }; + } } [Theory] @@ -1832,12 +1835,15 @@ public static IEnumerable ParseExact_ValidInput_Succeeds_MemberData() yield return new object[] { " 9 / 8 / 2017 10 : 11 : 12 AM", "M/d/yyyy HH':'mm':'ss tt\' \'", CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, new DateTime(2017, 9, 8, 10, 11, 12) }; yield return new object[] { " 9 / 8 / 2017 10 : 11 : 12 AM", "M/d/yyyy HH':'mm':'ss tt\' \'", CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, new DateTime(2017, 9, 8, 10, 11, 12) }; - var hebrewCulture = new CultureInfo("he-IL"); - hebrewCulture.DateTimeFormat.Calendar = new HebrewCalendar(); - DateTime today = DateTime.Today; - foreach (string pattern in hebrewCulture.DateTimeFormat.GetAllDateTimePatterns()) + if (PlatformDetection.IsNotInvariantGlobalization) { - yield return new object[] { today.ToString(pattern, hebrewCulture), pattern, hebrewCulture, DateTimeStyles.None, null }; + var hebrewCulture = new CultureInfo("he-IL"); + hebrewCulture.DateTimeFormat.Calendar = new HebrewCalendar(); + DateTime today = DateTime.Today; + foreach (string pattern in hebrewCulture.DateTimeFormat.GetAllDateTimePatterns()) + { + yield return new object[] { today.ToString(pattern, hebrewCulture), pattern, hebrewCulture, DateTimeStyles.None, null }; + } } } @@ -2004,15 +2010,27 @@ public static IEnumerable ToString_MatchesExpected_MemberData() yield return new object[] { new DateTime(221550163152616218, DateTimeKind.Utc), "r", null, "Sun, 25 Jan 0703 19:11:55 GMT" }; // Year patterns - - var enUS = new CultureInfo("en-US"); - var thTH = new CultureInfo("th-TH"); - yield return new object[] { new DateTime(1234, 5, 6), "yy", enUS, "34" }; - yield return new object[] { DateTime.MaxValue, "yy", thTH, "42" }; - for (int i = 3; i < 20; i++) + if (PlatformDetection.IsNotInvariantGlobalization) + { + var enUS = new CultureInfo("en-US"); + var thTH = new CultureInfo("th-TH"); + yield return new object[] { new DateTime(1234, 5, 6), "yy", enUS, "34" }; + yield return new object[] { DateTime.MaxValue, "yy", thTH, "42" }; + for (int i = 3; i < 20; i++) + { + yield return new object[] { new DateTime(1234, 5, 6), new string('y', i), enUS, 1234.ToString("D" + i) }; + yield return new object[] { DateTime.MaxValue, new string('y', i), thTH, 10542.ToString("D" + i) }; + } + } + else { - yield return new object[] { new DateTime(1234, 5, 6), new string('y', i), enUS, 1234.ToString("D" + i) }; - yield return new object[] { DateTime.MaxValue, new string('y', i), thTH, 10542.ToString("D" + i) }; + var invariant = new CultureInfo(""); + yield return new object[] { new DateTime(1234, 5, 6), "yy", invariant, "34" }; + + for (int i = 3; i < 20; i++) + { + yield return new object[] { new DateTime(1234, 5, 6), new string('y', i), invariant, 1234.ToString("D" + i) }; + } } } @@ -2299,7 +2317,7 @@ public static void TryFormat_MatchesToString(string format) Assert.Equal(0, dest[dest.Length - 1]); } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] [MemberData(nameof(ToString_MatchesExpected_MemberData))] public static void TryFormat_MatchesExpected(DateTime dateTime, string format, IFormatProvider provider, string expected) { diff --git a/src/libraries/System.Runtime/tests/System/Reflection/InvokeRefReturn.cs b/src/libraries/System.Runtime/tests/System/Reflection/InvokeRefReturn.cs index 885e17992c176..ee28dd51c2e37 100644 --- a/src/libraries/System.Runtime/tests/System/Reflection/InvokeRefReturn.cs +++ b/src/libraries/System.Runtime/tests/System/Reflection/InvokeRefReturn.cs @@ -59,6 +59,7 @@ public static unsafe void TestRefReturnOfPointer() } [Fact] + [ActiveIssue("https://github.com/dotnet/runtime/issues/39380", TestPlatforms.Browser)] public static unsafe void TestNullRefReturnOfPointer() { TestClassIntPointer tc = new TestClassIntPointer(null); diff --git a/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs b/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs index c2bb2bdc48cd1..c3242a0197cf8 100644 --- a/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs +++ b/src/libraries/System.Runtime/tests/System/Runtime/ExceptionServices/ExceptionDispatchInfoTests.cs @@ -49,6 +49,7 @@ public static void SetCurrentStackTrace_Invalid_Throws() } [Fact] + [ActiveIssue("https://github.com/dotnet/runtime/issues/39341", TestPlatforms.Browser)] public static void SetCurrentStackTrace_IncludedInExceptionStackTrace() { Exception e; diff --git a/src/libraries/System.Runtime/tests/System/StringTests.cs b/src/libraries/System.Runtime/tests/System/StringTests.cs index c9e8789008e5b..dabb22f2027ce 100644 --- a/src/libraries/System.Runtime/tests/System/StringTests.cs +++ b/src/libraries/System.Runtime/tests/System/StringTests.cs @@ -204,80 +204,101 @@ public static void Contains_Char_StringComparison(string s, char value, StringCo Assert.Equal(expected, s.Contains(value, comparisionType)); } + public static IEnumerable Contains_String_StringComparison_TestData() + { + yield return new object[] { "Hello", "ello", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "ELL", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "ElLo", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.CurrentCulture, false }; + yield return new object[] { "", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "", "hello", StringComparison.CurrentCulture, false }; + yield return new object[] { "Hello", "", StringComparison.CurrentCulture, true }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.CurrentCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.CurrentCulture, true }; + + // CurrentCultureIgnoreCase + yield return new object[] { "Hello", "ello", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "ELL", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "ElLo", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.CurrentCultureIgnoreCase, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.CurrentCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.CurrentCultureIgnoreCase, false }; + yield return new object[] { "Hello", "", StringComparison.CurrentCultureIgnoreCase, true }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true }; + } + + // InvariantCulture + yield return new object[] { "Hello", "ello", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "ELL", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "ElLo", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.InvariantCulture, false }; + yield return new object[] { "", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "", "hello", StringComparison.InvariantCulture, false }; + yield return new object[] { "Hello", "", StringComparison.InvariantCulture, true }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.InvariantCulture, false }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.InvariantCulture, true }; + + // InvariantCultureIgnoreCase + yield return new object[] { "Hello", "ello", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "ELL", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "ElLo", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.InvariantCultureIgnoreCase, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.InvariantCultureIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.InvariantCultureIgnoreCase, false }; + yield return new object[] { "Hello", "", StringComparison.InvariantCultureIgnoreCase, true }; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true }; + } + + // Ordinal + yield return new object[] { "Hello", "ello", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "ELL", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "ElLo", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.Ordinal, false }; + yield return new object[] { "", "", StringComparison.Ordinal, true }; + yield return new object[] { "", "hello", StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "", StringComparison.Ordinal, true }; + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.Ordinal, false }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.Ordinal, false }; + + // OrdinalIgnoreCase + yield return new object[] { "Hello", "ello", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "ELL", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "ElLo", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "Larger Hello", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "Goodbye", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "", "hello", StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "", StringComparison.OrdinalIgnoreCase, true }; + yield return new object[] { "Hello", "ell" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false }; + yield return new object[] { "Hello", "Ell" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false }; + } + [Theory] - // CurrentCulture - [InlineData("Hello", "ello", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "ELL", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "ElLo", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "Larger Hello", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "Goodbye", StringComparison.CurrentCulture, false)] - [InlineData("", "", StringComparison.CurrentCulture, true)] - [InlineData("", "hello", StringComparison.CurrentCulture, false)] - [InlineData("Hello", "", StringComparison.CurrentCulture, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.CurrentCulture, true)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.CurrentCulture, false)] - // CurrentCultureIgnoreCase - [InlineData("Hello", "ello", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "ELL", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "ElLo", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Larger Hello", StringComparison.CurrentCultureIgnoreCase, false)] - [InlineData("Hello", "Goodbye", StringComparison.CurrentCultureIgnoreCase, false)] - [InlineData("", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("", "hello", StringComparison.CurrentCultureIgnoreCase, false)] - [InlineData("Hello", "", StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.CurrentCultureIgnoreCase, true)] - // InvariantCulture - [InlineData("Hello", "ello", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "ELL", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "ElLo", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "Larger Hello", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "Goodbye", StringComparison.InvariantCulture, false)] - [InlineData("", "", StringComparison.InvariantCulture, true)] - [InlineData("", "hello", StringComparison.InvariantCulture, false)] - [InlineData("Hello", "", StringComparison.InvariantCulture, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.InvariantCulture, true)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.InvariantCulture, false)] - // InvariantCultureIgnoreCase - [InlineData("Hello", "ello", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "ELL", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "ElLo", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Larger Hello", StringComparison.InvariantCultureIgnoreCase, false)] - [InlineData("Hello", "Goodbye", StringComparison.InvariantCultureIgnoreCase, false)] - [InlineData("", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("", "hello", StringComparison.InvariantCultureIgnoreCase, false)] - [InlineData("Hello", "", StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.InvariantCultureIgnoreCase, true)] - // Ordinal - [InlineData("Hello", "ello", StringComparison.Ordinal, true)] - [InlineData("Hello", "ELL", StringComparison.Ordinal, false)] - [InlineData("Hello", "ElLo", StringComparison.Ordinal, false)] - [InlineData("Hello", "Larger Hello", StringComparison.Ordinal, false)] - [InlineData("Hello", "Goodbye", StringComparison.Ordinal, false)] - [InlineData("", "", StringComparison.Ordinal, true)] - [InlineData("", "hello", StringComparison.Ordinal, false)] - [InlineData("Hello", "", StringComparison.Ordinal, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.Ordinal, false)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.Ordinal, false)] - // OrdinalIgnoreCase - [InlineData("Hello", "ello", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "ELL", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "ElLo", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "Larger Hello", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "Goodbye", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("", "hello", StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "", StringComparison.OrdinalIgnoreCase, true)] - [InlineData("Hello", "ell" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false)] - [InlineData("Hello", "Ell" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false)] + [MemberData(nameof(Contains_String_StringComparison_TestData))] public static void Contains_String_StringComparison(string s, string value, StringComparison comparisonType, bool expected) { Assert.Equal(expected, s.Contains(value, comparisonType)); Assert.Equal(expected, s.AsSpan().Contains(value, comparisonType)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void Contains_StringComparison_TurkishI() { const string Source = "\u0069\u0130"; @@ -593,7 +614,9 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.CurrentCulture, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.CurrentCulture, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.CurrentCulture, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.CurrentCulture, "def" }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.CurrentCulture, "def" }; yield return new object[] { "abc", "abc", "def", StringComparison.CurrentCultureIgnoreCase, "def" }; yield return new object[] { "abc", "ABC", "def", StringComparison.CurrentCultureIgnoreCase, "def" }; @@ -601,7 +624,9 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.CurrentCultureIgnoreCase, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.CurrentCultureIgnoreCase, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.CurrentCultureIgnoreCase, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.CurrentCultureIgnoreCase, "def" }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.CurrentCultureIgnoreCase, "def" }; yield return new object[] { "abc", "abc", "def", StringComparison.Ordinal, "def" }; yield return new object[] { "abc", "ABC", "def", StringComparison.Ordinal, "abc" }; @@ -609,7 +634,9 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.Ordinal, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.Ordinal, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.Ordinal, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.Ordinal, "abc" }; + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.Ordinal, "abc" }; yield return new object[] { "abc", "abc", "def", StringComparison.OrdinalIgnoreCase, "def" }; yield return new object[] { "abc", "ABC", "def", StringComparison.OrdinalIgnoreCase, "def" }; @@ -617,7 +644,10 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.OrdinalIgnoreCase, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.OrdinalIgnoreCase, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.OrdinalIgnoreCase, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.OrdinalIgnoreCase, "abc" }; + + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.OrdinalIgnoreCase, "abc" }; yield return new object[] { "abc", "abc", "def", StringComparison.InvariantCulture, "def" }; yield return new object[] { "abc", "ABC", "def", StringComparison.InvariantCulture, "abc" }; @@ -625,7 +655,10 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.InvariantCulture, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.InvariantCulture, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.InvariantCulture, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.InvariantCulture, "def" }; + + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.InvariantCulture, "def" }; yield return new object[] { "abc", "abc", "def", StringComparison.InvariantCultureIgnoreCase, "def" }; yield return new object[] { "abc", "ABC", "def", StringComparison.InvariantCultureIgnoreCase, "def" }; @@ -633,19 +666,24 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "abc", "b", "LONG", StringComparison.InvariantCultureIgnoreCase, "aLONGc" }; yield return new object[] { "abc", "b", "d", StringComparison.InvariantCultureIgnoreCase, "adc" }; yield return new object[] { "abc", "b", null, StringComparison.InvariantCultureIgnoreCase, "ac" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.InvariantCultureIgnoreCase, "def" }; - string turkishSource = "\u0069\u0130"; + + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.InvariantCultureIgnoreCase, "def" }; + + string turkishSource = "\u0069\u0130"; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.Ordinal, "a\u0130" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.OrdinalIgnoreCase, "a\u0130" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.Ordinal, "\u0069a" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.OrdinalIgnoreCase, "\u0069a" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.Ordinal, "a\u0130" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.OrdinalIgnoreCase, "a\u0130" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.Ordinal, "\u0069a" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.OrdinalIgnoreCase, "\u0069a" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCulture, "a\u0130" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCultureIgnoreCase, "a\u0130" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCulture, "\u0069a" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCultureIgnoreCase, "\u0069a" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCulture, "a\u0130" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCultureIgnoreCase, "a\u0130" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCulture, "\u0069a" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCultureIgnoreCase, "\u0069a" }; + } } [Theory] @@ -655,7 +693,7 @@ public void Replace_StringComparison_ReturnsExpected(string original, string old Assert.Equal(expected, original.Replace(oldValue, newValue, comparisonType)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public void Replace_StringComparison_TurkishI() { const string Source = "\u0069\u0130"; @@ -693,15 +731,18 @@ public static IEnumerable Replace_StringComparisonCulture_TestData() yield return new object[] { "abc", "abc", "def", true, CultureInfo.InvariantCulture, "def" }; yield return new object[] { "abc", "ABC", "def", true, CultureInfo.InvariantCulture, "def" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", false, null, "def" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", true, null, "def" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", false, CultureInfo.InvariantCulture, "def" }; - yield return new object[] { "abc", "abc" + SoftHyphen, "def", true, CultureInfo.InvariantCulture, "def" }; - - yield return new object[] { "\u0069\u0130", "\u0069", "a", false, new CultureInfo("tr-TR"), "a\u0130" }; - yield return new object[] { "\u0069\u0130", "\u0069", "a", true, new CultureInfo("tr-TR"), "aa" }; - yield return new object[] { "\u0069\u0130", "\u0069", "a", false, CultureInfo.InvariantCulture, "a\u0130" }; - yield return new object[] { "\u0069\u0130", "\u0069", "a", true, CultureInfo.InvariantCulture, "a\u0130" }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + yield return new object[] { "abc", "abc" + SoftHyphen, "def", false, null, "def" }; + yield return new object[] { "abc", "abc" + SoftHyphen, "def", true, null, "def" }; + yield return new object[] { "abc", "abc" + SoftHyphen, "def", false, CultureInfo.InvariantCulture, "def" }; + yield return new object[] { "abc", "abc" + SoftHyphen, "def", true, CultureInfo.InvariantCulture, "def" }; + + yield return new object[] { "\u0069\u0130", "\u0069", "a", false, new CultureInfo("tr-TR"), "a\u0130" }; + yield return new object[] { "\u0069\u0130", "\u0069", "a", true, new CultureInfo("tr-TR"), "aa" }; + yield return new object[] { "\u0069\u0130", "\u0069", "a", false, CultureInfo.InvariantCulture, "a\u0130" }; + yield return new object[] { "\u0069\u0130", "\u0069", "a", true, CultureInfo.InvariantCulture, "a\u0130" }; + } } [Theory] @@ -729,7 +770,7 @@ public void Replace_StringComparison_EmptyOldValue_ThrowsArgumentException() AssertExtensions.Throws("oldValue", () => "abc".Replace("", "def", true, CultureInfo.CurrentCulture)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public void Replace_StringComparison_WeightlessOldValue_WithOrdinalComparison_Succeeds() { Assert.Equal("abcdef", ("abc" + ZeroWidthJoiner).Replace(ZeroWidthJoiner, "def")); @@ -737,7 +778,7 @@ public void Replace_StringComparison_WeightlessOldValue_WithOrdinalComparison_Su Assert.Equal("abcdef", ("abc" + ZeroWidthJoiner).Replace(ZeroWidthJoiner, "def", StringComparison.OrdinalIgnoreCase)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public void Replace_StringComparison_WeightlessOldValue_WithLinguisticComparison_TerminatesReplacement() { Assert.Equal("abc" + ZeroWidthJoiner + "def", ("abc" + ZeroWidthJoiner + "def").Replace(ZeroWidthJoiner, "xyz", StringComparison.CurrentCulture)); @@ -971,7 +1012,7 @@ public static void IndexOf_SingleLetter_StringComparison(string s, char target, Assert.Equal(expected, s.AsSpan().IndexOf(charArray, stringComparison)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_TurkishI_TurkishCulture_Char() { using (new ThreadCultureChange("tr-TR")) @@ -1003,7 +1044,7 @@ public static void IndexOf_TurkishI_TurkishCulture_Char() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_TurkishI_InvariantCulture_Char() { using (new ThreadCultureChange(CultureInfo.InvariantCulture)) @@ -1021,7 +1062,7 @@ public static void IndexOf_TurkishI_InvariantCulture_Char() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_TurkishI_EnglishUSCulture_Char() { using (new ThreadCultureChange("en-US")) @@ -1039,7 +1080,7 @@ public static void IndexOf_TurkishI_EnglishUSCulture_Char() } } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] public static void IndexOf_EquivalentDiacritics_EnglishUSCulture_Char() { string s = "Exhibit a\u0300\u00C0"; @@ -1065,7 +1106,7 @@ public static void IndexOf_EquivalentDiacritics_InvariantCulture_Char() { Assert.Equal(10, s.IndexOf(value)); Assert.Equal(10, s.IndexOf(value, StringComparison.CurrentCulture)); - Assert.Equal(8, s.IndexOf(value, StringComparison.CurrentCultureIgnoreCase)); + Assert.Equal(PlatformDetection.IsInvariantGlobalization ? 10 : 8, s.IndexOf(value, StringComparison.CurrentCultureIgnoreCase)); } } diff --git a/src/libraries/System.Runtime/tests/System/TimeSpanTests.cs b/src/libraries/System.Runtime/tests/System/TimeSpanTests.cs index 296cc923173f9..f538d8cccd329 100644 --- a/src/libraries/System.Runtime/tests/System/TimeSpanTests.cs +++ b/src/libraries/System.Runtime/tests/System/TimeSpanTests.cs @@ -608,9 +608,12 @@ public static IEnumerable Parse_Valid_TestData() yield return new object[] { "23:00:00", null, new TimeSpan(23, 0, 0) }; yield return new object[] { "24:00:00", null, new TimeSpan(24, 0, 0, 0) }; - // Croatia uses ',' in place of '.' - CultureInfo croatianCulture = new CultureInfo("hr-HR"); - yield return new object[] { "6:12:14:45,348", croatianCulture, new TimeSpan(6, 12, 14, 45, 348) }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + // Croatia uses ',' in place of '.' + CultureInfo croatianCulture = new CultureInfo("hr-HR"); + yield return new object[] { "6:12:14:45,348", croatianCulture, new TimeSpan(6, 12, 14, 45, 348) }; + } } [Theory] @@ -655,7 +658,9 @@ public static IEnumerable Parse_Invalid_TestData() yield return new object[] { "00:00::00", null, typeof(FormatException) }; // duplicated separator yield return new object[] { "00:00:00:", null, typeof(FormatException) }; // extra separator at end yield return new object[] { "00:00:00:00:00:00:00:00", null, typeof(FormatException) }; // too many components - yield return new object[] { "6:12:14:45.3448", new CultureInfo("hr-HR"), typeof(FormatException) }; // culture that uses ',' rather than '.' + + if (PlatformDetection.IsNotInvariantGlobalization) + yield return new object[] { "6:12:14:45.3448", new CultureInfo("hr-HR"), typeof(FormatException) }; // culture that uses ',' rather than '.' // OverflowExceptions yield return new object[] { "1:1:1.99999999", null, typeof(OverflowException) }; // overflowing fraction @@ -956,7 +961,8 @@ public static IEnumerable ToString_TestData() yield return new object[] { input, "dddddd\\.ss", invariantInfo, "000142.18" }; // constant/invariant format - foreach (CultureInfo info in new[] { null, invariantInfo, commaSeparatorInfo }) // validate that culture is ignored + CultureInfo[] cultureInfos = PlatformDetection.IsInvariantGlobalization ? new[] { (CultureInfo)null } : new[] { null, invariantInfo, commaSeparatorInfo }; + foreach (CultureInfo info in cultureInfos) // validate that culture is ignored { foreach (string constFormat in new[] { null, "c", "t", "T" }) { @@ -989,19 +995,22 @@ public static IEnumerable ToString_TestData() yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "g", invariantInfo, "13:10:56:23.045" }; yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "g", invariantInfo, "23:59:59.999" }; - // general short format, NumberDecimalSeparator used - yield return new object[] { input, "g", commaSeparatorInfo, "142:21:21:18,9101112" }; - yield return new object[] { TimeSpan.Zero, "g", commaSeparatorInfo, "0:00:00" }; - yield return new object[] { new TimeSpan(1), "g", commaSeparatorInfo, "0:00:00,0000001" }; - yield return new object[] { new TimeSpan(-1), "g", commaSeparatorInfo, "-0:00:00,0000001" }; - yield return new object[] { TimeSpan.MaxValue, "g", commaSeparatorInfo, "10675199:2:48:05,4775807" }; - yield return new object[] { TimeSpan.MinValue, "g", commaSeparatorInfo, "-10675199:2:48:05,4775808" }; - yield return new object[] { new TimeSpan(1, 2, 3), "g", commaSeparatorInfo, "1:02:03" }; - yield return new object[] { -new TimeSpan(1, 2, 3), "g", commaSeparatorInfo, "-1:02:03" }; - yield return new object[] { new TimeSpan(12, 34, 56), "g", commaSeparatorInfo, "12:34:56" }; - yield return new object[] { new TimeSpan(12, 34, 56, 23), "g", commaSeparatorInfo, "13:10:56:23" }; - yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "g", commaSeparatorInfo, "13:10:56:23,045" }; - yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "g", commaSeparatorInfo, "23:59:59,999" }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + // general short format, NumberDecimalSeparator used + yield return new object[] { input, "g", commaSeparatorInfo, "142:21:21:18,9101112" }; + yield return new object[] { TimeSpan.Zero, "g", commaSeparatorInfo, "0:00:00" }; + yield return new object[] { new TimeSpan(1), "g", commaSeparatorInfo, "0:00:00,0000001" }; + yield return new object[] { new TimeSpan(-1), "g", commaSeparatorInfo, "-0:00:00,0000001" }; + yield return new object[] { TimeSpan.MaxValue, "g", commaSeparatorInfo, "10675199:2:48:05,4775807" }; + yield return new object[] { TimeSpan.MinValue, "g", commaSeparatorInfo, "-10675199:2:48:05,4775808" }; + yield return new object[] { new TimeSpan(1, 2, 3), "g", commaSeparatorInfo, "1:02:03" }; + yield return new object[] { -new TimeSpan(1, 2, 3), "g", commaSeparatorInfo, "-1:02:03" }; + yield return new object[] { new TimeSpan(12, 34, 56), "g", commaSeparatorInfo, "12:34:56" }; + yield return new object[] { new TimeSpan(12, 34, 56, 23), "g", commaSeparatorInfo, "13:10:56:23" }; + yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "g", commaSeparatorInfo, "13:10:56:23,045" }; + yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "g", commaSeparatorInfo, "23:59:59,999" }; + } // general long format, invariant culture yield return new object[] { input, "G", invariantInfo, "142:21:21:18.9101112" }; @@ -1017,19 +1026,22 @@ public static IEnumerable ToString_TestData() yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "G", invariantInfo, "13:10:56:23.0450000" }; yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "G", invariantInfo, "0:23:59:59.9990000" }; - // general long format, NumberDecimalSeparator used - yield return new object[] { input, "G", commaSeparatorInfo, "142:21:21:18,9101112" }; - yield return new object[] { TimeSpan.Zero, "G", commaSeparatorInfo, "0:00:00:00,0000000" }; - yield return new object[] { new TimeSpan(1), "G", commaSeparatorInfo, "0:00:00:00,0000001" }; - yield return new object[] { new TimeSpan(-1), "G", commaSeparatorInfo, "-0:00:00:00,0000001" }; - yield return new object[] { TimeSpan.MaxValue, "G", commaSeparatorInfo, "10675199:02:48:05,4775807" }; - yield return new object[] { TimeSpan.MinValue, "G", commaSeparatorInfo, "-10675199:02:48:05,4775808" }; - yield return new object[] { new TimeSpan(1, 2, 3), "G", commaSeparatorInfo, "0:01:02:03,0000000" }; - yield return new object[] { -new TimeSpan(1, 2, 3), "G", commaSeparatorInfo, "-0:01:02:03,0000000" }; - yield return new object[] { new TimeSpan(12, 34, 56), "G", commaSeparatorInfo, "0:12:34:56,0000000" }; - yield return new object[] { new TimeSpan(12, 34, 56, 23), "G", commaSeparatorInfo, "13:10:56:23,0000000" }; - yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "G", commaSeparatorInfo, "13:10:56:23,0450000" }; - yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "G", commaSeparatorInfo, "0:23:59:59,9990000" }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + // general long format, NumberDecimalSeparator used + yield return new object[] { input, "G", commaSeparatorInfo, "142:21:21:18,9101112" }; + yield return new object[] { TimeSpan.Zero, "G", commaSeparatorInfo, "0:00:00:00,0000000" }; + yield return new object[] { new TimeSpan(1), "G", commaSeparatorInfo, "0:00:00:00,0000001" }; + yield return new object[] { new TimeSpan(-1), "G", commaSeparatorInfo, "-0:00:00:00,0000001" }; + yield return new object[] { TimeSpan.MaxValue, "G", commaSeparatorInfo, "10675199:02:48:05,4775807" }; + yield return new object[] { TimeSpan.MinValue, "G", commaSeparatorInfo, "-10675199:02:48:05,4775808" }; + yield return new object[] { new TimeSpan(1, 2, 3), "G", commaSeparatorInfo, "0:01:02:03,0000000" }; + yield return new object[] { -new TimeSpan(1, 2, 3), "G", commaSeparatorInfo, "-0:01:02:03,0000000" }; + yield return new object[] { new TimeSpan(12, 34, 56), "G", commaSeparatorInfo, "0:12:34:56,0000000" }; + yield return new object[] { new TimeSpan(12, 34, 56, 23), "G", commaSeparatorInfo, "13:10:56:23,0000000" }; + yield return new object[] { new TimeSpan(12, 34, 56, 23, 45), "G", commaSeparatorInfo, "13:10:56:23,0450000" }; + yield return new object[] { new TimeSpan(0, 23, 59, 59, 999), "G", commaSeparatorInfo, "0:23:59:59,9990000" }; + } } [Theory] diff --git a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs index 547bb80458978..dc0650c285df7 100644 --- a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs +++ b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs @@ -1805,6 +1805,7 @@ public static void NewfoundlandTimeZone(string dateTimeString, bool expectedDST, } [Fact] + [ActiveIssue("https://github.com/dotnet/runtime/issues/39342", TestPlatforms.Browser)] public static void GetSystemTimeZones() { ReadOnlyCollection timeZones = TimeZoneInfo.GetSystemTimeZones(); diff --git a/src/libraries/System.Runtime/tests/System/TupleTests.cs b/src/libraries/System.Runtime/tests/System/TupleTests.cs index 62f7c2cedcb6a..f27a39ff49377 100644 --- a/src/libraries/System.Runtime/tests/System/TupleTests.cs +++ b/src/libraries/System.Runtime/tests/System/TupleTests.cs @@ -428,7 +428,7 @@ public static void CompareTo() tupleDriverB = new TupleTestDriver, TimeSpan>((short)1, (int)1, long.MinValue, "This"); tupleDriverC = new TupleTestDriver, TimeSpan>((short)1, (int)1, long.MinValue, "this"); tupleDriverA.CompareTo(tupleDriverB, 0, 5); - tupleDriverA.CompareTo(tupleDriverC, 1, 5); + tupleDriverA.CompareTo(tupleDriverC, PlatformDetection.IsInvariantGlobalization ? /* 'T'-'t' */ -32 : 1, 5); //Tuple-5 tupleDriverA = new TupleTestDriver, TimeSpan>((short)(-1), (int)(-1), (long)0, "is", 'A'); tupleDriverB = new TupleTestDriver, TimeSpan>((short)(-1), (int)(-1), (long)0, "is", 'A'); diff --git a/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs b/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs index 7190397886121..9255f0b42e86e 100644 --- a/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs +++ b/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs @@ -1234,9 +1234,12 @@ public static IEnumerable Create_String_Invalid_TestData() yield return new object[] { "uri://a:2147483648", UriKind.Absolute }; yield return new object[] { "uri://a:80:80", UriKind.Absolute }; - // Invalid unicode - yield return new object[] { "http://\uD800", UriKind.Absolute }; - yield return new object[] { "http://\uDC00", UriKind.Absolute }; + if (PlatformDetection.IsNotInvariantGlobalization) + { + // Invalid unicode + yield return new object[] { "http://\uD800", UriKind.Absolute }; + yield return new object[] { "http://\uDC00", UriKind.Absolute }; + } } [Theory] diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj index cd95d22064a06..6992c70d9f7ad 100644 --- a/src/libraries/tests.proj +++ b/src/libraries/tests.proj @@ -52,7 +52,6 @@ - From 219ac1d209f00cfe28b8da03a2654c4ef36f6dbb Mon Sep 17 00:00:00 2001 From: Santiago Fernandez Madero Date: Thu, 16 Jul 2020 16:35:54 -0700 Subject: [PATCH 2/2] Disable System.Runtime tests that use binary formatter on wasm --- src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs | 2 +- .../tests/System/UnitySerializationHolderTests.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs index dc0650c285df7..f7de159162633 100644 --- a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs +++ b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs @@ -2165,7 +2165,7 @@ public static void ToSerializedString_FromSerializedString_RoundTrips(TimeZoneIn Assert.Equal(serialized, deserializedTimeZone.ToSerializedString()); } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsBinaryFormatterSupported))] [MemberData(nameof(SystemTimeZonesTestData))] public static void BinaryFormatter_RoundTrips(TimeZoneInfo timeZone) { diff --git a/src/libraries/System.Runtime/tests/System/UnitySerializationHolderTests.cs b/src/libraries/System.Runtime/tests/System/UnitySerializationHolderTests.cs index 67b6b11f39359..ca8cab3a11742 100644 --- a/src/libraries/System.Runtime/tests/System/UnitySerializationHolderTests.cs +++ b/src/libraries/System.Runtime/tests/System/UnitySerializationHolderTests.cs @@ -9,7 +9,7 @@ namespace System.Tests { public class UnitySerializationHolderTests { - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsBinaryFormatterSupported))] public void UnitySerializationHolderWithAssemblySingleton() { const string UnitySerializationHolderAssemblyBase64String = "AAEAAAD/////AQAAAAAAAAAEAQAAAB9TeXN0ZW0uVW5pdHlTZXJpYWxpemF0aW9uSG9sZGVyAwAAAAREYXRhCVVuaXR5VHlwZQxBc3NlbWJseU5hbWUBAAEIBgIAAABLbXNjb3JsaWIsIFZlcnNpb249NC4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5BgAAAAkCAAAACw==";