From 96535f95e1e259aae2f60711d1e95ab54a2670ed Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Wed, 12 Mar 2025 00:36:38 +0000
Subject: [PATCH 1/2] Add InlineArrayX types

Closes https://github.com/dotnet/runtime/issues/111973. Implements the API as proposed.
---
 .../System.Private.CoreLib.Shared.projitems   |   3 +-
 .../Runtime/CompilerServices/InlineArray.cs   |  76 +++++++
 .../System.Runtime/ref/System.Runtime.cs      |  70 ++++++
 .../CompilerServices/InlineArrayTests.cs      | 201 ++++++++++++++++++
 4 files changed, 349 insertions(+), 1 deletion(-)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
 create mode 100644 src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs

diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index ffe8e7daaba2be..20d08a75ce8526 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -857,6 +857,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\InternalsVisibleToAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\IntrinsicAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\IsByRefLikeAttribute.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\InlineArray.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\InlineArrayAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\IsConst.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\IsExternalInit.cs" />
@@ -2790,4 +2791,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Wasi\WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Wasi\WasiPollWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
new file mode 100644
index 00000000000000..6d333d71b36a8f
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Runtime.CompilerServices
+{
+    [InlineArray(2)]
+    public struct InlineArray2<T>
+    {
+        private T t;
+    }
+    [InlineArray(3)]
+    public struct InlineArray3<T>
+    {
+        private T t;
+    }
+    [InlineArray(4)]
+    public struct InlineArray4<T>
+    {
+        private T t;
+    }
+    [InlineArray(5)]
+    public struct InlineArray5<T>
+    {
+        private T t;
+    }
+    [InlineArray(6)]
+    public struct InlineArray6<T>
+    {
+        private T t;
+    }
+    [InlineArray(7)]
+    public struct InlineArray7<T>
+    {
+        private T t;
+    }
+    [InlineArray(8)]
+    public struct InlineArray8<T>
+    {
+        private T t;
+    }
+    [InlineArray(9)]
+    public struct InlineArray9<T>
+    {
+        private T t;
+    }
+    [InlineArray(10)]
+    public struct InlineArray10<T>
+    {
+        private T t;
+    }
+    [InlineArray(11)]
+    public struct InlineArray11<T>
+    {
+        private T t;
+    }
+    [InlineArray(12)]
+    public struct InlineArray12<T>
+    {
+        private T t;
+    }
+    [InlineArray(13)]
+    public struct InlineArray13<T>
+    {
+        private T t;
+    }
+    [InlineArray(14)]
+    public struct InlineArray14<T>
+    {
+        private T t;
+    }
+    [InlineArray(15)]
+    public struct InlineArray15<T>
+    {
+        private T t;
+    }
+}
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 7cd48689e6f5b9..06e0b273b1e2c5 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -13490,6 +13490,76 @@ public sealed partial class IndexerNameAttribute : System.Attribute
     {
         public IndexerNameAttribute(string indexerName) { }
     }
+    [InlineArray(2)]
+    public struct InlineArray2<T>
+    {
+        private T t;
+    }
+    [InlineArray(3)]
+    public struct InlineArray3<T>
+    {
+        private T t;
+    }
+    [InlineArray(4)]
+    public struct InlineArray4<T>
+    {
+        private T t;
+    }
+    [InlineArray(5)]
+    public struct InlineArray5<T>
+    {
+        private T t;
+    }
+    [InlineArray(6)]
+    public struct InlineArray6<T>
+    {
+        private T t;
+    }
+    [InlineArray(7)]
+    public struct InlineArray7<T>
+    {
+        private T t;
+    }
+    [InlineArray(8)]
+    public struct InlineArray8<T>
+    {
+        private T t;
+    }
+    [InlineArray(9)]
+    public struct InlineArray9<T>
+    {
+        private T t;
+    }
+    [InlineArray(10)]
+    public struct InlineArray10<T>
+    {
+        private T t;
+    }
+    [InlineArray(11)]
+    public struct InlineArray11<T>
+    {
+        private T t;
+    }
+    [InlineArray(12)]
+    public struct InlineArray12<T>
+    {
+        private T t;
+    }
+    [InlineArray(13)]
+    public struct InlineArray13<T>
+    {
+        private T t;
+    }
+    [InlineArray(14)]
+    public struct InlineArray14<T>
+    {
+        private T t;
+    }
+    [InlineArray(15)]
+    public struct InlineArray15<T>
+    {
+        private T t;
+    }
     [System.AttributeUsageAttribute(System.AttributeTargets.Struct, AllowMultiple=false)]
     public sealed partial class InlineArrayAttribute : System.Attribute
     {
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs
new file mode 100644
index 00000000000000..f17c1d1da16d9c
--- /dev/null
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs
@@ -0,0 +1,201 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection;
+using Xunit;
+
+namespace System.Runtime.CompilerServices.Tests
+{
+    public static class InlineArrayTests
+    {
+        [Fact]
+        public void InlineArray2Test()
+        {
+            InlineArray2<int> inlineArray2 = new InlineArray2<int>();
+            inlineArray2[0] = 1;
+            inlineArray2[1] = 2;
+            Assert.Equal(1, inlineArray2[0]);
+            Assert.Equal(2, inlineArray2[1]);
+        }
+
+        [Fact]
+        public void InlineArray3Test()
+        {
+            InlineArray3<int> inlineArray3 = new InlineArray3<int>();
+            inlineArray3[0] = 1;
+            inlineArray3[1] = 2;
+            inlineArray3[2] = 3;
+            Assert.Equal(1, inlineArray3[0]);
+            Assert.Equal(2, inlineArray3[1]);
+            Assert.Equal(3, inlineArray3[2]);
+        }
+
+        [Fact]
+        public void InlineArray4Test()
+        {
+            InlineArray4<int> inlineArray4 = new InlineArray4<int>();
+            for (int i = 0; i < 4; i++)
+            {
+                inlineArray4[i] = i + 1;
+            }
+            for (int i = 0; i < 4; i++)
+            {
+                Assert.Equal(i + 1, inlineArray4[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray5Test()
+        {
+            InlineArray5<int> inlineArray5 = new InlineArray5<int>();
+            for (int i = 0; i < 5; i++)
+            {
+                inlineArray5[i] = i + 1;
+            }
+            for (int i = 0; i < 5; i++)
+            {
+                Assert.Equal(i + 1, inlineArray5[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray6Test()
+        {
+            InlineArray6<int> inlineArray6 = new InlineArray6<int>();
+            for (int i = 0; i < 6; i++)
+            {
+                inlineArray6[i] = i + 1;
+            }
+            for (int i = 0; i < 6; i++)
+            {
+                Assert.Equal(i + 1, inlineArray6[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray7Test()
+        {
+            InlineArray7<int> inlineArray7 = new InlineArray7<int>();
+            for (int i = 0; i < 7; i++)
+            {
+                inlineArray7[i] = i + 1;
+            }
+            for (int i = 0; i < 7; i++)
+            {
+                Assert.Equal(i + 1, inlineArray7[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray8Test()
+        {
+            InlineArray8<int> inlineArray8 = new InlineArray8<int>();
+            for (int i = 0; i < 8; i++)
+            {
+                inlineArray8[i] = i + 1;
+            }
+            for (int i = 0; i < 8; i++)
+            {
+                Assert.Equal(i + 1, inlineArray8[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray9Test()
+        {
+            InlineArray9<int> inlineArray9 = new InlineArray9<int>();
+            for (int i = 0; i < 9; i++)
+            {
+                inlineArray9[i] = i + 1;
+            }
+            for (int i = 0; i < 9; i++)
+            {
+                Assert.Equal(i + 1, inlineArray9[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray10Test()
+        {
+            InlineArray10<int> inlineArray10 = new InlineArray10<int>();
+            for (int i = 0; i < 10; i++)
+            {
+                inlineArray10[i] = i + 1;
+            }
+            for (int i = 0; i < 10; i++)
+            {
+                Assert.Equal(i + 1, inlineArray10[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray11Test()
+        {
+            InlineArray11<int> inlineArray11 = new InlineArray11<int>();
+            for (int i = 0; i < 11; i++)
+            {
+                inlineArray11[i] = i + 1;
+            }
+            for (int i = 0; i < 11; i++)
+            {
+                Assert.Equal(i + 1, inlineArray11[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray12Test()
+        {
+            InlineArray12<int> inlineArray12 = new InlineArray12<int>();
+            for (int i = 0; i < 12; i++)
+            {
+                inlineArray12[i] = i + 1;
+            }
+            for (int i = 0; i < 12; i++)
+            {
+                Assert.Equal(i + 1, inlineArray12[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray13Test()
+        {
+            InlineArray13<int> inlineArray13 = new InlineArray13<int>();
+            for (int i = 0; i < 13; i++)
+            {
+                inlineArray13[i] = i + 1;
+            }
+            for (int i = 0; i < 13; i++)
+            {
+                Assert.Equal(i + 1, inlineArray13[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray14Test()
+        {
+            InlineArray14<int> inlineArray14 = new InlineArray14<int>();
+            for (int i = 0; i < 14; i++)
+            {
+                inlineArray14[i] = i + 1;
+            }
+            for (int i = 0; i < 14; i++)
+            {
+                Assert.Equal(i + 1, inlineArray14[i]);
+            }
+        }
+
+        [Fact]
+        public void InlineArray15Test()
+        {
+            InlineArray15<int> inlineArray15 = new InlineArray15<int>();
+            for (int i = 0; i < 15; i++)
+            {
+                inlineArray15[i] = i + 1;
+            }
+            for (int i = 0; i < 15; i++)
+            {
+                Assert.Equal(i + 1, inlineArray15[i]);
+            }
+        }
+    }
+}

From e2ef692b0eff69790ab2bd8d6e6ce140ab095a9e Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Wed, 12 Mar 2025 01:19:11 +0000
Subject: [PATCH 2/2] PR feedback

---
 .../Runtime/CompilerServices/InlineArray.cs   |  69 ++++++++
 .../System.Runtime/ref/System.Runtime.cs      |  28 +--
 .../CompilerServices/InlineArrayTests.cs      | 163 +++++-------------
 3 files changed, 126 insertions(+), 134 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
index 6d333d71b36a8f..96c4d104b61558 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/InlineArray.cs
@@ -3,71 +3,140 @@
 
 namespace System.Runtime.CompilerServices
 {
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 2.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(2)]
     public struct InlineArray2<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 3.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(3)]
     public struct InlineArray3<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 4.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(4)]
     public struct InlineArray4<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 5.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(5)]
     public struct InlineArray5<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 6.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(6)]
     public struct InlineArray6<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 7.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(7)]
     public struct InlineArray7<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 8.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(8)]
     public struct InlineArray8<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 9.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(9)]
     public struct InlineArray9<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 10.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(10)]
     public struct InlineArray10<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 11.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(11)]
     public struct InlineArray11<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 12.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(12)]
     public struct InlineArray12<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 13.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(13)]
     public struct InlineArray13<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 14.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(14)]
     public struct InlineArray14<T>
     {
         private T t;
     }
+
+    /// <summary>
+    /// Represents an inline array of <typeparamref name="T"/> with a fixed length of 15.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the array.</typeparam>
     [InlineArray(15)]
     public struct InlineArray15<T>
     {
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 06e0b273b1e2c5..aaff8b1c5cb654 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -13490,72 +13490,72 @@ public sealed partial class IndexerNameAttribute : System.Attribute
     {
         public IndexerNameAttribute(string indexerName) { }
     }
-    [InlineArray(2)]
+    [System.Runtime.CompilerServices.InlineArray(2)]
     public struct InlineArray2<T>
     {
         private T t;
     }
-    [InlineArray(3)]
+    [System.Runtime.CompilerServices.InlineArray(3)]
     public struct InlineArray3<T>
     {
         private T t;
     }
-    [InlineArray(4)]
+    [System.Runtime.CompilerServices.InlineArray(4)]
     public struct InlineArray4<T>
     {
         private T t;
     }
-    [InlineArray(5)]
+    [System.Runtime.CompilerServices.InlineArray(5)]
     public struct InlineArray5<T>
     {
         private T t;
     }
-    [InlineArray(6)]
+    [System.Runtime.CompilerServices.InlineArray(6)]
     public struct InlineArray6<T>
     {
         private T t;
     }
-    [InlineArray(7)]
+    [System.Runtime.CompilerServices.InlineArray(7)]
     public struct InlineArray7<T>
     {
         private T t;
     }
-    [InlineArray(8)]
+    [System.Runtime.CompilerServices.InlineArray(8)]
     public struct InlineArray8<T>
     {
         private T t;
     }
-    [InlineArray(9)]
+    [System.Runtime.CompilerServices.InlineArray(9)]
     public struct InlineArray9<T>
     {
         private T t;
     }
-    [InlineArray(10)]
+    [System.Runtime.CompilerServices.InlineArray(10)]
     public struct InlineArray10<T>
     {
         private T t;
     }
-    [InlineArray(11)]
+    [System.Runtime.CompilerServices.InlineArray(11)]
     public struct InlineArray11<T>
     {
         private T t;
     }
-    [InlineArray(12)]
+    [System.Runtime.CompilerServices.InlineArray(12)]
     public struct InlineArray12<T>
     {
         private T t;
     }
-    [InlineArray(13)]
+    [System.Runtime.CompilerServices.InlineArray(13)]
     public struct InlineArray13<T>
     {
         private T t;
     }
-    [InlineArray(14)]
+    [System.Runtime.CompilerServices.InlineArray(14)]
     public struct InlineArray14<T>
     {
         private T t;
     }
-    [InlineArray(15)]
+    [System.Runtime.CompilerServices.InlineArray(15)]
     public struct InlineArray15<T>
     {
         private T t;
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs
index f17c1d1da16d9c..ed1489fa4bc33d 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/InlineArrayTests.cs
@@ -8,194 +8,117 @@ namespace System.Runtime.CompilerServices.Tests
 {
     public static class InlineArrayTests
     {
+        private static void WriteRead(Span<int> span, int expectedLength)
+        {
+            Assert.Equal(expectedLength, span.Length);
+
+            for (int i = 0; i < span.Length; i++)
+            {
+                span[i] = i + 1;
+            }
+
+            for (int i = 0; i < span.Length; i++)
+            {
+                Assert.Equal(i + 1, span[i]);
+            }
+        }
+
         [Fact]
         public void InlineArray2Test()
         {
-            InlineArray2<int> inlineArray2 = new InlineArray2<int>();
-            inlineArray2[0] = 1;
-            inlineArray2[1] = 2;
-            Assert.Equal(1, inlineArray2[0]);
-            Assert.Equal(2, inlineArray2[1]);
+            InlineArray2<int> inlineArray2 = new();
+            WriteRead(inlineArray2, 2);
         }
 
         [Fact]
         public void InlineArray3Test()
         {
-            InlineArray3<int> inlineArray3 = new InlineArray3<int>();
-            inlineArray3[0] = 1;
-            inlineArray3[1] = 2;
-            inlineArray3[2] = 3;
-            Assert.Equal(1, inlineArray3[0]);
-            Assert.Equal(2, inlineArray3[1]);
-            Assert.Equal(3, inlineArray3[2]);
+            InlineArray3<int> inlineArray3 = new();
+            WriteRead(inlineArray3, 3);
         }
 
         [Fact]
         public void InlineArray4Test()
         {
-            InlineArray4<int> inlineArray4 = new InlineArray4<int>();
-            for (int i = 0; i < 4; i++)
-            {
-                inlineArray4[i] = i + 1;
-            }
-            for (int i = 0; i < 4; i++)
-            {
-                Assert.Equal(i + 1, inlineArray4[i]);
-            }
+            InlineArray4<int> inlineArray4 = new();
+            WriteRead(inlineArray4, 4);
         }
 
         [Fact]
         public void InlineArray5Test()
         {
-            InlineArray5<int> inlineArray5 = new InlineArray5<int>();
-            for (int i = 0; i < 5; i++)
-            {
-                inlineArray5[i] = i + 1;
-            }
-            for (int i = 0; i < 5; i++)
-            {
-                Assert.Equal(i + 1, inlineArray5[i]);
-            }
+            InlineArray5<int> inlineArray5 = new();
+            WriteRead(inlineArray5, 5);
         }
 
         [Fact]
         public void InlineArray6Test()
         {
-            InlineArray6<int> inlineArray6 = new InlineArray6<int>();
-            for (int i = 0; i < 6; i++)
-            {
-                inlineArray6[i] = i + 1;
-            }
-            for (int i = 0; i < 6; i++)
-            {
-                Assert.Equal(i + 1, inlineArray6[i]);
-            }
+            InlineArray6<int> inlineArray6 = new();
+            WriteRead(inlineArray6, 6);
         }
 
         [Fact]
         public void InlineArray7Test()
         {
-            InlineArray7<int> inlineArray7 = new InlineArray7<int>();
-            for (int i = 0; i < 7; i++)
-            {
-                inlineArray7[i] = i + 1;
-            }
-            for (int i = 0; i < 7; i++)
-            {
-                Assert.Equal(i + 1, inlineArray7[i]);
-            }
+            InlineArray7<int> inlineArray7 = new();
+            WriteRead(inlineArray7, 7);
         }
 
         [Fact]
         public void InlineArray8Test()
         {
-            InlineArray8<int> inlineArray8 = new InlineArray8<int>();
-            for (int i = 0; i < 8; i++)
-            {
-                inlineArray8[i] = i + 1;
-            }
-            for (int i = 0; i < 8; i++)
-            {
-                Assert.Equal(i + 1, inlineArray8[i]);
-            }
+            InlineArray8<int> inlineArray8 = new();
+            WriteRead(inlineArray8, 8);
         }
 
         [Fact]
         public void InlineArray9Test()
         {
-            InlineArray9<int> inlineArray9 = new InlineArray9<int>();
-            for (int i = 0; i < 9; i++)
-            {
-                inlineArray9[i] = i + 1;
-            }
-            for (int i = 0; i < 9; i++)
-            {
-                Assert.Equal(i + 1, inlineArray9[i]);
-            }
+            InlineArray9<int> inlineArray9 = new();
+            WriteRead(inlineArray9, 9);
         }
 
         [Fact]
         public void InlineArray10Test()
         {
-            InlineArray10<int> inlineArray10 = new InlineArray10<int>();
-            for (int i = 0; i < 10; i++)
-            {
-                inlineArray10[i] = i + 1;
-            }
-            for (int i = 0; i < 10; i++)
-            {
-                Assert.Equal(i + 1, inlineArray10[i]);
-            }
+            InlineArray10<int> inlineArray10 = new();
+            WriteRead(inlineArray10, 10);
         }
 
         [Fact]
         public void InlineArray11Test()
         {
-            InlineArray11<int> inlineArray11 = new InlineArray11<int>();
-            for (int i = 0; i < 11; i++)
-            {
-                inlineArray11[i] = i + 1;
-            }
-            for (int i = 0; i < 11; i++)
-            {
-                Assert.Equal(i + 1, inlineArray11[i]);
-            }
+            InlineArray11<int> inlineArray11 = new();
+            WriteRead(inlineArray11, 11);
         }
 
         [Fact]
         public void InlineArray12Test()
         {
-            InlineArray12<int> inlineArray12 = new InlineArray12<int>();
-            for (int i = 0; i < 12; i++)
-            {
-                inlineArray12[i] = i + 1;
-            }
-            for (int i = 0; i < 12; i++)
-            {
-                Assert.Equal(i + 1, inlineArray12[i]);
-            }
+            InlineArray12<int> inlineArray12 = new();
+            WriteRead(inlineArray12, 12);
         }
 
         [Fact]
         public void InlineArray13Test()
         {
-            InlineArray13<int> inlineArray13 = new InlineArray13<int>();
-            for (int i = 0; i < 13; i++)
-            {
-                inlineArray13[i] = i + 1;
-            }
-            for (int i = 0; i < 13; i++)
-            {
-                Assert.Equal(i + 1, inlineArray13[i]);
-            }
+            InlineArray13<int> inlineArray13 = new();
+            WriteRead(inlineArray13, 13);
         }
 
         [Fact]
         public void InlineArray14Test()
         {
-            InlineArray14<int> inlineArray14 = new InlineArray14<int>();
-            for (int i = 0; i < 14; i++)
-            {
-                inlineArray14[i] = i + 1;
-            }
-            for (int i = 0; i < 14; i++)
-            {
-                Assert.Equal(i + 1, inlineArray14[i]);
-            }
+            InlineArray14<int> inlineArray14 = new();
+            WriteRead(inlineArray14, 14);
         }
 
         [Fact]
         public void InlineArray15Test()
         {
-            InlineArray15<int> inlineArray15 = new InlineArray15<int>();
-            for (int i = 0; i < 15; i++)
-            {
-                inlineArray15[i] = i + 1;
-            }
-            for (int i = 0; i < 15; i++)
-            {
-                Assert.Equal(i + 1, inlineArray15[i]);
-            }
+            InlineArray15<int> inlineArray15 = new();
+            WriteRead(inlineArray15, 15);
         }
     }
 }