Merge generics support in mscorlib

.github/.changelog-config.json

@@ -21,6 +21,13 @@
             ],
             "exhaustive": true
         },
+        {
+            "title": "## Unit Tests",
+            "labels": [
+                "Type: Unit Tests"
+            ],
+            "exhaustive": true
+        },
         {
             "title": "## ⚠️ Breaking Changes",
             "labels": [

.runsettings

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <RunSettings>
    <!-- Configurations that affect the Test Framework -->
    <RunConfiguration>
@@ -12,5 +12,6 @@
        <Logging>Verbose</Logging>
        <IsRealHardware>False</IsRealHardware>
 	   <RunnerExtraArguments> --forcegc </RunnerExtraArguments>
+       <UsePreviewClr>True</UsePreviewClr>
    </nanoFrameworkAdapter>
-</RunSettings>
+</RunSettings>

CLAUDE.md

@@ -0,0 +1,69 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+`.github/copilot-instructions.md` is the authoritative rulebook for this repo (build details, coding conventions, contribution rules). Read it whenever you need more than the summary below.
+
+## What this repo is
+
+The Base Class Library (BCL) for **.NET nanoFramework** — the `mscorlib` equivalent for embedded/MCU targets. This is **not** standard .NET: it targets `TargetFrameworkVersion v1.0` (the nanoFramework target), builds `.nfproj` projects, and pairs with a native C++ runtime.
+
+Two output NuGet packages, both producing an assembly named `mscorlib`:
+- `nanoFramework.CoreLibrary/` — full BCL including `System.Reflection`
+- `nanoFramework.CoreLibrary.NoReflection/` — reflection excluded for smaller flash footprint (same sources, minus `System/Reflection/`)
+
+When adding or removing files, decide whether the change also applies to the NoReflection variant and update its `.nfproj` accordingly. Reflection-only sources stay in the full project.
+
+## Native-interop constraints (read before editing methods)
+
+- Methods marked `[MethodImpl(MethodImplOptions.InternalCall)]` are **native stubs** — the implementation lives in the nanoFramework C++ interpreter. Never add a body. Changing signatures requires a coordinated change to the native runtime.
+- Some methods intentionally `throw new NotSupportedException();` (usually no message) to satisfy an interface contract while omitting the feature to save flash. This is by design — do not "fix" them.
+- Assembly size is a first-class concern. Avoid adding features that noticeably grow the binary; comment the rationale when omitting functionality.
+
+## Build & test
+
+Windows only. Requires Visual Studio 2022 with the nanoFramework VS extension (or MSBuild 17+ with `NFProjectSystem.CSharp.targets`). Linux CI cannot build this repo. CI is Azure Pipelines (`azure-pipelines.yml`), not GitHub Actions.
+
+```powershell
+nuget restore nanoFramework.CoreLibrary.sln
+msbuild nanoFramework.CoreLibrary.sln /p:Configuration=Release /p:Platform="Any CPU"
+```
+
+Tests run on the **nanoCLR Win32 emulator** via `vstest.console.exe` — `dotnet test` will not work. Run a single suite from a Developer Command Prompt:
+
+```powershell
+vstest.console.exe .\Tests\NFUnitTestBitConverter\bin\Release\NFUnitTest.dll /Settings:.\.runsettings /TestAdapterPath:.\nanoFramework.TestFramework\source\TestAdapter\bin\Debug\net4.8
+```
+
+Runsettings:
+- `.runsettings` — preview nanoCLR downloaded from NuGet (default)
+- `local_clr.runsettings` — locally-built nanoCLR
+
+Every test suite is its own `.nfproj` under `Tests/`. Tests reference `mscorlib`, `nanoFramework.TestFramework`, and `nanoFramework.UnitTestLauncher` **as project references** (via the `nanoFramework.TestFramework/` submodule), not as NuGet packages — this is mandatory because the CoreLibrary itself replaces `mscorlib`.
+
+New API surface requires test coverage for methods, properties, events, and thrown exceptions.
+
+## Repo layout landmarks
+
+- `nanoFramework.CoreLibrary/System/` — all `System.*` sources, subfoldered by sub-namespace (`Collections/`, `Diagnostics/`, `Globalization/`, `IO/`, `Reflection/`, `Runtime/`, `Threading/`, …)
+- `nanoFramework.CoreLibrary/Friends.cs` — `InternalsVisibleTo` declarations for test projects; add new ones here when they need access to internals
+- `nanoFramework.CoreLibrary/key.snk` — strong-name key; do not replace or remove
+- `nanoFramework.TestFramework/` — git submodule; test framework sources referenced by every test project
+- `version.json` — Nerdbank.GitVersioning; do not hand-edit version numbers
+- `.runsettings`, `local_clr.runsettings` — test runner configs (emulator, sequential execution, 20 min timeout)
+
+## Coding conventions (highlights)
+
+- File header on every `.cs`:
+  ```csharp
+  // Licensed to the .NET Foundation under one or more agreements.
+  // The .NET Foundation licenses this file to you under the MIT license.
+  ```
+- 4-space C# indent, CRLF, UTF-8 BOM, `using` outside namespace, System usings first, always braces.
+- Private/internal fields `_camelCase`; private/internal statics `s_camelCase`; constants and public members PascalCase.
+- Avoid `var` — use explicit types.
+- C# language version: 13.0 for the main project; `default` for the NoReflection variant.
+
+## Pipeline note
+
+`RestoreLockedMode` is on in CI. If a package version genuinely needs to change, regenerate and commit the corresponding `packages.lock.json`; do not bypass the lock.

Tests/NFUnitTestArithmetic/UnitTestFormat.cs

@@ -45,7 +45,14 @@ public void StringFormat_01()
         {
             // catch an exception if the format string is null
             string nullFormat = null;
-            Assert.ThrowsException(typeof(NullReferenceException), () => { string.Format(nullFormat, 12345.67); });
+            Assert.ThrowsException(typeof(ArgumentNullException), () => { string.Format(nullFormat, 12345.67); });
+        }
+
+        [TestMethod]
+        public void StringFormat_NullArgs()
+        {
+            // passing a null params array should throw ArgumentNullException
+            Assert.ThrowsException(typeof(ArgumentNullException), () => { string.Format("{0}", (object[])null); });
         }
 
         [TestMethod]

Tests/NFUnitTestClasses/NFUnitTestClasses.nfproj

@@ -38,6 +38,7 @@
     <Compile Include="UnitTestPropertiesTests.cs" />
     <Compile Include="UnitTestHashCodeTests.cs" />
     <Compile Include="UnitTestStaticTests.cs" />
+    <Compile Include="UnitTestGenericStaticTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\nanoFramework.CoreLibrary\CoreLibrary.nfproj" />

Tests/NFUnitTestClasses/UnitTestGenericStaticTests.cs

@@ -0,0 +1,229 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using nanoFramework.TestFramework;
+
+namespace NFUnitTestClasses
+{
+    [TestClass]
+    class UnitTestGenericStaticTests
+    {
+        [TestMethod]
+        public void Generic_StaticField_FirstTouch_Read()
+        {
+            // First interaction with this closed generic type is a static field read
+            // (CEE_LDSFLD), not a constructor call.
+            Assert.AreEqual(1, GenericWithStaticField<int>.InitCount);
+        }
+
+        [TestMethod]
+        public void Generic_StaticMethod_FirstTouch_Call()
+        {
+            // First interaction with this closed generic type is a static method
+            // call (CEE_CALL), not a constructor call.
+            Assert.IsTrue(GenericWithStaticMethod<long>.IsInitialized());
+        }
+
+        [TestMethod]
+        public void Generic_StaticField_NonGenericHolder()
+        {
+            BoxHolder.IntBox.Add(42);
+
+            Assert.AreEqual(1, BoxHolder.IntBox.Count);
+            Assert.AreEqual(42, BoxHolder.IntBox.Items[0]);
+
+            BoxHolder.StringBox.Add("hello");
+
+            Assert.AreEqual(1, BoxHolder.StringBox.Count);
+            Assert.AreEqual("hello", BoxHolder.StringBox.Items[0]);
+        }
+
+        [TestMethod]
+        public void Generic_StaticField_GenericHolder()
+        {
+            GenericBoxHolder<int>.Box.Add(99);
+
+            Assert.AreEqual(1, GenericBoxHolder<int>.Box.Count);
+            Assert.AreEqual(99, GenericBoxHolder<int>.Box.Items[0]);
+        }
+
+        [TestMethod]
+        public void Generic_StaticField_MultipleInstantiations()
+        {
+            Assert.AreEqual(1, GenericWithStaticField<byte>.InitCount);
+            Assert.AreEqual(1, GenericWithStaticField<string>.InitCount);
+        }
+
+        [TestMethod]
+        public void Generic_SingleParam_ValueType()
+        {
+            var container = new GenericContainer<int>(42);
+
+            Assert.AreEqual(42, container.GetValue());
+
+            container.SetValue(100);
+
+            Assert.AreEqual(100, container.GetValue());
+        }
+
+        [TestMethod]
+        public void Generic_SingleParam_ReferenceType()
+        {
+            var container = new GenericContainer<string>("hello");
+
+            Assert.AreEqual("hello", container.GetValue());
+        }
+
+        [TestMethod]
+        public void Generic_SingleParam_Convert()
+        {
+            var container = new GenericContainer<int>(21);
+
+            int doubled = container.Convert(v => v * 2);
+
+            Assert.AreEqual(42, doubled);
+        }
+
+        [TestMethod]
+        public void Generic_TwoParam_MixedTypes()
+        {
+            var pair = new GenericPair<int, string>(1, "one");
+
+            Assert.AreEqual(1, pair.First);
+            Assert.AreEqual("one", pair.Second);
+        }
+
+        [TestMethod]
+        public void Generic_TwoParam_SameType()
+        {
+            var pair = new GenericPair<int, int>(10, 20);
+
+            Assert.AreEqual(10, pair.First);
+            Assert.AreEqual(20, pair.Second);
+        }
+
+        [TestMethod]
+        public void Generic_GenericMethod_Resolution()
+        {
+            int a = 1;
+            int b = 2;
+            Swap(ref a, ref b);
+
+            Assert.AreEqual(2, a);
+            Assert.AreEqual(1, b);
+
+            string s1 = "A";
+            string s2 = "B";
+            Swap(ref s1, ref s2);
+
+            Assert.AreEqual("B", s1);
+            Assert.AreEqual("A", s2);
+        }
+
+        [TestMethod]
+        public void Generic_MultipleInstantiations_SameMethod()
+        {
+            var intContainer = new GenericContainer<int>(1);
+            var stringContainer = new GenericContainer<string>("one");
+            var pair = new GenericPair<bool, int>(true, 2);
+
+            Assert.AreEqual(1, intContainer.GetValue());
+            Assert.AreEqual("one", stringContainer.GetValue());
+            Assert.IsTrue(pair.First);
+            Assert.AreEqual(2, pair.Second);
+        }
+
+        private static void Swap<T>(ref T a, ref T b)
+        {
+            T temp = a;
+            a = b;
+            b = temp;
+        }
+
+        internal class GenericWithStaticField<T>
+        {
+            internal static T DefaultValue = default(T);
+            internal static int InitCount = 0;
+
+            static GenericWithStaticField()
+            {
+                InitCount = 1;
+            }
+        }
+
+        internal class GenericWithStaticMethod<T>
+        {
+            private static bool _initialized = false;
+
+            static GenericWithStaticMethod()
+            {
+                _initialized = true;
+            }
+
+            internal static bool IsInitialized()
+            {
+                return _initialized;
+            }
+        }
+
+        internal class GenericStaticFieldBox<T>
+        {
+            internal T[] Items;
+            internal int Count;
+
+            internal GenericStaticFieldBox()
+            {
+                Items = new T[4];
+                Count = 0;
+            }
+
+            internal void Add(T item)
+            {
+                Items[Count++] = item;
+            }
+        }
+
+        internal static class BoxHolder
+        {
+            internal static readonly GenericStaticFieldBox<int> IntBox = new GenericStaticFieldBox<int>();
+            internal static readonly GenericStaticFieldBox<string> StringBox = new GenericStaticFieldBox<string>();
+        }
+
+        internal static class GenericBoxHolder<T>
+        {
+            internal static readonly GenericStaticFieldBox<T> Box = new GenericStaticFieldBox<T>();
+        }
+
+        internal class GenericContainer<T>
+        {
+            private T _value;
+
+            internal GenericContainer(T value)
+            {
+                _value = value;
+            }
+
+            internal T GetValue() => _value;
+
+            internal void SetValue(T value) => _value = value;
+
+            internal TResult Convert<TResult>(Func<T, TResult> converter)
+            {
+                return converter(_value);
+            }
+        }
+
+        internal class GenericPair<TFirst, TSecond>
+        {
+            internal TFirst First;
+            internal TSecond Second;
+
+            internal GenericPair(TFirst first, TSecond second)
+            {
+                First = first;
+                Second = second;
+            }
+        }
+    }
+}