diff --git a/eng/illink.targets b/eng/illink.targets
index f255f7f2df8120..601b0b798fbca7 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 547e4fd249c06f..74ceefc4cc6a40 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 8a92b10e7a606c..05e07447a96164 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 29baaf32646f7e..e194f4db7e0437 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 cb8fb0394c3be9..c8a14438e38e02 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 950a2860ed32f2..940704fa9a0442 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 b7951f37872507..09aacebf83d097 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 885e17992c1768..ee28dd51c2e374 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 c2bb2bdc48cd14..c3242a0197cf83 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 c9e8789008e5b2..dabb22f2027ce9 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 296cc923173f9d..f538d8cccd3294 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 547bb804589782..f7de159162633c 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();
@@ -2164,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/TupleTests.cs b/src/libraries/System.Runtime/tests/System/TupleTests.cs
index 62f7c2cedcb6ac..f27a39ff493777 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/UnitySerializationHolderTests.cs b/src/libraries/System.Runtime/tests/System/UnitySerializationHolderTests.cs
index 67b6b11f39359b..ca8cab3a11742b 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==";
diff --git a/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs b/src/libraries/System.Runtime/tests/System/Uri.CreateStringTests.cs
index 7190397886121f..9255f0b42e86e4 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 cd95d22064a066..6992c70d9f7ade 100644
--- a/src/libraries/tests.proj
+++ b/src/libraries/tests.proj
@@ -52,7 +52,6 @@
-