src/libraries/Common/tests/ComplianceTests/GB18030/Tests/StringTests.cs:13

• [nitpick] The constant name 'Dummy' is ambiguous and doesn't clearly indicate its purpose as a replacement character for testing. Consider renaming to 'ReplacementChar' or 'TestReplacementCharacter'.

    private const string Dummy = "\uFFFF";

src/libraries/Common/tests/ComplianceTests/GB18030/TestHelper.cs:127

• The path-segment splitting logic can yield segments that still exceed MaxPathSegmentName. The check runs before appending the next text element, so it only detects overflow one iteration late and can add an already-too-long segment to the results, potentially causing path-related tests to fail on some inputs/filesystems.

                if (fileSystemEncoding.GetByteCount(current) > MaxPathSegmentName)
                {
                    result.Add(current);
                    current = string.Empty;
                }

src/libraries/Common/tests/ComplianceTests/GB18030/Tests/StringTests.cs:51

• This test uses string.Contains(string, StringComparison), which isn't available when compiling for the .NET Framework target in this multi-targeted test project. The [SkipOnTargetFramework] attribute doesn't prevent compilation. Consider compiling this test only for NETCOREAPP.

    public static IEnumerable<object[]> Contains_MemberData() =>
        TestHelper.DecodedTestData.SelectMany(testData =>
        TestHelper.NonOrdinalStringComparisons.Select(comparison => new object[] { testData, comparison  }));

    [Theory]
    [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
    [MemberData(nameof(Contains_MemberData))]
    public void Contains(string decoded, StringComparison comparison)

src/libraries/Common/tests/ComplianceTests/GB18030/TestHelper.cs:145

• NonExceedingPathNameMaxDecodedTestData only splits after current is already over the byte limit. That can yield path segments longer than MaxPathSegmentName (the check should consider the next element before appending).

            foreach (string element in GetTextElements(data))
            {
                if (fileSystemEncoding.GetByteCount(current) > MaxPathSegmentName)
                {
                    result.Add(current);
                    current = string.Empty;
                }
                current += element;
            }
            result.Add(current);

src/libraries/Common/tests/ComplianceTests/GB18030/TestHelper.cs:140

• The path segment splitting logic checks GetByteCount(current) > MaxPathSegmentName before appending the next text element, which can yield segments that exceed the max (and can also add an empty segment when the first element pushes it over). It should check whether adding the next element would exceed the limit, then flush the current segment before appending.

            foreach (string element in GetTextElements(data))
            {
                if (fileSystemEncoding.GetByteCount(current) > MaxPathSegmentName)
                {
                    result.Add(current);

src/libraries/Common/tests/ComplianceTests/GB18030/Tests/DirectoryTestBase.cs:48

• Path.Combine(Enumerable.Repeat(...).ToArray()) can produce string.Empty (or potentially throw on older implementations) when recurseLevel is 0, making this behavior depend on framework details. Since the test explicitly asserts the 0-level case equals firstPath, build the nested path deterministically without relying on Path.Combine with an empty array.

    {
        string firstPath = Path.Combine(TempDirectory.FullName, gb18030Line);
        string nestedDirPath = Path.Combine(firstPath, Path.Combine(Enumerable.Repeat(gb18030Line, recurseLevel).ToArray()));
        Assert.True(recurseLevel > 0 || firstPath.Equals(nestedDirPath));

src/libraries/Common/tests/ComplianceTests/GB18030/Tests/StringTests.cs:24

• The fixed (sbyte* p = (sbyte[])(object)encoded) cast will throw InvalidCastException at runtime (a byte[] can't be cast to sbyte[]). You can pin the byte[] and cast the pointer to sbyte* for the string(sbyte*, ...) constructor.

    public unsafe void Ctor(byte[] encoded)
    {
        fixed (sbyte* p = (sbyte[])(object)encoded)
        {
            string s = new string(p, 0, encoded.Length, TestHelper.GB18030Encoding);

src/libraries/Common/tests/ComplianceTests/GB18030/TestHelper.cs:142

• This logic can emit path segments that exceed MaxPathSegmentName: the byte-count check happens before appending the next text element, so current can grow beyond the limit and only be split on the following iteration (after it's already too large). This can make the filesystem tests fail when creating a segment longer than the intended cap.

            foreach (string element in GetTextElements(data))
            {
                if (fileSystemEncoding.GetByteCount(current) > MaxPathSegmentName)
                {
                    result.Add(current);

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/RegexGeneratorHelper.netcoreapp.cs:50

• Using the null-forgiving operator here will turn a missing directory name into a later ArgumentNullException/NullReferenceException without context. Since this is test infrastructure, it's better to throw an explicit exception if the directory can't be determined.

                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
                MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(corelibPath)!, "System.Runtime.dll")),
                MetadataReference.CreateFromFile(typeof(Unsafe).Assembly.Location),

src/libraries/System.Runtime/tests/System.Globalization.Tests/System/Globalization/CharUnicodeInfoTestData.cs:17

• The null-forgiving operator will cause a later null deref if the embedded resource name changes or isn't embedded correctly. Throwing a descriptive exception here makes failures much easier to diagnose.

            string fileName = "UnicodeData.txt";
            Stream stream = typeof(CharUnicodeInfoTestData).GetTypeInfo().Assembly.GetManifestResourceStream(fileName)!;
            using (StreamReader reader = new StreamReader(stream))

src/libraries/Common/tests/ComplianceTests/GB18030/Tests/RegexTests.cs:89

• Minor formatting: missing space between the array type and parameter name (string[]characters) reduces readability and doesn't match typical style in nearby code.

    [MemberData(nameof(NamedBlock_MemberData))]
    public async Task NamedBlock_InclusionAsync(string[] characters, RegexNamedBlock namedBlock, RegexEngine engine, CultureInfo culture)
    {

src/libraries/Common/tests/ComplianceTests/GB18030/TestHelper.cs:148

• NonExceedingPathNameMaxDecodedTestData splitting is incorrect: it checks the byte count of the current segment after it already exceeded the limit, so it can emit path segments whose encoded byte length is > MaxPathSegmentName. That defeats the purpose of the helper and can still produce overlong path components on some platforms.

            List<string> result = new();
            string current = string.Empty;
            foreach (string element in GetTextElements(data))
            {
                if (fileSystemEncoding.GetByteCount(current) > MaxPathSegmentName)
                {
                    result.Add(current);
                    current = string.Empty;
                }
                current += element;
            }
            result.Add(current);
            return result;