[mono][xunit tests] Move skipped tests out of rsp file

src/libraries/System.Utf8String.Experimental/tests/System/Char8Tests.cs

@@ -7,6 +7,7 @@
 
 namespace System.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public unsafe partial class Char8Tests
     {
         [Theory]

src/libraries/System.Utf8String.Experimental/tests/System/MemoryTests.cs

@@ -11,6 +11,7 @@
 
 namespace System.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public partial class MemoryTests
     {
         [Fact]

src/libraries/System.Utf8String.Experimental/tests/System/Net/Http/Utf8StringContentTests.cs

@@ -11,6 +11,7 @@
 
 namespace System.Net.Http.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public partial class Utf8StringContentTests
     {
         [Fact]

src/libraries/System.Utf8String.Experimental/tests/System/ReflectionTests.cs

@@ -9,6 +9,7 @@
 
 namespace System.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public partial class ReflectionTests
     {
         [Fact]

src/libraries/System.Utf8String.Experimental/tests/System/Utf8ExtensionsTests.cs

@@ -11,6 +11,7 @@
 
 namespace System.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public partial class Utf8ExtensionsTests
     {
         [Fact]

src/libraries/System.Utf8String.Experimental/tests/System/Utf8SpanTests.cs

@@ -16,6 +16,7 @@
 
 namespace System.Text.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public unsafe partial class Utf8SpanTests
     {
         [Fact]

src/libraries/System.Utf8String.Experimental/tests/System/Utf8StringTests.cs

@@ -10,6 +10,7 @@
 
 namespace System.Tests
 {
+    [SkipOnMono("The features from System.Utf8String.Experimental namespace are experimental.")]
     public unsafe partial class Utf8StringTests
     {
         [Fact]

src/mono/netcore/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -176,6 +176,7 @@
       <Compile Include="$(BclSourcesRoot)\System\TypedReference.cs" />
       <Compile Include="$(BclSourcesRoot)\System\TypeLoadException.Mono.cs" />
       <Compile Include="$(BclSourcesRoot)\System\TypeNameParser.cs" />
+      <Compile Include="$(BclSourcesRoot)\System\Utf8String.cs" />
       <Compile Include="$(BclSourcesRoot)\System\ValueType.cs" />
       <Compile Include="$(BclSourcesRoot)\System\WeakReference.Mono.cs" />
       <Compile Include="$(BclSourcesRoot)\System\WeakReference.T.Mono.cs" />
@@ -252,6 +253,7 @@
       <Compile Include="$(BclSourcesRoot)\System\Runtime\Loader\AssemblyLoadContext.Mono.cs" />
       <Compile Include="$(BclSourcesRoot)\System\Runtime\Remoting\Contexts\Context.cs" />
       <Compile Include="$(BclSourcesRoot)\System\Security\DynamicSecurityMethodAttribute.cs" />
+      <Compile Include="$(BclSourcesRoot)\System\Text\Utf8Span.cs" />
       <Compile Include="$(BclSourcesRoot)\System\Threading\Interlocked.Mono.cs" />
       <Compile Include="$(BclSourcesRoot)\System\Threading\Monitor.cs" />
       <Compile Include="$(BclSourcesRoot)\System\Threading\Overlapped.cs" />

src/mono/netcore/System.Private.CoreLib/src/System/Text/Utf8Span.cs

@@ -0,0 +1,118 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text.Unicode;
+using Internal.Runtime.CompilerServices;
+
+#pragma warning disable 0809  //warning CS0809: Obsolete member 'Utf8Span.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
+
+#pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
+#if TARGET_64BIT
+using nint = System.Int64;
+using nuint = System.UInt64;
+#else
+using nint = System.Int32;
+using nuint = System.UInt32;
+#endif
+
+namespace System.Text
+{
+    [StructLayout(LayoutKind.Auto)]
+    public readonly ref partial struct Utf8Span
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Utf8Span(Utf8String? value)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public ReadOnlySpan<byte> Bytes { get; }
+
+        public static Utf8Span Empty => default;
+
+        public bool IsEmpty => throw new PlatformNotSupportedException();
+
+        public int Length => throw new PlatformNotSupportedException();
+
+        public Utf8Span this[Range range]
+        {
+            get
+            {
+                throw new PlatformNotSupportedException();
+            }
+        }
+
+        public bool IsEmptyOrWhiteSpace() => throw new PlatformNotSupportedException();
+
+        [Obsolete("Equals(object) on Utf8Span will always throw an exception. Use Equals(Utf8Span) or operator == instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object? obj)
+        {
+            throw new NotSupportedException(SR.Utf8Span_CannotCallEqualsObject);
+        }
+
+        public bool Equals(Utf8Span other) => throw new PlatformNotSupportedException();
+
+        public bool Equals(Utf8Span other, StringComparison comparison) => throw new PlatformNotSupportedException();
+
+        public static bool Equals(Utf8Span left, Utf8Span right) => throw new PlatformNotSupportedException();
+
+        public static bool Equals(Utf8Span left, Utf8Span right, StringComparison comparison)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public override int GetHashCode()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public int GetHashCode(StringComparison comparison)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public bool IsAscii()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public bool IsNormalized(NormalizationForm normalizationForm = NormalizationForm.FormC)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public ref readonly byte GetPinnableReference()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public override string ToString()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        internal unsafe string ToStringNoReplacement()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public Utf8String ToUtf8String()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Utf8Span UnsafeCreateWithoutValidation(ReadOnlySpan<byte> buffer)
+        {
+            throw new PlatformNotSupportedException();
+        }
+    }
+}

src/mono/netcore/System.Private.CoreLib/src/System/Utf8String.cs

@@ -0,0 +1,112 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Unicode;
+using Internal.Runtime.CompilerServices;
+
+#pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
+#if TARGET_64BIT
+using nint = System.Int64;
+using nuint = System.UInt64;
+#else
+using nint = System.Int32;
+using nuint = System.UInt32;
+#endif
+
+namespace System
+{
+    /// <summary>
+    /// Represents an immutable string of UTF-8 code units.
+    /// </summary>
+    public sealed partial class Utf8String : IComparable<Utf8String?>, IEquatable<Utf8String?>
+    {
+        public static readonly Utf8String Empty;
+        public static bool operator ==(Utf8String? left, Utf8String? right) => throw new PlatformNotSupportedException();
+        public static bool operator !=(Utf8String? left, Utf8String? right) => throw new PlatformNotSupportedException();
+        public static implicit operator Utf8Span(Utf8String? value) => throw new PlatformNotSupportedException();
+
+        public int Length => throw new PlatformNotSupportedException();
+        public Utf8String this[Range range]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                throw new PlatformNotSupportedException();
+            }
+        }
+
+        public int CompareTo(Utf8String? other)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public int CompareTo(Utf8String? other, StringComparison comparison)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public override bool Equals(object? obj)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public bool Equals(Utf8String? value)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public bool Equals(Utf8String? value, StringComparison comparison) => throw new PlatformNotSupportedException();
+
+        public static bool Equals(Utf8String? left, Utf8String? right)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public static bool Equals(Utf8String? a, Utf8String? b, StringComparison comparison)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public override int GetHashCode()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public int GetHashCode(StringComparison comparison)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)] // for compiler use only
+        public ref readonly byte GetPinnableReference() => throw new PlatformNotSupportedException();
+
+        public bool IsAscii()
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public static bool IsNullOrEmpty([NotNullWhen(false)] Utf8String? value)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public static bool IsNullOrWhiteSpace([NotNullWhen(false)] Utf8String? value)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
+        public byte[] ToByteArray() => throw new PlatformNotSupportedException();
+
+        public override string ToString()
+        {
+            throw new PlatformNotSupportedException();
+        }
+    }
+}