diff --git a/.runsettings b/.runsettings index 3d17b679..536c73fb 100644 --- a/.runsettings +++ b/.runsettings @@ -1,4 +1,4 @@ - + @@ -12,5 +12,6 @@ Verbose False --forcegc + True - \ No newline at end of file + diff --git a/Tests/NFUnitTestGC/TestGC.cs b/Tests/NFUnitTestGC/TestGC.cs index 0bec97a8..bf52e121 100644 --- a/Tests/NFUnitTestGC/TestGC.cs +++ b/Tests/NFUnitTestGC/TestGC.cs @@ -1,7 +1,8 @@ -// Licensed to the .NET Foundation under one or more agreements. +// 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 NFUnitTestGC @@ -15,8 +16,6 @@ public void TestGCStress() int maxArraySize = 1024 * 32; object[] arrays = new object[600]; - // Starting TestGCStress - for (int loop = 0; loop < 100; loop++) { OutputHelper.WriteLine($"Running iteration {loop}"); @@ -24,7 +23,7 @@ public void TestGCStress() for (int i = 0; i < arrays.Length - 1;) { OutputHelper.WriteLine($"Alloc array of {maxArraySize} bytes @ pos {i}"); - arrays[i++] = new byte[maxArraySize]; ; + arrays[i++] = new byte[maxArraySize]; OutputHelper.WriteLine($"Alloc array of 64 bytes @ pos {i}"); arrays[i++] = new byte[64]; @@ -37,8 +36,35 @@ public void TestGCStress() arrays[i] = null; } } + } + + [TestMethod] + public void TestGetTotalMemory() + { + // create several objects + object[] objects = new object[100]; + + for (int i = 0; i < objects.Length; i++) + { + objects[i] = new object(); + } + + // get total memory + long totalMemory = GC.GetTotalMemory(false); + OutputHelper.WriteLine($"Total memory: {totalMemory} bytes"); + + // release objects + for (int i = 0; i < objects.Length; i++) + { + objects[i] = null; + } + + // get total memory, forcing full collection + long totalMemoryAfterCollection = GC.GetTotalMemory(true); + OutputHelper.WriteLine($"Total memory: {totalMemoryAfterCollection} bytes"); - // Completed TestGCStress + // check if memory was released + Assert.IsTrue(totalMemory > totalMemoryAfterCollection, "Memory was not released"); } } } diff --git a/Tests/NFUnitTestSystemLib/NFUnitTestSystemLib.nfproj b/Tests/NFUnitTestSystemLib/NFUnitTestSystemLib.nfproj index 593d741a..95da98f9 100644 --- a/Tests/NFUnitTestSystemLib/NFUnitTestSystemLib.nfproj +++ b/Tests/NFUnitTestSystemLib/NFUnitTestSystemLib.nfproj @@ -21,9 +21,12 @@ true UnitTest v1.0 + 13.0 + + @@ -61,4 +64,4 @@ - \ No newline at end of file + diff --git a/Tests/NFUnitTestSystemLib/RuntimeHelpersTests.cs b/Tests/NFUnitTestSystemLib/RuntimeHelpersTests.cs new file mode 100644 index 00000000..d02d1c00 --- /dev/null +++ b/Tests/NFUnitTestSystemLib/RuntimeHelpersTests.cs @@ -0,0 +1,68 @@ +// 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 System.Runtime.CompilerServices; +using nanoFramework.TestFramework; + +namespace NFUnitTestSystemLib +{ + [TestClass] + class RuntimeHelpersTests + { + [TestMethod] + public static void IsReferenceOrContainsReferences() + { + Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences()); + Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences>()); + Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences>()); + //Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences()); + //Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences()); + } + + private struct StructWithoutReferences + { + public int a, b, c; + } + + private struct StructWithReferences + { + public int a, b, c; + public object d; + } + + private ref struct RefStructWithoutReferences + { + public int a; + public long b; + } + + private ref struct RefStructWithReferences + { + public int a; + public object b; + } + + // TODO: add after checking viability of ref fields in ref structs + //private ref struct RefStructWithRef + //{ + // public ref int a; + + // internal RefStructWithRef(ref int aVal) + // { + // a = ref aVal; + // } + //} + + //private ref struct RefStructWithNestedRef + //{ + // public Span a; + //} + } +} diff --git a/Tests/NFUnitTestSystemLib/UnitTestGCTest.cs b/Tests/NFUnitTestSystemLib/UnitTestGCTest.cs index 05c73642..42a3e8f0 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestGCTest.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestGCTest.cs @@ -9,6 +9,11 @@ namespace NFUnitTestSystemLib [TestClass] public class UnitTestGCTest { +#pragma warning disable S1215 // this is intended to test the GC +#pragma warning disable S1854 // this is intended to test the GC +#pragma warning disable S2696 // this is intended to test the GC +#pragma warning disable S3971 // this is intended to test the GC + internal class FinalizeObject { public static FinalizeObject m_currentInstance = null; @@ -54,17 +59,20 @@ public void SystemGC1_Test() /// 6. Verify that object has been collected /// /// - // Tests ReRegisterForFinalize - // Create a FinalizeObject. + + OutputHelper.WriteLine("Tests ReRegisterForFinalize"); + OutputHelper.WriteLine("Create a FinalizeObject."); + FinalizeObject mfo = new FinalizeObject(); m_hasFinalized1 = false; m_hasFinalized2 = false; // Release reference + OutputHelper.WriteLine("Release reference"); mfo = null; - // Allow GC - GC.WaitForPendingFinalizers(); + OutputHelper.WriteLine("Allow GC"); + GC.Collect(); int sleepTime = 1000; int slept = 0; @@ -85,10 +93,10 @@ public void SystemGC1_Test() // FinalizeObject.m_currentInstance field. Setting this value // to null and forcing another garbage collection will now // cause the object to Finalize permanently. - // Reregister and allow for GC - FinalizeObject.m_currentInstance = null; - GC.WaitForPendingFinalizers(); + OutputHelper.WriteLine("Reregister and allow for GC"); + FinalizeObject.m_currentInstance = null; + GC.Collect(); sleepTime = 1000; slept = 0; @@ -119,18 +127,19 @@ public void SystemGC2_Test() /// 6. Verify that object has not been collected /// /// - // Tests SuppressFinalize - // Create a FinalizeObject. + + OutputHelper.WriteLine("Tests SuppressFinalize"); + OutputHelper.WriteLine("Create a FinalizeObject"); FinalizeObject mfo = new FinalizeObject(); m_hasFinalized1 = false; m_hasFinalized2 = false; - // Releasing + OutputHelper.WriteLine("Releasing"); GC.SuppressFinalize(mfo); mfo = null; - // Allow GC - GC.WaitForPendingFinalizers(); + OutputHelper.WriteLine("Allow GC"); + GC.Collect(); int sleepTime = 1000; int slept = 0; @@ -138,7 +147,7 @@ public void SystemGC2_Test() while (!m_hasFinalized1 && slept < sleepTime) { // force GC run caused by memory allocation - var dummyArray = new byte[1024 * 1024 * 1]; + _ = new byte[1024 * 1024 * 1]; System.Threading.Thread.Sleep(10); slept += 10; @@ -161,59 +170,35 @@ public void SystemGC3_Test() /// /// - // Tests WaitForPendingFinalizers, dependant on test 1 - // will auto-fail if test 1 fails. OutputHelper.Write("Tests WaitForPendingFinalizers, dependant on test 1"); - OutputHelper.WriteLine("will auto-fail if test 1 fails."); + OutputHelper.WriteLine("will fail if test 1 fails."); - Assert.IsTrue(m_Test1Result); + Assert.IsTrue(m_Test1Result, "Can't run this test as SystemGC1_Test has failed."); - // Create a FinalizeObject. + OutputHelper.WriteLine("Create a FinalizeObject"); FinalizeObject mfo = new FinalizeObject(); m_hasFinalized1 = false; m_hasFinalized2 = false; - // Releasing + OutputHelper.WriteLine("Releasing"); mfo = null; - int sleepTime = 1000; - int slept = 0; - - while (!m_hasFinalized1 && slept < sleepTime) - { - // force GC run caused by memory allocation - var dummyArray = new byte[1024 * 1024 * 1]; - - System.Threading.Thread.Sleep(10); - slept += 10; - } - - OutputHelper.WriteLine($"GC took {slept}"); - - // Wait for GC + OutputHelper.WriteLine("Wait for GC"); + GC.Collect(); GC.WaitForPendingFinalizers(); - // Releasing again + OutputHelper.WriteLine("Releasing again"); FinalizeObject.m_currentInstance = null; - sleepTime = 1000; - slept = 0; - - while (!m_hasFinalized2 && slept < sleepTime) - { - // force GC run caused by memory allocation - var dummyArray = new byte[1024 * 1024 * 1]; - - System.Threading.Thread.Sleep(10); - slept += 10; - } - - OutputHelper.WriteLine($"GC took {slept}"); - - // Wait for GC + OutputHelper.WriteLine("Wait for GC"); + GC.Collect(); GC.WaitForPendingFinalizers(); Assert.IsTrue(m_hasFinalized2); } } +#pragma warning restore S1215 // "GC.Collect" should not be called +#pragma warning restore S1854 // Unused assignments should be removed +#pragma warning restore S2696 // Instance members should not write to "static" fields +#pragma warning restore S3971 // "GC.SuppressFinalize" should not be called } diff --git a/Tests/NFUnitTestSystemLib/UnitTestInitLocalTests.cs b/Tests/NFUnitTestSystemLib/UnitTestInitLocalTests.cs index fea53af7..a26039e7 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestInitLocalTests.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestInitLocalTests.cs @@ -49,6 +49,9 @@ public void SystemType1_GetType_Test() // ConstructorInfo) // NOTE: We add the reflection items to the ArrayList to assure that they can be properly // assigned to a object container (this used to lead to a access violation) + + OutputHelper.WriteLine("Testing Int32"); + Type type = typeof(int); list.Add(type); string name = ((Type)list[i]).Name; @@ -68,12 +71,16 @@ public void SystemType1_GetType_Test() //fRes &= name.ToLower() == "mscorlib"; //i++; + OutputHelper.WriteLine("Testing NFUnitTestSystemLib.UnitTestInitLocalTests+TestObj"); + type = Type.GetType("NFUnitTestSystemLib.UnitTestInitLocalTests+TestObj"); list.Add(type); name = ((Type)list[i]).Name; Assert.AreEqual(name, "TestObj"); i++; + OutputHelper.WriteLine("Testing IEmptyInterface"); + Type iface = type.GetInterfaces()[0]; list.Add(iface); name = ((Type)list[i]).Name; @@ -81,6 +88,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(iface.Name, "IEmptyInterface"); i++; + OutputHelper.WriteLine("Testing FieldInfo"); + FieldInfo fi = type.GetField("Field1"); list.Add(fi); name = ((FieldInfo)list[i]).Name; @@ -88,6 +97,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(fi.Name, "Field1"); i++; + OutputHelper.WriteLine("Testing MethodInfo"); + MethodInfo mi = type.GetMethod("Method1"); list.Add(mi); name = ((MethodInfo)list[i]).Name; @@ -95,6 +106,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(mi.Name, "Method1"); i++; + OutputHelper.WriteLine("Testing ConstructorInfo"); + ConstructorInfo ci = type.GetConstructor(new Type[] { }); list.Add(ci); name = ((ConstructorInfo)list[i]).Name; @@ -104,7 +117,10 @@ public void SystemType1_GetType_Test() // // Now test arrays of reflection types - // + // + + OutputHelper.WriteLine("Testing Array of Type"); + Type[] types = new Type[] { typeof(int), typeof(bool), Type.GetType("NFUnitTestSystemLib.UnitTestInitLocalTests+TestObj") }; list.Add(types[2]); name = ((Type)list[i]).Name; @@ -127,6 +143,8 @@ public void SystemType1_GetType_Test() //fRes &= asms[0].GetName().Name == "Microsoft.SPOT.Platform.Tests.Systemlib2"; //i++; + OutputHelper.WriteLine("Testing Array of FieldInfo"); + FieldInfo[] fis = new FieldInfo[] { types[2].GetField("Field1"), type.GetFields()[0] }; list.Add(fis[0]); name = ((FieldInfo)list[i]).Name; @@ -134,6 +152,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(fis[0].Name, "Field1"); i++; + OutputHelper.WriteLine("Testing Array of MethodInfo"); + MethodInfo[] mis = new MethodInfo[] { type.GetMethods()[2], types[2].GetMethod("Method2", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public) }; list.Add(mis[1]); name = ((MethodInfo)list[i]).Name; @@ -141,6 +161,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(mis[1].Name, "Method2"); i++; + OutputHelper.WriteLine("Testing Array of ConstructorInfo"); + ConstructorInfo[] cis = new ConstructorInfo[] { types[2].GetConstructor(new Type[] { }), typeof(TestObj).GetConstructor(new Type[] { typeof(int) }) }; list.Add(cis[0]); name = ((ConstructorInfo)list[i]).Name; @@ -148,6 +170,8 @@ public void SystemType1_GetType_Test() Assert.AreEqual(cis[0].Name, ".ctor"); i++; + OutputHelper.WriteLine("Testing Array of System.Collections.ArrayList"); + Array ar = Array.CreateInstance(typeof(Type), 3); ((IList)ar)[0] = typeof(Type); ((IList)ar)[1] = Type.GetType("System.Collections.ArrayList"); @@ -157,7 +181,6 @@ public void SystemType1_GetType_Test() Assert.AreEqual(name, "ArrayList"); Assert.AreEqual(((Type)((IList)ar)[0]).Name, "Type"); Assert.AreEqual(((Type)ar.GetValue(1)).Name, "ArrayList"); - i++; list.Clear(); } @@ -192,14 +215,24 @@ public void SystemType1_ArrayListToArrayForStruct_Test() // make sure boxing of struct value type (Guid) is handled properly // this test was a result of a bug found by a customer. Guid ret = new Guid(); + ArrayList guidList = new ArrayList(); guidList.Add(Guid.NewGuid()); guidList.Add(Guid.NewGuid()); + Guid[] guidArray = (Guid[])guidList.ToArray(typeof(Guid)); + // Verify the array has the correct length + Assert.AreEqual(2, guidArray.Length); + + // Verify each element is not empty and matches the source list + int i = 0; foreach (Guid g in guidArray) { + Assert.IsFalse(Guid.Empty.Equals(g), "Guid should not be empty"); + Assert.AreEqual(guidList[i], g, "Guid should match the source ArrayList element"); ret = g; + i++; } } diff --git a/Tests/NFUnitTestSystemLib/UnitTestNullable.cs b/Tests/NFUnitTestSystemLib/UnitTestNullable.cs new file mode 100644 index 00000000..74a98741 --- /dev/null +++ b/Tests/NFUnitTestSystemLib/UnitTestNullable.cs @@ -0,0 +1,266 @@ +// 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 NFUnitTestSystemLib +{ + [TestClass] + public class UnitTestNullable + { + [TestMethod] + public void Ctor_Empty() + { + // Nullable and Nullable are mostly verbatim ports so we don't test much here. + + int? n = default(int?); + Assert.IsFalse(n.HasValue); + + // TODO replace with Assert.ThrowsException when available + Assert.ThrowsException( + typeof(InvalidOperationException), + () => _ = n.Value); + Assert.ThrowsException( + typeof(InvalidOperationException), + () => _ = (int)n); + + Assert.IsNull(n); + Assert.AreNotEqual(7, n); + Assert.AreEqual(0, n.GetHashCode()); + Assert.AreEqual("", n.ToString()); + Assert.AreEqual(default(int), n.GetValueOrDefault()); + Assert.AreEqual(999, n.GetValueOrDefault(999)); + + n = new int?(42); + Assert.IsTrue(n.HasValue); + Assert.AreEqual(42, n.Value); + Assert.AreEqual(42, (int)n); + Assert.IsNotNull(n); + Assert.AreNotEqual(7, n); + Assert.AreEqual(42, n); + Assert.AreEqual(42.GetHashCode(), n.GetHashCode()); + Assert.AreEqual(42.ToString(), n.ToString()); + Assert.AreEqual(42, n.GetValueOrDefault()); + Assert.AreEqual(42, n.GetValueOrDefault(999)); + + n = 88; + Assert.IsTrue(n.HasValue); + Assert.AreEqual(88, n.Value); + } + + [TestMethod] + public static void Boxing() + { + int? n = new int?(42); + Unbox(n); + } + + private static void Unbox(object o) + { + Type t = o.GetType(); + + // TOOD: replace with Assert.IsNotType(t); when available + Assert.IsNotInstanceOfType(typeof(int?), t); + + Assert.AreEqual(typeof(int), t); + } + + [TestMethod] + public static void ExplicitCast_T() + { + int? nullable = 5; + int value = (int)nullable; + Assert.AreEqual(5, value); + + nullable = null; + // TODO replace with Assert.Throws(() => (int)nullable); when available + Assert.ThrowsException( + typeof(InvalidOperationException), + () => _ = (int)nullable); + } + + [TestMethod] + public static void GetUnderlyingType() + { + Assert.AreEqual(typeof(int), Nullable.GetUnderlyingType(typeof(int?))); + Assert.AreEqual(null, Nullable.GetUnderlyingType(typeof(int))); + Assert.AreEqual(null, Nullable.GetUnderlyingType(typeof(G))); + } + + [TestMethod] + public static void GetUnderlyingType_NullType_ThrowsArgumentNullException() + { + // TODO replace with Assert.Throws("nullableType", () => Nullable.GetUnderlyingType(null)); when available + Assert.ThrowsException( + typeof(ArgumentNullException), + () => Nullable.GetUnderlyingType(null) + ); + } + + // TODO: Uncomment when available + //[TestMethod] + //public static void GetValueRefOrDefaultRef_WithValue() + //{ + // static void Test(T before, T after) + // where T : struct + // { + // T? nullable = before; + // ref readonly T reference = ref Nullable.GetValueRefOrDefaultRef(in nullable); + + // Assert.AreEqual(before, nullable!.Value); + + // Unsafe.AsRef(in reference) = after; + + // Assert.Equal(after, nullable.Value); + // } + + // Test((byte)0, (byte)42); + // Test(0, 42); + // Test(1.3f, 3.14f); + // Test(0.555, 8.49); + // Test(Guid.NewGuid(), Guid.NewGuid()); + //} + + // TODO: Uncomment when available + //[TestMethod] + //public static void GetValueRefOrDefaultRef_WithDefault() + //{ + // static void Test() + // where T : struct + // { + // T? nullable = null; + // ref readonly T reference = ref Nullable.GetValueRefOrDefaultRef(in nullable); + + // Assert.Equal(nullable!.GetValueOrDefault(), reference); + // } + + // Test(); + // Test(); + // Test(); + // Test(); + // Test(); + //} + + // TODO: Uncomment when available + //[TestMethod] + //public static void GetValueRefOrDefaultRef_UnsafeWriteToNullMaintainsExpectedBehavior() + //{ + // static void Test(T after) + // where T : struct + // { + // T? nullable = null; + // ref readonly T reference = ref Nullable.GetValueRefOrDefaultRef(in nullable); + + // Unsafe.AsRef(in reference) = after; + + // Assert.Equal(after, nullable.GetValueOrDefault()); // GetValueOrDefault() unconditionally returns the field + // Assert.False(nullable.HasValue); + // Assert.Equal(0, nullable.GetHashCode()); // GetHashCode() returns 0 if HasValue is false, without reading the field + // Assert.Throws(() => nullable.Value); // Accessing the value should still throw despite the write + // Assert.Throws(() => (T)nullable); + // } + + // Test((byte)42); + // Test(42); + // Test(3.14f); + // Test(8.49); + // Test(Guid.NewGuid()); + //} + + [TestMethod] + public static void Compare_Equals() + { + // Case 1: (null, null, 0) + int? n1 = null; + int? n2 = null; + int expected = 0; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + + // Case 2: (7, null, 1) + n1 = 7; + n2 = null; + expected = 1; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + + // Case 3: (null, 7, -1) + n1 = null; + n2 = 7; + expected = -1; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + + // Case 4: (7, 7, 0) + n1 = 7; + n2 = 7; + expected = 0; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + + // Case 5: (7, 5, 1) + n1 = 7; + n2 = 5; + expected = 1; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + + // Case 6: (5, 7, -1) + n1 = 5; + n2 = 7; + expected = -1; + Assert.AreEqual(expected == 0, Nullable.Equals(n1, n2)); + Assert.AreEqual(expected == 0, n1.Equals(n2)); + // TODO Assert.AreEqual(expected, Nullable.Compare(n1, n2)); + } + + //[TestMethod] + //public static void MutatingMethods_MutationsAffectOriginal() + //{ + // MutatingStruct? ms = new MutatingStruct() { Value = 1 }; + + // for (int i = 1; i <= 2; i++) + // { + // Assert.AreEqual(i.ToString(), ms.Value.ToString()); + // Assert.AreEqual(i, ms.Value.Value); + + // Assert.AreEqual(i.ToString(), ms.ToString()); + // Assert.AreEqual(i + 1, ms.Value.Value); + // } + + // for (int i = 3; i <= 4; i++) + // { + // Assert.AreEqual(i, ms.Value.GetHashCode()); + // Assert.AreEqual(i, ms.Value.Value); + + // Assert.AreEqual(i, ms.GetHashCode()); + // Assert.AreEqual(i + 1, ms.Value.Value); + // } + + // for (int i = 5; i <= 6; i++) + // { + // ms.Value.Equals(new object()); + // Assert.AreEqual(i, ms.Value.Value); + + // ms.Equals(new object()); + // Assert.AreEqual(i + 1, ms.Value.Value); + // } + //} + + //private struct MutatingStruct + //{ + // public int Value; + // public override string ToString() => Value++.ToString(); + // public override bool Equals(object obj) => Value++.Equals(null); + // public override int GetHashCode() => Value++.GetHashCode(); + //} + + public class G { } + } +} diff --git a/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs b/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs index 709f2122..805c2b93 100644 --- a/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs +++ b/Tests/NFUnitTestSystemLib/UnitTestReflectionTypeTest.cs @@ -5,6 +5,7 @@ using System.Collections; using System.Reflection; using nanoFramework.TestFramework; +using static NFUnitTestSystemLib.UnitTestNullable; namespace NFUnitTestSystemLib { @@ -52,85 +53,103 @@ public void SystemReflectionType_RuntimeType_Test1() /// TestClass cls = new TestClass(); + OutputHelper.WriteLine("Testing Type members for a class type"); + // Test Type members for a class type Type t = cls.GetType(); Assembly asm = t.Assembly; list.Add(asm); - Assert.AreEqual(((Assembly)list[i]).GetName().Name, "NFUnitTest"); - Assert.AreEqual(asm.GetName().Name, "NFUnitTest"); - Assert.AreEqual(t.Name, "TestClass"); - Assert.AreEqual(t.FullName, "NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestClass"); + Assert.AreEqual("NFUnitTest", ((Assembly)list[i]).GetName().Name); + Assert.AreEqual("NFUnitTest", asm.GetName().Name); + Assert.AreEqual("TestClass", t.Name); + Assert.AreEqual("NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestClass", t.FullName); Assert.IsInstanceOfType(t.BaseType, typeof(object)); Assert.IsNull(t.GetElementType()); + OutputHelper.WriteLine("Testing methods of class type"); + MethodInfo[] mis = t.GetMethods(); - Assert.AreEqual(mis[0].Name, "Method1"); + Assert.AreEqual("Method1", mis[0].Name); mis = t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic); - Assert.AreEqual(mis[0].Name, "Method2"); + Assert.AreEqual("Method2", mis[0].Name); Assert.IsNotNull(t.GetMethod("Method1")); Assert.IsNotNull(t.GetMethod("Method2", BindingFlags.Instance | BindingFlags.NonPublic)); + OutputHelper.WriteLine("Testing fields of class type"); + FieldInfo[] fis = t.GetFields(); - Assert.AreEqual(fis[0].Name, "m_Field1"); + Assert.AreEqual("m_Field1", fis[0].Name); fis = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic); - Assert.AreEqual(fis[0].Name, "m_Field2"); + Assert.AreEqual("m_Field2", fis[0].Name); Assert.IsNotNull(t.GetField("m_Field1")); Assert.IsNotNull(t.GetField("m_Field2", BindingFlags.NonPublic | BindingFlags.Instance)); Assert.IsNotNull(t.GetConstructor(new Type[] { })); + OutputHelper.WriteLine("Testing interfaces of class type"); + Type[] ifaces = t.GetInterfaces(); - Assert.AreEqual(ifaces.Length, 2); - Assert.AreEqual(ifaces[0].Name, "IInterface1"); - Assert.AreEqual(ifaces[1].Name, "IInterface2"); + Assert.AreEqual(2, ifaces.Length); + Assert.AreEqual("IInterface1", ifaces[0].Name); + Assert.AreEqual("IInterface2", ifaces[1].Name); Assert.IsTrue(t.IsSubclassOf(typeof(object))); i++; + OutputHelper.WriteLine("Testing Type members for a struct valuetype"); + // test Type members for a struct valuetype TestStruct str = new TestStruct(); t = str.GetType(); asm = t.Assembly; list.Add(asm); - Assert.AreEqual(((Assembly)list[i]).GetName().Name, "NFUnitTest"); - Assert.AreEqual(asm.GetName().Name, "NFUnitTest"); - Assert.AreEqual(t.Name, "TestStruct"); - Assert.AreEqual(t.FullName, "NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestStruct"); + Assert.AreEqual("NFUnitTest", ((Assembly)list[i]).GetName().Name); + Assert.AreEqual("NFUnitTest", asm.GetName().Name); + Assert.AreEqual("TestStruct", t.Name); + Assert.AreEqual("NFUnitTestSystemLib.UnitTestReflectionTypeTest+TestStruct", t.FullName); Assert.IsInstanceOfType(t.BaseType, typeof(ValueType)); - Assert.AreEqual(t.GetInterfaces().Length, 0); + Assert.AreEqual(0, t.GetInterfaces().Length); Assert.IsNull(t.GetElementType()); i++; + OutputHelper.WriteLine("Testing Type members for an Assembly reflection type"); + // test Type members for an Assembly reflection type //Assembly asmObj = typeof(TestClass).Assembly; //t = asmObj.GetType(); //asm = t.Assembly; //list.Add(asm); - //Assert.AreEqual(((Assembly)list[i]).GetName().Name, "mscorlib"); - //Assert.AreEqual(asm.GetName().Name, "mscorlib"); - //Assert.AreEqual(t.Name, "Assembly"); - //Assert.AreEqual(t.FullName, "System.Reflection.Assembly"); + //Assert.AreEqual("mscorlib", ((Assembly)list[i]).GetName().Name); + //Assert.AreEqual("mscorlib", asm.GetName().Name); + //Assert.AreEqual("Assembly", t.Name); + //Assert.AreEqual("System.Reflection.Assembly", t.FullName); //Assert.IsInstanceOfType(t.BaseType, typeof(Object)); - //Assert.AreEqual(t.GetInterfaces().Length, 0); + //Assert.AreEqual(0, t.GetInterfaces().Length); //Assert.IsNull(t.GetElementType()); + OutputHelper.WriteLine("Testing Type members for a MethodInfo reflection type"); + mis = typeof(TestClass).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); t = mis.GetType(); - Assert.AreEqual(t.Name, "RuntimeMethodInfo[]"); - Assert.AreEqual(t.FullName, "System.Reflection.RuntimeMethodInfo[]"); + Assert.AreEqual("RuntimeMethodInfo[]", t.Name); + Assert.AreEqual("System.Reflection.RuntimeMethodInfo[]", t.FullName); Assert.IsInstanceOfType(t.BaseType, typeof(Array)); Assert.IsTrue(t.GetInterfaces().Length > 0); - Assert.AreEqual(t.GetElementType().Name, "RuntimeMethodInfo"); + Assert.AreEqual("RuntimeMethodInfo", t.GetElementType().Name); + + OutputHelper.WriteLine("Testing Type members for a delegate"); // test Type members for a delegate Delegate del = new MyDelegate(MyDelegateImpl); t = del.GetType(); Assert.IsNotNull(t.DeclaringType); - Assert.AreEqual(t.Name, "MyDelegate"); + Assert.AreEqual("MyDelegate", t.Name); Assert.IsInstanceOfType(t.BaseType, typeof(MulticastDelegate)); + OutputHelper.WriteLine("Testing Type members for an enum"); + // test Type members for an enum TestEnum en = TestEnum.Item1; t = en.GetType(); - Assert.IsInstanceOfType(t.DeclaringType, typeof(UnitTestReflectionTypeTest)); + Assert.IsInstanceOfType(typeof(UnitTestReflectionTypeTest), t.DeclaringType); Assert.IsTrue(t.IsEnum); Assert.IsFalse(t.IsAbstract); Assert.IsFalse(t.IsClass); @@ -145,10 +164,11 @@ public void SystemReflectionType_SystemType_Test2() Assert.IsTrue(typeof(Array).IsInstanceOfType(blah)); Assert.IsTrue(typeof(TestStruct[]).IsArray); + Assert.IsTrue(typeof(G[]).IsArray); Assert.IsFalse(typeof(Array).IsValueType); Assert.IsTrue(typeof(TestStruct).IsValueType); Assert.IsTrue(typeof(Type).IsSubclassOf(typeof(MemberInfo))); - Assert.AreEqual(typeof(Type).GetInterfaces()[0].Name, "IReflect"); + Assert.AreEqual("IReflect", typeof(Type).GetInterfaces()[0].Name); Assert.IsTrue(typeof(MyDelegate).IsInstanceOfType(new MyDelegate(MyDelegateImpl))); // Get known type from assembly qualified type name Culture and PublicKeyToken are used by debugger to identify types diff --git a/Tests/NFUnitTestTypes/NFUnitTestTypes.nfproj b/Tests/NFUnitTestTypes/NFUnitTestTypes.nfproj index 7ede25bb..f6f14b4a 100644 --- a/Tests/NFUnitTestTypes/NFUnitTestTypes.nfproj +++ b/Tests/NFUnitTestTypes/NFUnitTestTypes.nfproj @@ -24,7 +24,9 @@ + + @@ -47,4 +49,4 @@ - + \ No newline at end of file diff --git a/Tests/NFUnitTestTypes/UnitTestGuid.cs b/Tests/NFUnitTestTypes/UnitTestGuid.cs new file mode 100644 index 00000000..886207cb --- /dev/null +++ b/Tests/NFUnitTestTypes/UnitTestGuid.cs @@ -0,0 +1,140 @@ +// 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 NFUnitTestTypes +{ + [TestClass] + class UnitTestGuid + { + [TestMethod] + public void Guid_Compare_To_Empty() + { + var empty = Guid.Empty; + var notEmpty = Guid.NewGuid(); + Assert.IsFalse(empty == notEmpty); + } + + [TestMethod] + public void Guid_Empty_IsAllZeros() + { + var empty = Guid.Empty; + var bytes = empty.ToByteArray(); + foreach (var b in bytes) + { + Assert.AreEqual((byte)0, b); + } + } + + [TestMethod] + public void Guid_Constructor_ByteArray_RoundTrip() + { + var original = Guid.NewGuid(); + var bytes = original.ToByteArray(); + var roundTrip = new Guid(bytes); + Assert.AreEqual(original, roundTrip); + } + + [TestMethod] + public void Guid_Equals_And_Operator() + { + var g1 = Guid.NewGuid(); + var g2 = new Guid(g1.ToByteArray()); + Assert.IsTrue(g1.Equals(g2)); + Assert.IsTrue(g1 == g2); + Assert.IsFalse(g1 != g2); + } + + [TestMethod] + public void Guid_NotEquals_And_Operator() + { + var g1 = Guid.NewGuid(); + var g2 = Guid.NewGuid(); + Assert.IsFalse(g1.Equals(g2)); + Assert.IsFalse(g1 == g2); + Assert.IsTrue(g1 != g2); + } + + [TestMethod] + public void Guid_ToString_And_Parse() + { + var g1 = Guid.NewGuid(); + var str = g1.ToString(); + var g2 = new Guid(str); + Assert.AreEqual(g1, g2); + } + + [TestMethod] + public void Guid_GetHashCode_Consistent() + { + var g1 = Guid.NewGuid(); + var g2 = new Guid(g1.ToByteArray()); + Assert.AreEqual(g1.GetHashCode(), g2.GetHashCode()); + } + + [TestMethod] + public void Guid_CompareTo_Object_And_Self() + { + var g1 = Guid.NewGuid(); + var g2 = new Guid(g1.ToByteArray()); + Assert.AreEqual(0, g1.CompareTo(g2)); + Assert.AreEqual(0, g1.CompareTo((object)g2)); + Assert.AreEqual(1, g1.CompareTo(null)); + } + + [TestMethod] + public void Guid_CompareTo_InvalidType_Throws() + { + var g1 = Guid.NewGuid(); + Assert.ThrowsException(typeof(ArgumentException), () => + { + g1.CompareTo("not a guid"); + }); + } + + [TestMethod] + public void Guid_TryParseGuidWithDashes_Valid() + { + var g1 = Guid.NewGuid(); + var str = g1.ToString(); + bool parsed = Guid.TryParse(str, out var g2); + Assert.IsTrue(parsed); + Assert.AreEqual(g1, g2); + } + + [TestMethod] + public void Guid_TryParseGuidWithDashes_Invalid() + { + bool parsed = Guid.TryParse("invalid-guid", out var g2); + Assert.IsFalse(parsed); + Assert.AreEqual(Guid.Empty, g2); + } + + [TestMethod] + public void Guid_Constructor_String_WithBraces() + { + var g1 = Guid.NewGuid(); + var str = "{" + g1.ToString() + "}"; + var g2 = new Guid(str); + Assert.AreEqual(g1, g2); + } + + [TestMethod] + public void Guid_Constructor_String_Invalid_Throws() + { + Assert.ThrowsException(typeof(ArgumentException), () => + { + var g = new Guid("invalid-guid"); + }); + } + + [TestMethod] + public void Guid_GetHashCode_Empty() + { + var empty = Guid.Empty; + Assert.AreEqual(0, empty.GetHashCode()); + } + } +} diff --git a/Tests/NFUnitTestTypes/UnitTestsReadOnlySpanByte.cs b/Tests/NFUnitTestTypes/UnitTestsReadOnlySpanByte.cs new file mode 100644 index 00000000..01266551 --- /dev/null +++ b/Tests/NFUnitTestTypes/UnitTestsReadOnlySpanByte.cs @@ -0,0 +1,978 @@ +// 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 NFUnitTestTypes +{ + [TestClass] + public class UnitTestsReadOnlySpanByte + { + [TestMethod] + public void EmptySpanTests() + { + // Empty span using default constructor + ReadOnlySpan span = new ReadOnlySpan(); + + Assert.AreEqual(0, span.Length, "Empty ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty ReadOnlySpan should be IsEmpty"); + + // Empty span from null array + span = new ReadOnlySpan(null); + + Assert.AreEqual(0, span.Length, "ReadOnlySpan from null should have length of 0"); + Assert.IsTrue(span.IsEmpty, "ReadOnlySpan from null should be IsEmpty"); + + // Empty span using Empty property + span = ReadOnlySpan.Empty; + + Assert.AreEqual(0, span.Length, "Empty ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty ReadOnlySpan should be IsEmpty"); + } + + [TestMethod] + public void RaisingExceptionsOfAllKindsTests() + { + // Should raise an exception on creation + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ReadOnlySpan span = new ReadOnlySpan(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ReadOnlySpan span = new ReadOnlySpan(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ReadOnlySpan span = new ReadOnlySpan(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { ReadOnlySpan span = new ReadOnlySpan(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0"); + + // Exception on index access + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span[span.Length]; + }, "IndexOutOfRangeException when accessing index equal to Length"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span[-1]; + }, "IndexOutOfRangeException when accessing negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span[span.Length + 1]; + }, "IndexOutOfRangeException when accessing index beyond Length"); + + // CopyTo with too small destination + Assert.ThrowsException(typeof(ArgumentException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + Span destination = new Span(new byte[span.Length - 1]); + + span.CopyTo(destination); + }); + + // Slicing arguments + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span.Slice(span.Length + 1); + }); + + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span.Slice(1, span.Length); + }); + + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span.Slice(-1, span.Length); + }); + + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => + { + ReadOnlySpan span = new ReadOnlySpan(array); + _ = span.Slice(1, -1); + }); + } + + [TestMethod] + public void IndexOutOfRangeExceptionTests() + { + // Comprehensive tests for IndexOutOfRangeException in the indexer + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + ReadOnlySpan span = new ReadOnlySpan(array); + + // Test reading at exact boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetReadOnlySpanElement(array, 10); + }, "Should throw IndexOutOfRangeException at index equal to Length"); + + // Test reading beyond boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetReadOnlySpanElement(array, 100); + }, "Should throw IndexOutOfRangeException at large index"); + + // Test negative index + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetReadOnlySpanElement(array, -1); + }, "Should throw IndexOutOfRangeException at negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetReadOnlySpanElement(array, -100); + }, "Should throw IndexOutOfRangeException at large negative index"); + + // Valid access should not throw + byte value = span[0]; + Assert.AreEqual((byte)0, value, "Valid index 0 should return correct value"); + + value = span[9]; + Assert.AreEqual((byte)9, value, "Valid index 9 should return correct value"); + + value = span[5]; + Assert.AreEqual((byte)5, value, "Valid index 5 should return correct value"); + } + + // Helper methods to avoid capturing ref struct in lambdas + private static byte GetReadOnlySpanElement(byte[] array, int index) + { + ReadOnlySpan span = new ReadOnlySpan(array); + return span[index]; + } + + private static byte GetPartialReadOnlySpanElement(byte[] array, int start, int length, int index) + { + ReadOnlySpan span = new ReadOnlySpan(array, start, length); + return span[index]; + } + + private static byte GetEmptyReadOnlySpanElement(int index) + { + ReadOnlySpan span = ReadOnlySpan.Empty; + return span[index]; + } + + private static byte GetNullReadOnlySpanElement(int index) + { + ReadOnlySpan span = new ReadOnlySpan(null); + return span[index]; + } + + private static byte GetSlicedReadOnlySpanElement(byte[] array, int sliceStart, int sliceLength, int index) + { + ReadOnlySpan span = new ReadOnlySpan(array); + ReadOnlySpan sliced = span.Slice(sliceStart, sliceLength); + return sliced[index]; + } + + private static byte GetStackAllocReadOnlySpanElement(int spanLength, int index) + { + ReadOnlySpan span = spanLength == 8 + ? stackalloc byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 } + : stackalloc byte[0]; + return span[index]; + } + + [TestMethod] + public void PartialSpanIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with partial ReadOnlySpans + byte[] array = new byte[20]; + ReadOnlySpan span = new ReadOnlySpan(array, 5, 10); + + // Should have length 10 + Assert.AreEqual(10, span.Length, "Partial ReadOnlySpan should have length 10"); + + // Valid access + byte value = span[0]; + value = span[9]; + + // Invalid access - at boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetPartialReadOnlySpanElement(array, 5, 10, 10); + }, "Should throw IndexOutOfRangeException at index equal to partial span Length"); + + // Invalid access - negative index + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetPartialReadOnlySpanElement(array, 5, 10, -1); + }, "Should throw IndexOutOfRangeException at negative index in partial span"); + + // Invalid access - beyond boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetPartialReadOnlySpanElement(array, 5, 10, 15); + }, "Should throw IndexOutOfRangeException at index beyond partial span Length"); + } + + [TestMethod] + public void EmptySpanIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with empty ReadOnlySpans + ReadOnlySpan emptySpan = ReadOnlySpan.Empty; + + Assert.AreEqual(0, emptySpan.Length, "Empty ReadOnlySpan should have length 0"); + + // Any index access should throw + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetEmptyReadOnlySpanElement(0); + }, "Should throw IndexOutOfRangeException on empty span at index 0"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetEmptyReadOnlySpanElement(-1); + }, "Should throw IndexOutOfRangeException on empty span at negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetEmptyReadOnlySpanElement(1); + }, "Should throw IndexOutOfRangeException on empty span at index 1"); + } + + [TestMethod] + public void NullArrayIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with null-based ReadOnlySpan + ReadOnlySpan nullSpan = new ReadOnlySpan(null); + + Assert.AreEqual(0, nullSpan.Length, "ReadOnlySpan from null should have length 0"); + Assert.IsTrue(nullSpan.IsEmpty, "ReadOnlySpan from null should be empty"); + + // Any index access should throw + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetNullReadOnlySpanElement(0); + }, "Should throw IndexOutOfRangeException when accessing null-based span at index 0"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetNullReadOnlySpanElement(-1); + }, "Should throw IndexOutOfRangeException when accessing null-based span at negative index"); + } + + [TestMethod] + public void SlicedSpanIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with sliced ReadOnlySpans + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + ReadOnlySpan span = new ReadOnlySpan(array); + ReadOnlySpan sliced = span.Slice(4, 8); + + // Should have length 8 + Assert.AreEqual(8, sliced.Length, "Sliced ReadOnlySpan should have length 8"); + + // Valid access + byte value = sliced[0]; + Assert.AreEqual((byte)0x04, value, "First element of slice should be 0x04"); + + value = sliced[7]; + Assert.AreEqual((byte)0x0B, value, "Last element of slice should be 0x0B"); + + // Invalid access at boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSlicedReadOnlySpanElement(array, 4, 8, 8); + }, "Should throw IndexOutOfRangeException at sliced span boundary"); + + // Invalid access beyond boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSlicedReadOnlySpanElement(array, 4, 8, 10); + }, "Should throw IndexOutOfRangeException beyond sliced span boundary"); + + // Invalid negative access + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSlicedReadOnlySpanElement(array, 4, 8, -1); + }, "Should throw IndexOutOfRangeException at negative index in sliced span"); + } + + [TestMethod] + public void StackAllocIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with stack-allocated ReadOnlySpans + ReadOnlySpan span = stackalloc byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 }; + + Assert.AreEqual(8, span.Length, "Stack-allocated ReadOnlySpan should have length 8"); + + // Valid access + byte value = span[0]; + Assert.AreEqual((byte)0x10, value, "First element should be 0x10"); + + value = span[7]; + Assert.AreEqual((byte)0x80, value, "Last element should be 0x80"); + + // Invalid access at boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetStackAllocReadOnlySpanElement(8, 8); + }, "Should throw IndexOutOfRangeException at stack-allocated span boundary"); + + // Invalid negative access + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetStackAllocReadOnlySpanElement(8, -1); + }, "Should throw IndexOutOfRangeException at negative index in stack-allocated span"); + } + + [TestMethod] + public void ToArrayTest() + { + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + + ReadOnlySpan span = new ReadOnlySpan(array); + + byte[] toArray = span.ToArray(); + + CollectionAssert.AreEqual(array, toArray, "Original array and ReadOnlySpan.ToArray should be the same"); + } + + [TestMethod] + public void ConstructorsOfAllKindsTests() + { + // Empty span using default constructor + ReadOnlySpan span = new ReadOnlySpan(); + + Assert.AreEqual(span.Length, 0, "Empty ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty ReadOnlySpan should be IsEmpty"); + + // Empty span from null with zero start and length + span = new ReadOnlySpan(null, 0, 0); + + Assert.AreEqual(span.Length, 0, "Empty ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty ReadOnlySpan should be IsEmpty"); + + // Empty span using Empty property + span = ReadOnlySpan.Empty; + + Assert.AreEqual(span.Length, 0, "Empty ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty ReadOnlySpan should be IsEmpty"); + + // ReadOnlySpan from normal array + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + span = new ReadOnlySpan(array); + + Assert.AreEqual(span.Length, array.Length, $"ReadOnlySpan should have length of the array it takes: {array.Length}"); + Assert.IsFalse(span.IsEmpty, "ReadOnlySpan should NOT be IsEmpty"); + + // ReadOnlySpan from normal array with different start and length + span = new ReadOnlySpan(array, 2, 8); + + Assert.AreEqual(span.Length, 8, $"ReadOnlySpan should have length of 8"); + Assert.IsFalse(span.IsEmpty, "ReadOnlySpan should NOT be IsEmpty"); + } + + [TestMethod] + public void SliceTests() + { + // ReadOnlySpan from normal array + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + ReadOnlySpan span = new ReadOnlySpan(array); + + // Slice 2 elements and check + ReadOnlySpan sliced = span.Slice(0, 2); + + Assert.AreEqual(sliced.Length, 2, "Sliced span length must be 2"); + Assert.AreEqual(sliced[0], (byte)0x00, "Sliced first element must be value 0"); + Assert.AreEqual(sliced[1], (byte)0x01, "Sliced second element must be value 1"); + + // Slice 4 elements starting at index 2 and check + sliced = span.Slice(2, 4); + + Assert.AreEqual(sliced.Length, 4, "Sliced span length must be 4"); + Assert.AreEqual(sliced[0], (byte)0x02, "Sliced first element must be value 2"); + Assert.AreEqual(sliced[1], (byte)0x03, "Sliced second element must be value 3"); + Assert.AreEqual(sliced[2], (byte)0x04, "Sliced third element must be value 4"); + Assert.AreEqual(sliced[3], (byte)0x05, "Sliced fourth element must be value 5"); + + // Slice starting at element 4 and check + sliced = span.Slice(4); + + Assert.AreEqual(sliced.Length, 12, "Sliced span length must be 12"); + + for (int i = 0; i < sliced.Length; i++) + { + Assert.AreEqual(sliced[i], span[i + 4], "ReadOnlySpan value should be the same as from the original span"); + } + + // Slice of slice + ReadOnlySpan secondSliced = sliced.Slice(2, 4); + + Assert.AreEqual(secondSliced.Length, 4, "Sliced span length must be 4"); + + for (int i = 0; i < secondSliced.Length; i++) + { + Assert.AreEqual(secondSliced[i], sliced[i + 2], "ReadOnlySpan value should be the same as from the original span"); + } + + // Should be an empty one + ReadOnlySpan empty = span.Slice(span.Length); + + Assert.AreEqual(empty.Length, 0, "Slicing all the span should result in an empty span"); + Assert.IsTrue(empty.IsEmpty, "Empty span should be empty"); + } + + [TestMethod] + public void GetElementsTests() + { + // ReadOnlySpan from normal array + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + ReadOnlySpan span = new ReadOnlySpan(array); + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual(span[i], array[i], "ReadOnlySpan value should be the same as from the original array"); + } + + // Partial span + span = new ReadOnlySpan(array, 2, 8); + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual(span[i], array[i + 2], "ReadOnlySpan value should be the same as from the original array"); + } + } + + [TestMethod] + public void CopyToTests() + { + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + ReadOnlySpan span = new ReadOnlySpan(array); + + // Copy to with the exact same size + Span destination = new Span(new byte[span.Length]); + span.CopyTo(destination); + + CollectionAssert.AreEqual(array, destination.ToArray(), "Original array and ReadOnlySpan.CopyTo should be the same"); + + // Copy to a larger span + destination = new Span(new byte[span.Length + 4]); + span.CopyTo(destination); + + Assert.AreEqual(destination.Length, span.Length + 4, "Destination should maintain its original size"); + + // Verify that the copied elements match + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual(span[i], destination[i], $"Element at index {i} should match after CopyTo"); + } + + // Verify that extra elements in destination remain zero + for (int i = span.Length; i < destination.Length; i++) + { + Assert.AreEqual((byte)0, destination[i], $"Element at index {i} beyond copied range should remain zero"); + } + } + + [TestMethod] + public void CopyToEmptySpanTests() + { + // Empty ReadOnlySpan CopyTo empty Span + ReadOnlySpan emptySource = ReadOnlySpan.Empty; + Span emptyDestination = Span.Empty; + + emptySource.CopyTo(emptyDestination); + + Assert.AreEqual(0, emptyDestination.Length, "Empty destination should remain empty"); + + // Empty ReadOnlySpan CopyTo larger Span + Span largerDestination = new Span(new byte[5]); + emptySource.CopyTo(largerDestination); + + Assert.AreEqual(5, largerDestination.Length, "Destination should maintain its size"); + + // Verify all elements remain zero + for (int i = 0; i < largerDestination.Length; i++) + { + Assert.AreEqual((byte)0, largerDestination[i], $"Element at index {i} should be zero"); + } + } + + [TestMethod] + public void CopyToPartialSpanTests() + { + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + + // Create a partial ReadOnlySpan + ReadOnlySpan span = new ReadOnlySpan(array, 4, 8); + + // Copy to a span of exact size + Span destination = new Span(new byte[8]); + span.CopyTo(destination); + + // Verify copied elements + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual(span[i], destination[i], $"Element at index {i} should match"); + Assert.AreEqual(array[i + 4], destination[i], $"Element should match original array at offset"); + } + } + + [TestMethod] + public void CopyToSlicedSpanTests() + { + byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + ReadOnlySpan span = new ReadOnlySpan(array); + + // Slice the ReadOnlySpan and then copy + ReadOnlySpan sliced = span.Slice(2, 6); + Span destination = new Span(new byte[6]); + + sliced.CopyTo(destination); + + // Verify copied elements match the sliced portion + for (int i = 0; i < sliced.Length; i++) + { + Assert.AreEqual(sliced[i], destination[i], $"Element at index {i} should match sliced span"); + Assert.AreEqual(array[i + 2], destination[i], $"Element should match original array at offset 2"); + } + } + + [TestMethod] + public void CopyToWithDestinationSliceTests() + { + byte[] array = new byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 }; + ReadOnlySpan source = new ReadOnlySpan(array); + + // Create a larger destination and copy to a slice of it + byte[] destArray = new byte[12]; + Span destination = new Span(destArray); + Span destSlice = destination.Slice(2, 8); + + source.CopyTo(destSlice); + + // Verify first 2 elements remain zero + Assert.AreEqual((byte)0, destArray[0], "Element before copied range should be zero"); + Assert.AreEqual((byte)0, destArray[1], "Element before copied range should be zero"); + + // Verify copied elements + for (int i = 0; i < source.Length; i++) + { + Assert.AreEqual(source[i], destArray[i + 2], $"Copied element at index {i + 2} should match source"); + } + + // Verify last elements remain zero + Assert.AreEqual((byte)0, destArray[10], "Element after copied range should be zero"); + Assert.AreEqual((byte)0, destArray[11], "Element after copied range should be zero"); + } + + [TestMethod] + public void CopyToWithNullableArrayTests() + { + // Test that CopyTo works correctly when the internal _array field is nullable + // Create ReadOnlySpan from null (tests nullable _array field) + ReadOnlySpan nullSpan = new ReadOnlySpan(null); + Span destination = new Span(new byte[5]); + + // CopyTo from empty span should not throw + nullSpan.CopyTo(destination); + + // Verify destination remains unchanged (all zeros) + for (int i = 0; i < destination.Length; i++) + { + Assert.AreEqual((byte)0, destination[i], $"Element at index {i} should be zero"); + } + } + + [TestMethod] + public void StackAllocReadOnlySpanTests() + { + // Create a ReadOnlySpan from stack-allocated memory + ReadOnlySpan span = stackalloc byte[16]; + + Assert.AreEqual(16, span.Length, "Stack-allocated ReadOnlySpan should have length of 16"); + Assert.IsFalse(span.IsEmpty, "Stack-allocated ReadOnlySpan should NOT be IsEmpty"); + + // Verify all elements are initialized to zero + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)0, span[i], "Stack-allocated ReadOnlySpan elements should be initialized to 0"); + } + } + + [TestMethod] + public void StackAllocReadOnlySpanWithInitializerTests() + { + // Create a ReadOnlySpan from stack-allocated memory with initializer + ReadOnlySpan span = stackalloc byte[8] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + + Assert.AreEqual(8, span.Length, "Stack-allocated ReadOnlySpan with initializer should have length of 8"); + Assert.IsFalse(span.IsEmpty, "Stack-allocated ReadOnlySpan should NOT be IsEmpty"); + + // Verify the initialized values + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)(i + 1), span[i], $"Stack-allocated ReadOnlySpan element at index {i} should be {i + 1}"); + } + } + + [TestMethod] + public void StackAllocReadOnlySpanSliceTests() + { + // Create a ReadOnlySpan from stack-allocated memory + ReadOnlySpan span = stackalloc byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + + // Slice the stack-allocated span + ReadOnlySpan sliced = span.Slice(4, 8); + + Assert.AreEqual(8, sliced.Length, "Sliced stack-allocated ReadOnlySpan should have length of 8"); + + for (int i = 0; i < sliced.Length; i++) + { + Assert.AreEqual((byte)(i + 4), sliced[i], $"Sliced element at index {i} should be {i + 4}"); + } + } + + [TestMethod] + public void StackAllocReadOnlySpanToArrayTests() + { + // Create a ReadOnlySpan from stack-allocated memory + ReadOnlySpan span = stackalloc byte[6] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; + + // Convert to array + byte[] array = span.ToArray(); + + Assert.AreEqual(6, array.Length, "ToArray should create an array with the same length"); + + byte[] expected = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; + CollectionAssert.AreEqual(expected, array, "Stack-allocated ReadOnlySpan ToArray should match expected values"); + } + + [TestMethod] + public void StackAllocReadOnlySpanCopyToTests() + { + // Create a ReadOnlySpan from stack-allocated memory + ReadOnlySpan source = stackalloc byte[8] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 }; + + // Create a destination Span + Span destination = new Span(new byte[8]); + + // Copy from stack-allocated ReadOnlySpan to heap-allocated Span + source.CopyTo(destination); + + // Verify the copy + for (int i = 0; i < source.Length; i++) + { + Assert.AreEqual(source[i], destination[i], $"Element at index {i} should match after CopyTo from stack-allocated span"); + } + } + + [TestMethod] + public void StackAllocEmptyReadOnlySpanTests() + { + // Create an empty stack-allocated ReadOnlySpan + ReadOnlySpan span = stackalloc byte[0]; + + Assert.AreEqual(0, span.Length, "Empty stack-allocated ReadOnlySpan should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty stack-allocated ReadOnlySpan should be IsEmpty"); + } + + [TestMethod] + public void ImplicitConversionFromArrayTests() + { + // Test implicit conversion from array to ReadOnlySpan + byte[] array = new byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 }; + + ReadOnlySpan span = array; // Implicit conversion + + Assert.AreEqual(array.Length, span.Length, "Implicitly converted ReadOnlySpan should have same length as array"); + + for (int i = 0; i < array.Length; i++) + { + Assert.AreEqual(array[i], span[i], $"Element at index {i} should match"); + } + } + + [TestMethod] + public void EqualityOperatorTests() + { + byte[] array1 = new byte[4] { 0x01, 0x02, 0x03, 0x04 }; + byte[] array2 = new byte[4] { 0x01, 0x02, 0x03, 0x04 }; + byte[] array3 = new byte[4] { 0x01, 0x02, 0x03, 0x05 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + ReadOnlySpan span3 = new ReadOnlySpan(array3); + + // Test equality with same content (content-based equality) + Assert.IsTrue(span1 == span2, "ReadOnlySpans with same content should be equal"); + Assert.IsFalse(span1 != span2, "ReadOnlySpans with same content should not be not-equal"); + + // Test inequality with different content + Assert.IsTrue(span1 != span3, "ReadOnlySpans with different content should not be equal"); + Assert.IsFalse(span1 == span3, "ReadOnlySpans with different content should not be equal"); + + // Test empty spans + ReadOnlySpan empty1 = new ReadOnlySpan(); + ReadOnlySpan empty2 = new ReadOnlySpan(); + + Assert.IsTrue(empty1 == empty2, "Empty ReadOnlySpans should be equal"); + Assert.IsFalse(empty1 != empty2, "Empty ReadOnlySpans should not be not-equal"); + } + + [TestMethod] + public void EqualityWithPartialSpansTests() + { + byte[] array1 = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + byte[] array2 = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + // Create two spans from different arrays with same content + ReadOnlySpan span1 = new ReadOnlySpan(array1, 2, 5); + ReadOnlySpan span2 = new ReadOnlySpan(array2, 2, 5); + + // They should be equal (content-based equality) + Assert.IsTrue(span1 == span2, "Partial spans with same content should be equal"); + Assert.IsFalse(span1 != span2, "Partial spans with same content should not be not-equal"); + + // Create span from different array with different content + byte[] array3 = new byte[10] { 0, 1, 2, 3, 99, 5, 6, 7, 8, 9 }; + ReadOnlySpan span3 = new ReadOnlySpan(array3, 2, 5); + Assert.IsFalse(span1 == span3, "Partial spans with different content should not be equal"); + Assert.IsTrue(span1 != span3, "Partial spans with different content should be not-equal"); + + // Create span with different length + ReadOnlySpan span4 = new ReadOnlySpan(array1, 2, 4); + Assert.IsFalse(span1 == span4, "Partial spans with different length should not be equal"); + Assert.IsTrue(span1 != span4, "Partial spans with different length should be not-equal"); + } + + [TestMethod] + public void EqualityWithSlicedSpansTests() + { + byte[] array1 = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + byte[] array2 = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + ReadOnlySpan originalSpan1 = new ReadOnlySpan(array1); + ReadOnlySpan originalSpan2 = new ReadOnlySpan(array2); + + // Create two slices from different arrays with same content + ReadOnlySpan slice1 = originalSpan1.Slice(2, 5); + ReadOnlySpan slice2 = originalSpan2.Slice(2, 5); + + // They should be equal (content-based equality) + Assert.IsTrue(slice1 == slice2, "Slices with same content should be equal"); + Assert.IsFalse(slice1 != slice2, "Slices with same content should not be not-equal"); + + // Create a slice with different content + byte[] array3 = new byte[10] { 0, 1, 2, 99, 4, 5, 6, 7, 8, 9 }; + ReadOnlySpan originalSpan3 = new ReadOnlySpan(array3); + ReadOnlySpan slice3 = originalSpan3.Slice(2, 5); + Assert.IsFalse(slice1 == slice3, "Slices with different content should not be equal"); + + // Create a slice with different length + ReadOnlySpan slice4 = originalSpan1.Slice(2, 4); + Assert.IsFalse(slice1 == slice4, "Slices with different length should not be equal"); + } + + [TestMethod] + public void EqualityWithNullArrayTests() + { + // Test equality with null-backed spans + ReadOnlySpan nullSpan1 = new ReadOnlySpan(null); + ReadOnlySpan nullSpan2 = new ReadOnlySpan(null); + ReadOnlySpan nullSpan3 = new ReadOnlySpan(null, 0, 0); + + // All null-backed spans should be equal (both are empty) + Assert.IsTrue(nullSpan1 == nullSpan2, "Null-backed spans should be equal"); + Assert.IsTrue(nullSpan1 == nullSpan3, "Null-backed spans with explicit 0,0 should be equal"); + Assert.IsFalse(nullSpan1 != nullSpan2, "Null-backed spans should not be not-equal"); + + // Compare with Empty + ReadOnlySpan emptySpan = ReadOnlySpan.Empty; + Assert.IsTrue(nullSpan1 == emptySpan, "Null-backed span should equal Empty span"); + } + + [TestMethod] + public void EqualityContentBasedTests() + { + // Create two arrays with identical content but different references + byte[] array1 = new byte[5] { 10, 20, 30, 40, 50 }; + byte[] array2 = new byte[5] { 10, 20, 30, 40, 50 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + + // ReadOnlySpans with same content should be equal (content-based equality) + Assert.IsTrue(span1 == span2, "ReadOnlySpans with same content should be equal"); + Assert.IsFalse(span1 != span2, "ReadOnlySpans with same content should not be not-equal"); + + // Now create another span from array1 + ReadOnlySpan span1Copy = new ReadOnlySpan(array1); + Assert.IsTrue(span1 == span1Copy, "ReadOnlySpans from same array should be equal"); + + // Modify array1 content + array1[2] = 99; + + // Spans should no longer be equal because content changed + Assert.IsFalse(span1 == span2, "ReadOnlySpans should not be equal after content changes"); + Assert.IsTrue(span1 != span2, "ReadOnlySpans should be not-equal after content changes"); + + // But span1 and span1Copy still reference the same array so should see same content + Assert.IsTrue(span1 == span1Copy, "ReadOnlySpans from same array should remain equal"); + } + + [TestMethod] + public void EqualityWithStackAllocatedSpansTests() + { + // Stack-allocated spans with same content should be equal + ReadOnlySpan stackSpan1 = stackalloc byte[5] { 1, 2, 3, 4, 5 }; + ReadOnlySpan stackSpan2 = stackalloc byte[5] { 1, 2, 3, 4, 5 }; + + // Stack-allocated spans with identical content should be equal (content-based) + Assert.IsTrue(stackSpan1 == stackSpan2, "Stack-allocated spans with same content should be equal"); + Assert.IsFalse(stackSpan1 != stackSpan2, "Stack-allocated spans with same content should not be not-equal"); + + // Stack-allocated spans with different content should not be equal + ReadOnlySpan stackSpan3 = stackalloc byte[5] { 1, 2, 99, 4, 5 }; + Assert.IsFalse(stackSpan1 == stackSpan3, "Stack-allocated spans with different content should not be equal"); + Assert.IsTrue(stackSpan1 != stackSpan3, "Stack-allocated spans with different content should be not-equal"); + + // Create a "copy" reference to the same stack span + ReadOnlySpan stackSpan1Copy = stackSpan1; + Assert.IsTrue(stackSpan1 == stackSpan1Copy, "Same stack-allocated span should equal itself"); + } + + [TestMethod] + public void EqualityTransitivityTests() + { + byte[] array1 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array2 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array3 = new byte[5] { 1, 2, 3, 4, 5 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + ReadOnlySpan span3 = new ReadOnlySpan(array3); + + // Test transitivity: if span1 == span2 and span2 == span3, then span1 == span3 + Assert.IsTrue(span1 == span2, "span1 should equal span2"); + Assert.IsTrue(span2 == span3, "span2 should equal span3"); + Assert.IsTrue(span1 == span3, "span1 should equal span3 (transitivity)"); + } + + [TestMethod] + public void EqualityReflexivityTests() + { + byte[] array = new byte[5] { 1, 2, 3, 4, 5 }; + ReadOnlySpan span = new ReadOnlySpan(array); + + // Test reflexivity: span should equal itself + Assert.IsTrue(span == span, "ReadOnlySpan should equal itself (reflexivity)"); + Assert.IsFalse(span != span, "ReadOnlySpan should not be not-equal to itself"); + + // Test with empty span + ReadOnlySpan emptySpan = ReadOnlySpan.Empty; + Assert.IsTrue(emptySpan == emptySpan, "Empty ReadOnlySpan should equal itself"); + } + + [TestMethod] + public void EqualitySymmetryTests() + { + byte[] array1 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array2 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array3 = new byte[5] { 1, 2, 99, 4, 5 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + ReadOnlySpan span3 = new ReadOnlySpan(array3); + + // Test symmetry: if span1 == span2, then span2 == span1 + Assert.IsTrue(span1 == span2, "span1 should equal span2"); + Assert.IsTrue(span2 == span1, "span2 should equal span1 (symmetry)"); + + // Test symmetry with inequality + Assert.IsFalse(span1 == span3, "span1 should not equal span3"); + Assert.IsFalse(span3 == span1, "span3 should not equal span1 (symmetry)"); + } + + [TestMethod] + public void EqualityWithDifferentOffsetsTests() + { + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + // Create spans with overlapping but different regions + ReadOnlySpan span1 = new ReadOnlySpan(array, 2, 5); // [2,3,4,5,6] + ReadOnlySpan span2 = new ReadOnlySpan(array, 3, 5); // [3,4,5,6,7] + + // They have different content so should not be equal + Assert.IsFalse(span1 == span2, "ReadOnlySpans with different content should not be equal"); + Assert.IsTrue(span1 != span2, "ReadOnlySpans with different content should be not-equal"); + + // Create span with same content from different array + byte[] array2 = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + ReadOnlySpan span3 = new ReadOnlySpan(array2, 2, 5); + Assert.IsTrue(span1 == span3, "ReadOnlySpans with same content should be equal"); + } + + [TestMethod] + public void EqualityZeroLengthSpansTests() + { + byte[] array1 = new byte[10]; + byte[] array2 = new byte[10]; + + // Create zero-length spans from different arrays + ReadOnlySpan zeroSpan1 = new ReadOnlySpan(array1, 5, 0); + ReadOnlySpan zeroSpan2 = new ReadOnlySpan(array2, 3, 0); + + // Zero-length spans should be equal (both empty, content-based) + Assert.IsTrue(zeroSpan1 == zeroSpan2, "Zero-length spans should be equal"); + Assert.IsFalse(zeroSpan1 != zeroSpan2, "Zero-length spans should not be not-equal"); + + // Zero-length span from same array with different offset + ReadOnlySpan zeroSpan3 = new ReadOnlySpan(array1, 7, 0); + Assert.IsTrue(zeroSpan1 == zeroSpan3, "Zero-length spans should be equal regardless of offset"); + + // Compare with Empty + ReadOnlySpan emptySpan = ReadOnlySpan.Empty; + Assert.IsTrue(zeroSpan1 == emptySpan, "Zero-length span should equal Empty span"); + } + + [TestMethod] + public void EqualityDifferentLengthsTests() + { + byte[] array1 = new byte[6] { 1, 2, 3, 4, 5, 6 }; + byte[] array2 = new byte[4] { 1, 2, 3, 4 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + + // Spans with different lengths should not be equal + Assert.IsFalse(span1 == span2, "ReadOnlySpans with different lengths should not be equal"); + Assert.IsTrue(span1 != span2, "ReadOnlySpans with different lengths should be not-equal"); + + // Test with partial spans that have same initial content but different lengths + byte[] array3 = new byte[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + ReadOnlySpan span3 = new ReadOnlySpan(array3, 0, 4); + ReadOnlySpan span4 = new ReadOnlySpan(array3, 0, 6); + + Assert.IsFalse(span3 == span4, "Partial spans with different lengths should not be equal"); + } + + [TestMethod] + public void EqualityPartialContentMatchTests() + { + // Test equality when only part of the content matches + byte[] array1 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array2 = new byte[5] { 1, 2, 99, 4, 5 }; + + ReadOnlySpan span1 = new ReadOnlySpan(array1); + ReadOnlySpan span2 = new ReadOnlySpan(array2); + + // Should not be equal (one element differs) + Assert.IsFalse(span1 == span2, "ReadOnlySpans with partial content match should not be equal"); + Assert.IsTrue(span1 != span2, "ReadOnlySpans with partial content match should be not-equal"); + + // Test with matching prefix + ReadOnlySpan span1Prefix = span1.Slice(0, 2); + ReadOnlySpan span2Prefix = span2.Slice(0, 2); + Assert.IsTrue(span1Prefix == span2Prefix, "ReadOnlySpans with matching prefix should be equal"); + + // Test with matching suffix + ReadOnlySpan span1Suffix = span1.Slice(3, 2); + ReadOnlySpan span2Suffix = span2.Slice(3, 2); + Assert.IsTrue(span1Suffix == span2Suffix, "ReadOnlySpans with matching suffix should be equal"); + } + } +} diff --git a/Tests/NFUnitTestTypes/UnitTestsSpanByte.cs b/Tests/NFUnitTestTypes/UnitTestsSpanByte.cs index e4ffde13..90fa50da 100644 --- a/Tests/NFUnitTestTypes/UnitTestsSpanByte.cs +++ b/Tests/NFUnitTestTypes/UnitTestsSpanByte.cs @@ -13,13 +13,15 @@ public class UnitTestsSpanByte public void EmptySpanTests() { // Empty span - SpanByte span = SpanByte.Empty; + Span span = Span.Empty; // Create a destination span larger - SpanByte destination = new byte[1]; + Span destination = new Span(new byte[1]); + span.CopyTo(destination); // Now also empty - destination = SpanByte.Empty; + destination = Span.Empty; + span.CopyTo(destination); } @@ -27,56 +29,270 @@ public void EmptySpanTests() public void RaisingExceptionsOfAllKindsTests() { // Should raise an exception on creation - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2"); - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2"); + Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0"); // Exception on index access byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var data = span[span.Length]; - }); + Span span = new Span(array); + _ = span[span.Length]; + }, "IndexOutOfRangeException when accessing index equal to Length"); + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var data = span[-1]; - }); + Span span = new Span(array); + _ = span[-1]; + }, "IndexOutOfRangeException when accessing negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + Span span = new Span(array); + _ = span[span.Length + 1]; + }, "IndexOutOfRangeException when accessing index beyond Length"); // Copy to with too small destination Assert.ThrowsException(typeof(ArgumentException), () => { - SpanByte span = new SpanByte(array); - SpanByte destination = new byte[span.Length - 1]; + Span span = new Span(array); + Span destination = new Span(new byte[span.Length - 1]); + span.CopyTo(destination); }); // Slicing arguments Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var sliced = span.Slice(span.Length + 1); + Span span = new Span(array); + _ = span.Slice(span.Length + 1); }); Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var sliced = span.Slice(1, span.Length); + Span span = new Span(array); + _ = span.Slice(1, span.Length); }); Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var sliced = span.Slice(-1, span.Length); + Span span = new Span(array); + _ = span.Slice(-1, span.Length); }); Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { - SpanByte span = new SpanByte(array); - var sliced = span.Slice(1, -1); + Span span = new Span(array); + _ = span.Slice(1, -1); }); + } + + [TestMethod] + public void IndexOutOfRangeExceptionTests() + { + // Comprehensive tests for IndexOutOfRangeException + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + Span span = new Span(array); + + // Test reading at exact boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSpanElement(array, 10); + }, "Should throw IndexOutOfRangeException at index equal to Length"); + + // Test reading beyond boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSpanElement(array, 100); + }, "Should throw IndexOutOfRangeException at large index"); + + // Test negative index + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSpanElement(array, -1); + }, "Should throw IndexOutOfRangeException at negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetSpanElement(array, -100); + }, "Should throw IndexOutOfRangeException at large negative index"); + + // Test writing at exact boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + SetSpanElement(array, 10, 99); + }, "Should throw IndexOutOfRangeException when writing at index equal to Length"); + + // Test writing beyond boundary + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + SetSpanElement(array, 100, 99); + }, "Should throw IndexOutOfRangeException when writing at large index"); + + // Test writing at negative index + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + SetSpanElement(array, -1, 99); + }, "Should throw IndexOutOfRangeException when writing at negative index"); + + // Valid access should not throw + byte value = span[0]; + Assert.AreEqual((byte)0, value, "Valid index 0 should return correct value"); + value = span[9]; + Assert.AreEqual((byte)9, value, "Valid index 9 should return correct value"); + + span[5] = 99; + Assert.AreEqual((byte)99, span[5], "Valid write should succeed"); + } + + // Helper methods to avoid capturing ref struct in lambdas + private static byte GetSpanElement(byte[] array, int index) + { + Span span = new Span(array); + return span[index]; + } + + private static void SetSpanElement(byte[] array, int index, byte value) + { + Span span = new Span(array); + span[index] = value; + } + + private static byte GetPartialSpanElement(byte[] array, int start, int length, int index) + { + Span span = new Span(array, start, length); + return span[index]; + } + + private static byte GetEmptySpanElement(int index) + { + Span span = Span.Empty; + return span[index]; + } + + private static void SetEmptySpanElement(int index, byte value) + { + Span span = Span.Empty; + span[index] = value; + } + + private static byte GetNullSpanElement(int index) + { + Span span = new Span(null); + return span[index]; + } + + [TestMethod] + public void PartialSpanIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with partial spans + byte[] array = new byte[20]; + Span span = new Span(array, 5, 10); + + // Should have length 10 + Assert.AreEqual(10, span.Length, "Partial span should have length 10"); + + // Valid access + byte value = span[0]; + span[0] = 1; + value = span[9]; + span[9] = 1; + + // Invalid access + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetPartialSpanElement(array, 5, 10, 10); + }, "Should throw IndexOutOfRangeException at index equal to partial span Length"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetPartialSpanElement(array, 5, 10, -1); + }, "Should throw IndexOutOfRangeException at negative index in partial span"); + } + + [TestMethod] + public void EmptySpanIndexOutOfRangeExceptionTests() + { + // Test IndexOutOfRangeException with empty spans + Span emptySpan = Span.Empty; + + Assert.AreEqual(0, emptySpan.Length, "Empty span should have length 0"); + + // Any index access should throw + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetEmptySpanElement(0); + }, "Should throw IndexOutOfRangeException on empty span at index 0"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetEmptySpanElement(-1); + }, "Should throw IndexOutOfRangeException on empty span at negative index"); + + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + SetEmptySpanElement(0, 1); + }, "Should throw IndexOutOfRangeException when writing to empty span"); + } + + [TestMethod] + public void NullableArrayFieldTests() + { + // Test that nullable _array field works correctly + + // Span from null array (tests nullable _array field) + Span nullSpan = new Span(null); + Assert.AreEqual(0, nullSpan.Length, "Span from null should have length 0"); + Assert.IsTrue(nullSpan.IsEmpty, "Span from null should be empty"); + + // Span from null with zero start and length + nullSpan = new Span(null, 0, 0); + Assert.AreEqual(0, nullSpan.Length, "Span from null with 0,0 should have length 0"); + Assert.IsTrue(nullSpan.IsEmpty, "Span from null with 0,0 should be empty"); + + // Try to access element in empty span (should throw) + Assert.ThrowsException(typeof(IndexOutOfRangeException), () => + { + _ = GetNullSpanElement(0); + }, "Should throw IndexOutOfRangeException when accessing null-based span"); + + // Copy from null-based span should work + Span destination = new Span(new byte[5]); + nullSpan.CopyTo(destination); // Should not throw + + // ToArray should work + byte[] array = nullSpan.ToArray(); + Assert.AreEqual(0, array.Length, "ToArray on null-based span should return empty array"); + + // Clear should work (no-op on empty span) + nullSpan.Clear(); // Should not throw + + // Slice should work + Span sliced = nullSpan.Slice(0); + Assert.AreEqual(0, sliced.Length, "Slicing null-based span should return empty span"); + } + + [TestMethod] + public void ClearWithNullableArrayTests() + { + // Clear on empty span (null array) + Span emptySpan = new Span(null); + emptySpan.Clear(); // Should not throw + Assert.IsTrue(emptySpan.IsEmpty, "Empty span should remain empty after Clear"); + + // Clear on normal span + byte[] array = new byte[5] { 1, 2, 3, 4, 5 }; + Span span = new Span(array); + span.Clear(); + + // Verify all elements are cleared + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)0, span[i], $"Element at index {i} should be 0 after Clear"); + Assert.AreEqual((byte)0, array[i], $"Original array element at index {i} should be 0 after Clear"); + } } [TestMethod] @@ -84,39 +300,66 @@ public void ToArrayTest() { byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - SpanByte span = new(array); + Span span = new(array); byte[] toArray = span.ToArray(); CollectionAssert.AreEqual(array, toArray, "Original array and SpanByte.ToArray should be the same"); } + [TestMethod] + public void ToArrayWithNullableArrayTests() + { + // Test ToArray with nullable array field + + // Empty span from null + Span emptySpan = new Span(null); + byte[] emptyArray = emptySpan.ToArray(); + Assert.AreEqual(0, emptyArray.Length, "ToArray on null-based span should return empty array"); + + // Partial span + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + Span partialSpan = new Span(array, 3, 5); + byte[] partialArray = partialSpan.ToArray(); + + Assert.AreEqual(5, partialArray.Length, "Partial span ToArray should have correct length"); + for (int i = 0; i < 5; i++) + { + Assert.AreEqual(array[i + 3], partialArray[i], $"Partial array element {i} should match"); + } + } + [TestMethod] public void ConstructorsOfAllKindsTests() { // Empty span - SpanByte span = new SpanByte(); + Span span = new Span(); + Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0"); Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty"); - // Empty span - span = new SpanByte(null, 0, 0); + // Empty span from null with zero start and length (tests nullable _array) + span = new Span(null, 0, 0); + Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0"); Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty"); // Empty span - span = SpanByte.Empty; + span = Span.Empty; + Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0"); Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty"); - // Span from normal array + // Spanfrom normal array byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - span = new SpanByte(array); + span = new Span(array); + Assert.AreEqual(span.Length, array.Length, $"SpanByte should have length of the array it takes: {array.Length}"); Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty"); - // Span from normal array with different start and length - span = new SpanByte(array, 2, 8); + // Spanfrom normal array with different start and length + span = new Span(array, 2, 8); + Assert.AreEqual(span.Length, 8, $"SpanByte should have length of 8"); Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty"); } @@ -124,17 +367,20 @@ public void ConstructorsOfAllKindsTests() [TestMethod] public void SliceTests() { - // Span from normal array + // Spanfrom normal array byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - SpanByte span = new SpanByte(array); + Span span = new Span(array); + // Slice 2 elements and check - var sliced = span.Slice(0, 2); + Span sliced = span.Slice(0, 2); + Assert.AreEqual(sliced.Length, 2, "Sliced span lenght must be 2"); Assert.AreEqual(sliced[0], (byte)0x00, "Sliced first element must be value 0"); Assert.AreEqual(sliced[1], (byte)0x01, "Sliced first element must be value 1"); // Slide 4 elements starting at index 2 and check sliced = span.Slice(2, 4); + Assert.AreEqual(sliced.Length, 4, "Sliced span lenght must be 4"); Assert.AreEqual(sliced[0], (byte)0x02, "Sliced first element must be value 2"); Assert.AreEqual(sliced[1], (byte)0x03, "Sliced first element must be value 3"); @@ -143,22 +389,27 @@ public void SliceTests() // Slide starting 4 at element check sliced = span.Slice(4); + Assert.AreEqual(sliced.Length, 12, "Sliced span lenght must be 12"); + for (int i = 0; i < sliced.Length; i++) { Assert.AreEqual(sliced[i], span[i + 4], "SpanByte value should be the same as from the original span"); } // Slice of slice - var secondSliced = sliced.Slice(2, 4); + Span secondSliced = sliced.Slice(2, 4); + Assert.AreEqual(secondSliced.Length, 4, "Sliced span lenght must be 12"); + for (int i = 0; i < secondSliced.Length; i++) { Assert.AreEqual(secondSliced[i], sliced[i + 2], "SpanByte value should be the same as from the original span"); } // Should be an empty one - var empty = span.Slice(span.Length); + Span empty = span.Slice(span.Length); + Assert.AreEqual(empty.Length, 0, "slicing all the span should result in an empty span"); Assert.IsTrue(empty.IsEmpty, "Empty span should be empty"); } @@ -167,39 +418,42 @@ public void SliceTests() public void CopyToTests() { byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - SpanByte span = new SpanByte(array); + Span span = new Span(array); + // First a copy to with the full span - SpanByte toCopy = new byte[span.Length]; + Span toCopy = new Span(new byte[span.Length]); + span.CopyTo(toCopy); - for (int i = 0; i < span.Length; i++) - { - Assert.AreEqual(toCopy[i], span[i], "SpanByte value should be the same as from the original array"); - } + + CollectionAssert.AreEqual(array, toCopy.ToArray(), "Original array and SpanByte.CopyTo should be the same"); // Now create a larger span - toCopy = new byte[span.Length + 1]; + toCopy = new Span(new byte[span.Length + 1]); span.CopyTo(toCopy); - for (int i = 0; i < span.Length; i++) - { - Assert.AreEqual(toCopy[i], span[i], "SpanByte value should be the same as from the original array"); - } - Assert.AreEqual(toCopy[span.Length], (byte)0); + Assert.AreEqual(toCopy.Length, span.Length + 1); + + byte[] tempArray = new byte[span.Length + 1]; + Array.Copy(array, tempArray, array.Length); + + CollectionAssert.AreEqual(tempArray, toCopy.ToArray(), "Original array and SpanByte.CopyTo should be the same with larger destination"); + + Assert.AreEqual(toCopy[toCopy.Length - 1], (byte)0, "Last byte should be 0 (byte default)"); } [TestMethod] public void GetElementsTests() { - // Span from normal array + // Spanfrom normal array byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; - SpanByte span = new SpanByte(array); + Span span = new Span(array); for (int i = 0; i < span.Length; i++) { Assert.AreEqual(span[i], array[i], "SpanByte value should be the same as from the original array"); } // Partial span - span = new SpanByte(array, 2, 8); + span = new Span(array, 2, 8); for (int i = 0; i < span.Length; i++) { Assert.AreEqual(span[i], array[i + 2], "SpanByte value should be the same as from the original array"); @@ -210,11 +464,13 @@ public void GetElementsTests() public void SetElementsTests() { // Create a span, and set the data - SpanByte span = new byte[12]; + Span span = new Span(new byte[12]); + // All should be 0 for (int i = 0; i < span.Length; i++) { Assert.AreEqual(span[i], (byte)0, "SpanByte value should be 0"); + // Set a value span[i] = (byte)i; } @@ -225,5 +481,372 @@ public void SetElementsTests() Assert.AreEqual(span[i], (byte)i, "SpanByte value should be the same as setup in the set method"); } } + + [TestMethod] + public void ImplicitConversionToReadOnlySpanTests() + { + // Test implicit conversion from Span to ReadOnlySpan + byte[] array = new byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 }; + Span span = new Span(array); + + // Implicit conversion + ReadOnlySpan readOnlySpan = span; + + Assert.AreEqual(span.Length, readOnlySpan.Length, "Converted ReadOnlySpan should have same length"); + + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual(span[i], readOnlySpan[i], $"Element at index {i} should match after conversion"); + } + + // Test with empty span + Span emptySpan = Span.Empty; + ReadOnlySpan emptyReadOnly = emptySpan; + Assert.AreEqual(0, emptyReadOnly.Length, "Converted empty ReadOnlySpan should have length 0"); + } + + [TestMethod] + public void StackAllocSpanTests() + { + // Create a span from stack-allocated memory + Span span = stackalloc byte[16]; + + Assert.AreEqual(16, span.Length, "Stack-allocated span should have length of 16"); + Assert.IsFalse(span.IsEmpty, "Stack-allocated span should NOT be IsEmpty"); + + // Verify all elements are initialized to zero + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)0, span[i], "Stack-allocated span elements should be initialized to 0"); + } + + // Set values in the stack-allocated span + for (int i = 0; i < span.Length; i++) + { + span[i] = (byte)(i * 2); + } + + // Verify the values were set correctly + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)(i * 2), span[i], $"Stack-allocated span element at index {i} should be {i * 2}"); + } + } + + [TestMethod] + public void StackAllocSpanWithInitializerTests() + { + // Create a span from stack-allocated memory with initializer + Span span = stackalloc byte[8] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + + Assert.AreEqual(8, span.Length, "Stack-allocated span with initializer should have length of 8"); + Assert.IsFalse(span.IsEmpty, "Stack-allocated span should NOT be IsEmpty"); + + // Verify the initialized values + for (int i = 0; i < span.Length; i++) + { + Assert.AreEqual((byte)(i + 1), span[i], $"Stack-allocated span element at index {i} should be {i + 1}"); + } + } + + [TestMethod] + public void StackAllocSpanSliceTests() + { + // Create a span from stack-allocated memory + Span span = stackalloc byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; + + // Slice the stack-allocated span + Span sliced = span.Slice(4, 8); + + Assert.AreEqual(8, sliced.Length, "Sliced stack-allocated span should have length of 8"); + + for (int i = 0; i < sliced.Length; i++) + { + Assert.AreEqual((byte)(i + 4), sliced[i], $"Sliced element at index {i} should be {i + 4}"); + } + + // Modify the sliced span and verify it affects the original + sliced[0] = 0xFF; + Assert.AreEqual((byte)0xFF, span[4], "Modifying sliced span should affect the original stack-allocated span"); + } + + [TestMethod] + public void StackAllocSpanCopyToTests() + { + // Create a span from stack-allocated memory + Span source = stackalloc byte[8] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 }; + + // Create a destination span (also stack-allocated) + Span destination = stackalloc byte[8]; + + // Copy from source to destination + source.CopyTo(destination); + + // Verify the copy + for (int i = 0; i < destination.Length; i++) + { + Assert.AreEqual(source[i], destination[i], $"Copied element at index {i} should match source"); + } + + // Copy to a heap-allocated array + byte[] heapArray = new byte[8]; + Span heapSpan = new Span(heapArray); + source.CopyTo(heapSpan); + + CollectionAssert.AreEqual(source.ToArray(), heapArray, "Stack-allocated span should copy correctly to heap-allocated array"); + } + + [TestMethod] + public void StackAllocSpanToArrayTests() + { + // Create a span from stack-allocated memory + Span span = stackalloc byte[6] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; + + // Convert to array + byte[] array = span.ToArray(); + + Assert.AreEqual(6, array.Length, "ToArray should create an array with the same length"); + + byte[] expected = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; + CollectionAssert.AreEqual(expected, array, "Stack-allocated span ToArray should match expected values"); + } + + [TestMethod] + public void StackAllocEmptySpanTests() + { + // Create an empty stack-allocated span + Span span = stackalloc byte[0]; + + Assert.AreEqual(0, span.Length, "Empty stack-allocated span should have length of 0"); + Assert.IsTrue(span.IsEmpty, "Empty stack-allocated span should be IsEmpty"); + } + + [TestMethod] + public void EqualityOperatorTests() + { + byte[] array1 = new byte[4] { 0x01, 0x02, 0x03, 0x04 }; + byte[] array2 = new byte[4] { 0x01, 0x02, 0x03, 0x04 }; + + Span span1 = new Span(array1); + Span span2 = new Span(array2); + Span span1Again = new Span(array1); + + // Test equality - should check reference and length, not content + Assert.IsTrue(span1 == span1Again, "Spans pointing to same array should be equal"); + Assert.IsFalse(span1 == span2, "Spans pointing to different arrays should not be equal"); + + // Test inequality + Assert.IsFalse(span1 != span1Again, "Spans pointing to same array should not be not-equal"); + Assert.IsTrue(span1 != span2, "Spans pointing to different arrays should be not-equal"); + + // Test with different lengths on same array + Span span1Partial = new Span(array1, 0, 2); + Assert.IsFalse(span1 == span1Partial, "Spans with different lengths should not be equal"); + Assert.IsTrue(span1 != span1Partial, "Spans with different lengths should be not-equal"); + + // Test empty spans + Span empty1 = new Span(); + Span empty2 = new Span(); + Assert.IsTrue(empty1 == empty2, "Empty spans should be equal"); + Assert.IsFalse(empty1 != empty2, "Empty spans should not be not-equal"); + } + + [TestMethod] + public void EqualityWithPartialSpansTests() + { + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + // Create two spans from the same array with same start and length + Span span1 = new Span(array, 2, 5); + Span span2 = new Span(array, 2, 5); + + // They should be equal (same array, same start, same length) + Assert.IsTrue(span1 == span2, "Partial spans from same array with same parameters should be equal"); + Assert.IsFalse(span1 != span2, "Partial spans from same array with same parameters should not be not-equal"); + + // Create span from same array but different start + Span span3 = new Span(array, 3, 5); + Assert.IsFalse(span1 == span3, "Partial spans with different start should not be equal"); + Assert.IsTrue(span1 != span3, "Partial spans with different start should be not-equal"); + + // Create span from same array but different length + Span span4 = new Span(array, 2, 4); + Assert.IsFalse(span1 == span4, "Partial spans with different length should not be equal"); + Assert.IsTrue(span1 != span4, "Partial spans with different length should be not-equal"); + } + + [TestMethod] + public void EqualityWithSlicedSpansTests() + { + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + Span originalSpan = new Span(array); + + // Create two slices from the same original span + Span slice1 = originalSpan.Slice(2, 5); + Span slice2 = originalSpan.Slice(2, 5); + + // They should be equal (same underlying array, same region) + Assert.IsTrue(slice1 == slice2, "Slices from same span with same parameters should be equal"); + + // Create a slice with different parameters + Span slice3 = originalSpan.Slice(3, 5); + Assert.IsFalse(slice1 == slice3, "Slices with different start should not be equal"); + + // Create a slice with different length + Span slice4 = originalSpan.Slice(2, 4); + Assert.IsFalse(slice1 == slice4, "Slices with different length should not be equal"); + } + + [TestMethod] + public void EqualityWithNullArrayTests() + { + // Test equality with null-backed spans + Span nullSpan1 = new Span(null); + Span nullSpan2 = new Span(null); + Span nullSpan3 = new Span(null, 0, 0); + + // All null-backed spans should be equal + Assert.IsTrue(nullSpan1 == nullSpan2, "Null-backed spans should be equal"); + Assert.IsTrue(nullSpan1 == nullSpan3, "Null-backed spans with explicit 0,0 should be equal"); + Assert.IsFalse(nullSpan1 != nullSpan2, "Null-backed spans should not be not-equal"); + + // Compare with Empty + Span emptySpan = Span.Empty; + Assert.IsTrue(nullSpan1 == emptySpan, "Null-backed span should equal Empty span"); + } + + [TestMethod] + public void EqualityReferenceVsContentTests() + { + // Create two arrays with identical content + byte[] array1 = new byte[5] { 10, 20, 30, 40, 50 }; + byte[] array2 = new byte[5] { 10, 20, 30, 40, 50 }; + + Span span1 = new Span(array1); + Span span2 = new Span(array2); + + // Even though content is identical, spans should not be equal + // because they reference different arrays + Assert.IsFalse(span1 == span2, "Spans with same content but different arrays should not be equal"); + Assert.IsTrue(span1 != span2, "Spans with same content but different arrays should be not-equal"); + + // Now create another span from array1 + Span span1Copy = new Span(array1); + Assert.IsTrue(span1 == span1Copy, "Spans referencing the same array should be equal"); + Assert.IsFalse(span1 != span1Copy, "Spans referencing the same array should not be not-equal"); + + // Modify array1 content + array1[2] = 99; + + // Spans should still be equal because they reference the same array + Assert.IsTrue(span1 == span1Copy, "Spans referencing same array should remain equal even after content changes"); + } + + [TestMethod] + public void EqualityWithStackAllocatedSpansTests() + { + // Stack-allocated spans are backed by different memory locations + Span stackSpan1 = stackalloc byte[5] { 1, 2, 3, 4, 5 }; + Span stackSpan2 = stackalloc byte[5] { 1, 2, 3, 4, 5 }; + + // Stack-allocated spans should not be equal (different memory locations) + Assert.IsFalse(stackSpan1 == stackSpan2, "Different stack-allocated spans should not be equal"); + Assert.IsTrue(stackSpan1 != stackSpan2, "Different stack-allocated spans should be not-equal"); + + // Create a "copy" reference to the same stack span + Span stackSpan1Copy = stackSpan1; + Assert.IsTrue(stackSpan1 == stackSpan1Copy, "Same stack-allocated span should equal itself"); + Assert.IsFalse(stackSpan1 != stackSpan1Copy, "Same stack-allocated span should not be not-equal to itself"); + } + + [TestMethod] + public void EqualityTransitivityTests() + { + byte[] array = new byte[5] { 1, 2, 3, 4, 5 }; + + Span span1 = new Span(array); + Span span2 = new Span(array); + Span span3 = new Span(array); + + // Test transitivity: if span1 == span2 and span2 == span3, then span1 == span3 + Assert.IsTrue(span1 == span2, "span1 should equal span2"); + Assert.IsTrue(span2 == span3, "span2 should equal span3"); + Assert.IsTrue(span1 == span3, "span1 should equal span3 (transitivity)"); + } + + [TestMethod] + public void EqualityReflexivityTests() + { + byte[] array = new byte[5] { 1, 2, 3, 4, 5 }; + Span span = new Span(array); + + // Test reflexivity: span should equal itself + Assert.IsTrue(span == span, "Span should equal itself (reflexivity)"); + Assert.IsFalse(span != span, "Span should not be not-equal to itself"); + + // Test with empty span + Span emptySpan = Span.Empty; + Assert.IsTrue(emptySpan == emptySpan, "Empty span should equal itself"); + } + + [TestMethod] + public void EqualitySymmetryTests() + { + byte[] array1 = new byte[5] { 1, 2, 3, 4, 5 }; + byte[] array2 = new byte[5] { 1, 2, 3, 4, 5 }; + + Span span1 = new Span(array1); + Span span2 = new Span(array2); + + // Test symmetry: if span1 == span2, then span2 == span1 + bool forward = span1 == span2; + bool backward = span2 == span1; + Assert.AreEqual(forward, backward, "Equality should be symmetric"); + + // Test with same array + Span span1Copy = new Span(array1); + Assert.IsTrue(span1 == span1Copy, "span1 should equal span1Copy"); + Assert.IsTrue(span1Copy == span1, "span1Copy should equal span1 (symmetry)"); + } + + [TestMethod] + public void EqualityWithDifferentOffsetsTests() + { + byte[] array = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + // Create spans with overlapping but different regions + Span span1 = new Span(array, 2, 5); // [2,3,4,5,6] + Span span2 = new Span(array, 3, 5); // [3,4,5,6,7] + + // Even though they overlap and have the same length, they should not be equal + Assert.IsFalse(span1 == span2, "Spans with different offsets should not be equal"); + Assert.IsTrue(span1 != span2, "Spans with different offsets should be not-equal"); + + // Create span with same offset and length + Span span3 = new Span(array, 2, 5); + Assert.IsTrue(span1 == span3, "Spans with same array, offset, and length should be equal"); + } + + [TestMethod] + public void EqualityZeroLengthSpansTests() + { + byte[] array1 = new byte[10]; + byte[] array2 = new byte[10]; + + // Create zero-length spans from different arrays + Span zeroSpan1 = new Span(array1, 5, 0); + Span zeroSpan2 = new Span(array2, 3, 0); + + // Zero-length spans from different arrays should not be equal + Assert.IsFalse(zeroSpan1 == zeroSpan2, "Zero-length spans from different arrays should not be equal"); + + // Zero-length spans from same array should be equal only if they have the same parameters + Span zeroSpan3 = new Span(array1, 5, 0); + Assert.IsTrue(zeroSpan1 == zeroSpan3, "Zero-length spans from same array with same offset should be equal"); + + // Compare with Empty + Span emptySpan = Span.Empty; + Assert.IsFalse(zeroSpan1 == emptySpan, "Zero-length span from array should not equal Empty span (different backing)"); + } } } diff --git a/Tests/UnitTestLauncher/UnitTestLauncher.nfproj b/Tests/UnitTestLauncher/UnitTestLauncher.nfproj index b03d676e..646eace2 100644 --- a/Tests/UnitTestLauncher/UnitTestLauncher.nfproj +++ b/Tests/UnitTestLauncher/UnitTestLauncher.nfproj @@ -27,7 +27,7 @@ - + diff --git a/azure-pipelines-templates/check-nf-interpreter-to-test.yml b/azure-pipelines-templates/check-nf-interpreter-to-test.yml new file mode 100644 index 00000000..09fc12ea --- /dev/null +++ b/azure-pipelines-templates/check-nf-interpreter-to-test.yml @@ -0,0 +1,72 @@ +# Copyright (c) .NET Foundation and Contributors +# See LICENSE file in the project root for full license information. + +steps: + - task: PowerShell@2 + displayName: Check nf-interpreter to test + condition: ne(variables['System.PullRequest.PullRequestNumber'], '') + inputs: + failOnStderr: false + targetType: "inline" + script: | + + # prepare GitHub API headers using token auth + $headers = @{ + Authorization = "token $env:GITHUB_TOKEN" + 'User-Agent' = 'azure-pipelines' + Accept = 'application/vnd.github+json' + } + + # find PR + "Getting PR #$env:System_PullRequest_PullRequestNumber details..." | Write-Host -ForegroundColor White -NoNewline + $pr = Invoke-RestMethod ` + -Uri "https://api.github.com/repos/$env:Build_Repository_Name/pulls/$env:System_PullRequest_PullRequestNumber" ` + -Headers $headers ` + -Method GET + + if($($pr.number) -eq "$env:System_PullRequest_PullRequestNumber") + { + 'OK' | Write-Host -ForegroundColor Green + } + + # grab PR commit message + $prCommitMessage = $($pr.body) + + # look for test prompt in PR commit message + # pattern is "[tested against nanoclr buildId NNN]" + + if($prCommitMessage -match "\[tested against nanoclr buildId (\d+)\]") + { + $buildId = $matches[1] + "AZDO build ID found: $buildId" | Write-Host -ForegroundColor White + + echo "##vso[task.setvariable variable=NFINTERPRETER_BUILDID]$buildId" + } + else + { + "No build ID found" | Write-Host -ForegroundColor Red + } + env: + GITHUB_TOKEN: $(GitHubToken) + + - task: DownloadPipelineArtifact@2 + condition: ne(variables['NFINTERPRETER_BUILDID'], '') + displayName: Download nanoCLR preview + inputs: + buildType: specific + project: 'nf-interpreter' + definition: '34' + buildVersionToDownload: specific + allowFailedBuilds: true + buildId: $(NFINTERPRETER_BUILDID) + artifactName: 'nanoclr_cli' + targetPath: '$(Agent.TempDirectory)/nanoclr_cli' + + - task: PowerShell@2 + condition: ne(variables['NFINTERPRETER_BUILDID'], '') + displayName: Flag availability of local nanoCLR + name: NANOCLR_CHECK + inputs: + targetType: 'inline' + script: | + Write-Host "##vso[task.setvariable variable=HAS_LOCAL_NANOCLR;isOutput=true]true" diff --git a/azure-pipelines.yml b/azure-pipelines.yml index 552271dd..ac674479 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -20,10 +20,6 @@ trigger: - assets/* - nanoFramework.TestFramework/* - tags: - include: - - v* - # PR always trigger build pr: autoCancel: true @@ -60,6 +56,8 @@ jobs: variables: - group: sign-client-credentials + - name: DOTNET_NOLOGO + value: true - name: buildPlatform value: 'Any CPU' - name: buildConfiguration @@ -71,13 +69,30 @@ jobs: - template: azure-pipelines-templates/process-pr-labels.yml@templates + - template: azure-pipelines-templates/check-nf-interpreter-to-test.yml + + - task: PowerShell@2 + displayName: Set unit test runsettings path + inputs: + targetType: 'inline' + script: | + $hasLocalNanoClr = $env:NANOCLR_CHECK_HAS_LOCAL_NANOCLR + if ($hasLocalNanoClr -eq 'true') { + Write-Host "##vso[task.setvariable variable=UNIT_TEST_RUNSETTINGS]$(System.DefaultWorkingDirectory)\local_clr.runsettings" + } else { + Write-Host "##vso[task.setvariable variable=UNIT_TEST_RUNSETTINGS]$(System.DefaultWorkingDirectory)\.runsettings" + } + env: + HAS_LOCAL_NANOCLR: $[ dependencies['check-nf-interpreter-to-test'].outputs['Flag_availability_of_local_nanoCLR.HAS_LOCAL_NANOCLR'] ] + # build steps only - template: azure-pipelines-templates/class-lib-build-only.yml@templates parameters: sonarCloudProject: 'nanoframework_lib-CoreLibrary' runUnitTests: ${{ ne(variables['processPrLabels.SKIP_UNIT_TESTS'], 'true') }} - unitTestRunsettings: '$(System.DefaultWorkingDirectory)\.runsettings' - skipNuGetCache: true + unitTestRunsettings: $(UNIT_TEST_RUNSETTINGS) + skipNuGetCache: false + usePreviewBuild: true # rebuild CoreLibrary project to get the assembly checksum - task: MSBuild@1 @@ -120,17 +135,21 @@ jobs: parameters: nugetPackageName: 'nanoFramework.CoreLibrary.NoReflection' - - template: azure-pipelines-templates/class-lib-publish.yml@templates + - template: azure-pipelines-templates/class-lib-publish.yml@templates + parameters: + baseBranchName: 'develop' - # create or update GitHub release ON tags from release + # create or update GitHub release ON tags - task: GithubRelease@1 condition: >- and( succeeded(), eq(variables['System.PullRequest.PullRequestId'], ''), - startsWith(variables['Build.SourceBranch'], 'refs/heads/main'), - not(contains(variables['Build.SourceBranch'], 'preview')), - eq(variables['StartReleaseCandidate'], false) + eq(variables['StartReleaseCandidate'], false), + or( + eq(variables['Build.SourceBranchName'], 'main'), + eq(variables['Build.SourceBranchName'], 'develop') + ) ) displayName: Create/Update GitHub stable release inputs: @@ -143,7 +162,7 @@ jobs: releaseNotesInline: 'Check the [changelog]($(Build.Repository.Uri)/blob/$(Build.SourceBranchName)/CHANGELOG.md).

Install from NuGet


The following NuGet packages are available for download from this release:
:package: [.NET](https://www.nuget.org/packages/$(nugetPackageName)/$(MY_NUGET_VERSION)) v$(MY_NUGET_VERSION).
:package: [.NET (without Reflection)](https://www.nuget.org/packages/$(nugetPackageName).NoReflection/$(MY_NUGET_VERSION)) v$(MY_NUGET_VERSION)' assets: '$(Build.ArtifactStagingDirectory)/*.nupkg' assetUploadMode: replace - isPreRelease: false + isPreRelease: $[eq(variables['Build.SourceBranchName'], 'develop')] addChangeLog: false ############################## diff --git a/local_clr.runsettings b/local_clr.runsettings new file mode 100644 index 00000000..9949dd43 --- /dev/null +++ b/local_clr.runsettings @@ -0,0 +1,16 @@ + + + + + 1 + .\TestResults + 1200000 + net48 + x64 + + + Verbose + False + D:\a\_temp\nanoclr_cli\nanoFramework.nanoCLR.dll + + \ No newline at end of file diff --git a/nanoFramework.CoreLibrary.Benchmarks.sln b/nanoFramework.CoreLibrary.Benchmarks.sln new file mode 100644 index 00000000..777b30d6 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks.sln @@ -0,0 +1,27 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36623.8 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{11A8DD76-328B-46DF-9F39-F559912D0360}") = "nanoFramework.CoreLibrary.Benchmarks", "nanoFramework.CoreLibrary.Benchmarks\nanoFramework.CoreLibrary.Benchmarks.nfproj", "{DFF849AB-F56C-4173-9E3C-5FD551914B0F}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Debug|Any CPU.Deploy.0 = Debug|Any CPU + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Release|Any CPU.Build.0 = Release|Any CPU + {DFF849AB-F56C-4173-9E3C-5FD551914B0F}.Release|Any CPU.Deploy.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {B0D58340-A787-48A6-B53F-1678A4E57960} + EndGlobalSection +EndGlobal diff --git a/nanoFramework.CoreLibrary.Benchmarks/Program.cs b/nanoFramework.CoreLibrary.Benchmarks/Program.cs new file mode 100644 index 00000000..99428e3e --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/Program.cs @@ -0,0 +1,40 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Threading; +using nanoFramework.Benchmark; +using nanoFramework.CoreLibrary.Benchmarks.ToString; +using nanoFramework.Runtime.Native; + +namespace nanoFramework.CoreLibrary.Benchmarks +{ + public class Program + { + public static void Main() + { + // Display header with system information + Debug.WriteLine("================================================"); + Debug.WriteLine(" nanoFramework Core Library Benchmarks"); + Debug.WriteLine("================================================"); + Debug.WriteLine(""); + + Debug.WriteLine($"Target Name: {SystemInfo.TargetName}"); + Debug.WriteLine($"Firmware: {SystemInfo.Version}"); + var coreLibVersion = typeof(object).Assembly.GetName().Version; + Debug.WriteLine($"CoreLibrary Version: {coreLibVersion}"); + + Debug.WriteLine(""); + Debug.WriteLine("================================================"); + Debug.WriteLine(""); + + // Run benchmarks + BenchmarkRunner.RunClass(typeof(ToStringPlain)); + BenchmarkRunner.RunClass(typeof(ToStringConcatenation)); + BenchmarkRunner.RunClass(typeof(ToStringInterpolation)); + BenchmarkRunner.RunClass(typeof(ToStringFormat)); + + Thread.Sleep(Timeout.Infinite); + } + } +} diff --git a/nanoFramework.CoreLibrary.Benchmarks/Properties/AssemblyInfo.cs b/nanoFramework.CoreLibrary.Benchmarks/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..d459bd32 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +// 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 System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("CSharp.BlankApplication")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("CSharp.BlankApplication")] +[assembly: AssemblyCopyright("Copyright © 2025")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringConcatenation.cs b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringConcatenation.cs new file mode 100644 index 00000000..184c0af1 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringConcatenation.cs @@ -0,0 +1,99 @@ +// 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.Benchmark; +using nanoFramework.Benchmark.Attributes; + +namespace nanoFramework.CoreLibrary.Benchmarks.ToString +{ + [IterationCount(5)] + public class ToStringConcatenation + { + private int _intValue; + private long _longValue; + private double _doubleValue; + private bool _boolValue; + private byte _byteValue; + private DateTime _dateTimeValue; + private string _stringValue; + + [Setup] + public void Setup() + { + _intValue = 12345; + _longValue = 1234567890123456L; + _doubleValue = 123.456; + _boolValue = true; + _byteValue = 255; + _dateTimeValue = new DateTime(2024, 1, 15, 10, 30, 45); + _stringValue = "test"; + } + + [Benchmark] + public void Int32Concatenation() + { + _ = "Value: " + _intValue; + } + + [Benchmark] + public void Int64Concatenation() + { + _ = "Value: " + _longValue; + } + + [Benchmark] + public void DoubleConcatenation() + { + _ = "Value: " + _doubleValue; + } + + [Benchmark] + public void BooleanConcatenation() + { + _ = "Value: " + _boolValue; + } + + [Benchmark] + public void ByteConcatenation() + { + _ = "Value: " + _byteValue; + } + + [Benchmark] + public void DateTimeConcatenation() + { + _ = "Value: " + _dateTimeValue; + } + + [Benchmark] + public void MultipleValuesConcatenation() + { + _ = "Int: " + _intValue + ", Double: " + _doubleValue + ", Bool: " + _boolValue; + } + + [Benchmark] + public void MixedConcatenation() + { + _ = "String: " + _stringValue + ", Int: " + _intValue + ", DateTime: " + _dateTimeValue; + } + + [Benchmark] + public void ComplexConcatenation() + { + _ = "Values - Byte: " + _byteValue + ", Long: " + _longValue + ", Double: " + _doubleValue + ", Bool: " + _boolValue; + } + + [Benchmark] + public void ExplicitToStringConcatenation() + { + _ = "Value: " + _intValue.ToString(); + } + + [Benchmark] + public void MultipleExplicitToStringConcatenation() + { + _ = "Int: " + _intValue.ToString() + ", Double: " + _doubleValue.ToString() + ", Bool: " + _boolValue.ToString(); + } + } +} diff --git a/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringFormat.cs b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringFormat.cs new file mode 100644 index 00000000..605a83ac --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringFormat.cs @@ -0,0 +1,99 @@ +// 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.Benchmark; +using nanoFramework.Benchmark.Attributes; + +namespace nanoFramework.CoreLibrary.Benchmarks.ToString +{ + [IterationCount(5)] + public class ToStringFormat + { + private int _intValue; + private long _longValue; + private double _doubleValue; + private bool _boolValue; + private byte _byteValue; + private DateTime _dateTimeValue; + private string _stringValue; + + [Setup] + public void Setup() + { + _intValue = 12345; + _longValue = 1234567890123456L; + _doubleValue = 123.456; + _boolValue = true; + _byteValue = 255; + _dateTimeValue = new DateTime(2024, 1, 15, 10, 30, 45); + _stringValue = "test"; + } + + [Benchmark] + public void Int32Format() + { + _ = string.Format("Value: {0}", _intValue); + } + + [Benchmark] + public void Int64Format() + { + _ = string.Format("Value: {0}", _longValue); + } + + [Benchmark] + public void DoubleFormat() + { + _ = string.Format("Value: {0}", _doubleValue); + } + + [Benchmark] + public void BooleanFormat() + { + _ = string.Format("Value: {0}", _boolValue); + } + + [Benchmark] + public void ByteFormat() + { + _ = string.Format("Value: {0}", _byteValue); + } + + [Benchmark] + public void DateTimeFormat() + { + _ = string.Format("Value: {0}", _dateTimeValue); + } + + [Benchmark] + public void MultipleValuesFormat() + { + _ = string.Format("Int: {0}, Double: {1}, Bool: {2}", _intValue, _doubleValue, _boolValue); + } + + [Benchmark] + public void MixedFormat() + { + _ = string.Format("String: {0}, Int: {1}, DateTime: {2}", _stringValue, _intValue, _dateTimeValue); + } + + [Benchmark] + public void ComplexFormat() + { + _ = string.Format("Values - Byte: {0}, Long: {1}, Double: {2}, Bool: {3}", _byteValue, _longValue, _doubleValue, _boolValue); + } + + [Benchmark] + public void ReorderedFormat() + { + _ = string.Format("Values: {2}, {1}, {0}", _intValue, _doubleValue, _boolValue); + } + + [Benchmark] + public void RepeatedFormat() + { + _ = string.Format("Value {0} repeated: {0}, {0}", _intValue); + } + } +} diff --git a/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringInterpolation.cs b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringInterpolation.cs new file mode 100644 index 00000000..98bccbb6 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringInterpolation.cs @@ -0,0 +1,87 @@ +// 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.Benchmark; +using nanoFramework.Benchmark.Attributes; + +namespace nanoFramework.CoreLibrary.Benchmarks.ToString +{ + [IterationCount(5)] + public class ToStringInterpolation + { + private int _intValue; + private long _longValue; + private double _doubleValue; + private bool _boolValue; + private byte _byteValue; + private DateTime _dateTimeValue; + private string _stringValue; + + [Setup] + public void Setup() + { + _intValue = 12345; + _longValue = 1234567890123456L; + _doubleValue = 123.456; + _boolValue = true; + _byteValue = 255; + _dateTimeValue = new DateTime(2024, 1, 15, 10, 30, 45); + _stringValue = "test"; + } + + [Benchmark] + public void Int32Interpolation() + { + _ = $"Value: {_intValue}"; + } + + [Benchmark] + public void Int64Interpolation() + { + _ = $"Value: {_longValue}"; + } + + [Benchmark] + public void DoubleInterpolation() + { + _ = $"Value: {_doubleValue}"; + } + + [Benchmark] + public void BooleanInterpolation() + { + _ = $"Value: {_boolValue}"; + } + + [Benchmark] + public void ByteInterpolation() + { + _ = $"Value: {_byteValue}"; + } + + [Benchmark] + public void DateTimeInterpolation() + { + _ = $"Value: {_dateTimeValue}"; + } + + [Benchmark] + public void MultipleValuesInterpolation() + { + _ = $"Int: {_intValue}, Double: {_doubleValue}, Bool: {_boolValue}"; + } + + [Benchmark] + public void MixedInterpolation() + { + _ = $"String: {_stringValue}, Int: {_intValue}, DateTime: {_dateTimeValue}"; + } + + [Benchmark] + public void ComplexInterpolation() + { + _ = $"Values - Byte: {_byteValue}, Long: {_longValue}, Double: {_doubleValue}, Bool: {_boolValue}"; + } + } +} diff --git a/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringPlain.cs b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringPlain.cs new file mode 100644 index 00000000..53ff1286 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/ToString/ToStringPlain.cs @@ -0,0 +1,67 @@ +// 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.Benchmark; +using nanoFramework.Benchmark.Attributes; + +namespace nanoFramework.CoreLibrary.Benchmarks.ToString +{ + [IterationCount(5)] + public class ToStringPlain + { + private int _intValue; + private long _longValue; + private double _doubleValue; + private bool _boolValue; + private byte _byteValue; + private DateTime _dateTimeValue; + + [Setup] + public void Setup() + { + _intValue = 12345; + _longValue = 1234567890123456L; + _doubleValue = 123.456; + _boolValue = true; + _byteValue = 255; + _dateTimeValue = new DateTime(2024, 1, 15, 10, 30, 45); + } + + [Benchmark] + public void Int32ToString() + { + _ = _intValue.ToString(); + } + + [Benchmark] + public void Int64ToString() + { + _ = _longValue.ToString(); + } + + [Benchmark] + public void DoubleToString() + { + _ = _doubleValue.ToString(); + } + + [Benchmark] + public void BooleanToString() + { + _ = _boolValue.ToString(); + } + + [Benchmark] + public void ByteToString() + { + _ = _byteValue.ToString(); + } + + [Benchmark] + public void DateTimeToString() + { + _ = _dateTimeValue.ToString(); + } + } +} diff --git a/nanoFramework.CoreLibrary.Benchmarks/nanoFramework.CoreLibrary.Benchmarks.nfproj b/nanoFramework.CoreLibrary.Benchmarks/nanoFramework.CoreLibrary.Benchmarks.nfproj new file mode 100644 index 00000000..1be68daf --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/nanoFramework.CoreLibrary.Benchmarks.nfproj @@ -0,0 +1,60 @@ + + + + $(MSBuildExtensionsPath)\nanoFramework\v1.0\ + + + + Debug + AnyCPU + {11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + dff849ab-f56c-4173-9e3c-5fd551914b0f + Exe + Properties + 512 + nanoFramework.CoreLibrary.Benchmarks + nanoFramework.CoreLibrary.Benchmarks + v1.0 + + + + + + + + + + + + + packages\nanoFramework.CoreLibrary.1.17.11\lib\mscorlib.dll + + + packages\nanoFramework.Benchmark.1.0.113\lib\nanoFramework.Benchmark.dll + + + packages\nanoFramework.Logging.1.1.161\lib\nanoFramework.Logging.dll + + + packages\nanoFramework.Runtime.Native.1.7.11\lib\nanoFramework.Runtime.Native.dll + + + packages\nanoFramework.System.Collections.1.5.67\lib\nanoFramework.System.Collections.dll + + + packages\nanoFramework.System.Text.1.3.42\lib\nanoFramework.System.Text.dll + + + packages\nanoFramework.System.Diagnostics.Stopwatch.1.2.862\lib\System.Diagnostics.Stopwatch.dll + + + + + + + + + + + + diff --git a/nanoFramework.CoreLibrary.Benchmarks/packages.config b/nanoFramework.CoreLibrary.Benchmarks/packages.config new file mode 100644 index 00000000..b2e69209 --- /dev/null +++ b/nanoFramework.CoreLibrary.Benchmarks/packages.config @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/nanoFramework.CoreLibrary.nuspec b/nanoFramework.CoreLibrary.nuspec index 63518a26..6b612a06 100644 --- a/nanoFramework.CoreLibrary.nuspec +++ b/nanoFramework.CoreLibrary.nuspec @@ -13,17 +13,14 @@ https://github.com/nanoframework/CoreLibrary images\nf-logo.png - Copyright (c) .NET Foundation and Contributors + Copyright (c) .NET Foundation and Contributors This package includes the CoreLibrary assembly for .NET nanoFramework C# projects. This package requires a target with mscorlib v$nativeVersion$ (checksum $checksum$). In case you don't need the System.Reflection API there is another NuGet package without this API. nanoFramework C# csharp netmf netnf nanoFramework.CoreLibrary - - - - - - + + + diff --git a/nanoFramework.CoreLibrary/CoreLibrary.nfproj b/nanoFramework.CoreLibrary/CoreLibrary.nfproj index c44da984..0bd250ab 100644 --- a/nanoFramework.CoreLibrary/CoreLibrary.nfproj +++ b/nanoFramework.CoreLibrary/CoreLibrary.nfproj @@ -38,7 +38,7 @@ $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb true true - default + 13.0 true @@ -66,6 +66,16 @@ + + + + + + + + + + @@ -188,7 +198,9 @@ - + + + @@ -251,4 +263,4 @@ - + \ No newline at end of file diff --git a/nanoFramework.CoreLibrary/System/Array.Enumerators.cs b/nanoFramework.CoreLibrary/System/Array.Enumerators.cs new file mode 100644 index 00000000..532e4483 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Array.Enumerators.cs @@ -0,0 +1,101 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; + +#nullable enable + +namespace System +{ + internal abstract class SZGenericArrayEnumeratorBase : IDisposable + { + protected int _index; + protected readonly int _endIndex; + + protected SZGenericArrayEnumeratorBase(int endIndex) + { + _index = -1; + _endIndex = endIndex; + } + + public bool MoveNext() + { + int index = _index + 1; + + if ((uint)index < (uint)_endIndex) + { + _index = index; + + return true; + } + + _index = _endIndex; + + return false; + } + + public void Reset() => _index = -1; + + public void Dispose() + { + } + } + + internal sealed class SZGenericArrayEnumerator : SZGenericArrayEnumeratorBase, IEnumerator + { + private readonly T[]? _array; + + /// Provides an empty enumerator singleton. + /// + /// If the consumer is using SZGenericArrayEnumerator elsewhere or is otherwise likely + /// to be using T[] elsewhere, this singleton should be used. Otherwise, GenericEmptyEnumerator's + /// singleton should be used instead, as it doesn't reference T[] in order to reduce footprint. + /// + internal static readonly SZGenericArrayEnumerator Empty = new SZGenericArrayEnumerator(null, 0); + + internal SZGenericArrayEnumerator(T[]? array, int endIndex) + : base(endIndex) + { + Debug.Assert(array == null || endIndex == array.Length); + _array = array; + } + + public T Current + { + get + { + if ((uint)_index >= (uint)_endIndex) + { + throw new InvalidOperationException(); + } + + return _array![_index]; + } + } + + object? IEnumerator.Current => Current; + } + + internal abstract class GenericEmptyEnumeratorBase : IDisposable, IEnumerator + { +#pragma warning disable CA1822 // https://github.com/dotnet/roslyn-analyzers/issues/5911 + public bool MoveNext() => false; + + public object Current + { + get + { + return default; + } + } + + public void Reset() { } + + public void Dispose() { } +#pragma warning restore CA1822 + } +} diff --git a/nanoFramework.CoreLibrary/System/Array.cs b/nanoFramework.CoreLibrary/System/Array.cs index 1256a436..c9cf7254 100644 --- a/nanoFramework.CoreLibrary/System/Array.cs +++ b/nanoFramework.CoreLibrary/System/Array.cs @@ -1,8 +1,12 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Collections; using System.Runtime.CompilerServices; +#if NANOCLR_REFLECTION +using System.Collections.Generic; +using System.Diagnostics; +#endif // NANOCLR_REFLECTION namespace System { @@ -343,6 +347,25 @@ public static int IndexOf(Array array, Object value, int startIndex, int count) return -1; } +#if NANOCLR_REFLECTION + /// + /// Creates and returns an empty array of the specified type. + /// + /// + /// + public static T[] Empty() + { + return EmptyArray.Value; + } + + private static class EmptyArray + { +#pragma warning disable CA1825, IDE0300 // this is the implementation of Array.Empty() + internal static readonly T[] Value = new T[0]; +#pragma warning restore CA1825, IDE0300 + } +#endif + [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool TrySzIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal); @@ -410,5 +433,153 @@ public void Reset() _index = _startIndex - 1; } } + +#if NANOCLR_REFLECTION +#pragma warning disable CA1822 // Mark members as static + //---------------------------------------------------------------------------------------- + // ! READ THIS BEFORE YOU WORK ON THIS CLASS. + // + // The methods on this class must be written VERY carefully to avoid introducing security holes. + // That's because they are invoked with special "this"! The "this" object + // for all of these methods are not SZArrayHelper objects. Rather, they are of type U[] + // where U[] is castable to T[]. No actual SZArrayHelper object is ever instantiated. Thus, you will + // see a lot of expressions that cast "this" "T[]". + // + // This class is needed to allow an SZ array of type T[] to expose IList, + // IList, etc., etc. all the way up to IList. When the following call is + // made: + // + // ((IList) (new U[n])).SomeIListMethod() + // + // the interface stub dispatcher treats this as a special case, loads up SZArrayHelper, + // finds the corresponding generic method (matched simply by method name), instantiates + // it for type and executes it. + // + // The "T" will reflect the interface used to invoke the method. The actual runtime "this" will be + // array that is castable to "T[]" (i.e. for primitives and valuetypes, it will be exactly + // "T[]" - for orefs, it may be a "U[]" where U derives from T.) + //---------------------------------------------------------------------------------------- + internal sealed class SZArrayHelper + { + // It is never legal to instantiate this class. + private SZArrayHelper() + { + Debug.Assert(false, "Hey! How'd I get here?"); + } + + internal IEnumerator GetEnumerator() + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + T[] @this = Unsafe.As(this); + int length = @this.Length; + return length == 0 ? SZGenericArrayEnumerator.Empty : new SZGenericArrayEnumerator(@this, length); + } + + private void CopyTo(T[] array, int index) + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + + T[] @this = Unsafe.As(this); + Array.Copy(@this, 0, array, index, @this.Length); + } + + internal int get_Count() + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + T[] @this = Unsafe.As(this); + return @this.Length; + } + + internal T get_Item(int index) + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + + T[] @this = Unsafe.As(this); + if ((uint)index >= (uint)@this.Length) + { +#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one + throw new ArgumentOutOfRangeException(); +#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one + } + + return @this[index]; + } + + internal void set_Item(int index, T value) + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + T[] @this = Unsafe.As(this); + if ((uint)index >= (uint)@this.Length) + { +#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one + throw new ArgumentOutOfRangeException(); +#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one + } + + @this[index] = value; + } + + private void Add(T _) + { + // Not meaningful for arrays. + throw new NotSupportedException(); + } + + private bool Contains(T value) + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + T[] @this = Unsafe.As(this); + return Array.IndexOf(@this, value, 0, @this.Length) >= 0; + } + + private bool get_IsReadOnly() + { + return true; + } + + private void Clear() + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + + throw new NotSupportedException(); + } + + private int IndexOf(T value) + { + // ! Warning: "this" is an array, not an SZArrayHelper. See comments above + // ! or you may introduce a security hole! + T[] @this = Unsafe.As(this); + return Array.IndexOf(@this, value, 0, @this.Length); + } + + private void Insert(int _, T _1) + { + // Not meaningful for arrays + throw new NotSupportedException(); + } + + private bool Remove(T _) + { + // Not meaningful for arrays + throw new NotSupportedException(); + return default; + } + + private void RemoveAt(int _) + { + // Not meaningful for arrays + throw new NotSupportedException(); + } + } +#pragma warning restore CA1822 + +#endif } } diff --git a/nanoFramework.CoreLibrary/System/ArrayTypeMismatchException.cs b/nanoFramework.CoreLibrary/System/ArrayTypeMismatchException.cs new file mode 100644 index 00000000..658300b6 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/ArrayTypeMismatchException.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System +{ + /// + /// The exception that is thrown when an attempt is made to store an element of the wrong type within an array. + /// + [Serializable] + public class ArrayTypeMismatchException : SystemException + { + /// + /// Initializes a new instance of the class. + /// + public ArrayTypeMismatchException() + { + } + + /// + /// Initializes a new instance of the class with a specified error message. + /// + /// + public ArrayTypeMismatchException(string? message) + : base(message) + { + } + + /// + /// Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + /// + /// + /// + public ArrayTypeMismatchException(string? message, Exception? innerException) + : base(message, innerException) + { + } + } +} diff --git a/nanoFramework.CoreLibrary/System/AssemblyInfo.cs b/nanoFramework.CoreLibrary/System/AssemblyInfo.cs index 1d1984ee..6c4f9d6f 100644 --- a/nanoFramework.CoreLibrary/System/AssemblyInfo.cs +++ b/nanoFramework.CoreLibrary/System/AssemblyInfo.cs @@ -10,4 +10,4 @@ [assembly: AssemblyProduct(".NET nanoFramework mscorlib")] [assembly: AssemblyCopyright("Copyright (c) .NET Foundation and Contributors")] -[assembly: AssemblyNativeVersion("100.5.0.24")] +[assembly: AssemblyNativeVersion("100.22.0.1")] diff --git a/nanoFramework.CoreLibrary/System/Collections/Generic/Comparer.cs b/nanoFramework.CoreLibrary/System/Collections/Generic/Comparer.cs new file mode 100644 index 00000000..309edfb2 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Collections/Generic/Comparer.cs @@ -0,0 +1,183 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; + +#nullable enable + +namespace System.Collections.Generic +{ + ///// + ///// Provides a base class for implementations of the IComparer{T} generic interface. + ///// + ///// The type of objects to compare. + //[Serializable] + //public abstract partial class Comparer : IComparer, IComparer + //{ + // protected Comparer() + // { + + // } + // //public static Comparer Create(Comparison comparison) + // //{ + // // ArgumentNullException.ThrowIfNull(comparison); + + // // return new ComparisonComparer(comparison); + // //} + + // /// + // /// Returns a default sort-order comparer for the type specified by the generic argument. + // /// + // /// + // /// An object that inherits {T} and serves as a sort-order comparer for type {T}. + // /// + // public static extern Comparer Default + // { + // [MethodImpl(MethodImplOptions.InternalCall)] + // get; + // } + + // public abstract int Compare(T? x, T? y); + + // int IComparer.Compare(object? x, object? y) + // { + // if (x == null) + // { + // return y == null ? 0 : -1; + // } + + // if (y == null) + // { + // return 1; + // } + + // if (x is T && y is T) + // { + // return Compare((T)x, (T)y); + // } + + // throw new ArgumentException(); + // } + //} + + //internal sealed class ComparisonComparer : Comparer + //{ + // private readonly Comparison _comparison; + + // public ComparisonComparer(Comparison comparison) + // { + // _comparison = comparison; + // } + + // public override int Compare(T? x, T? y) => _comparison(x!, y!); + //} + + // Note: although there is a lot of shared code in the following + // comparers, we do not incorporate it into a base class for perf + // reasons. Adding another base class (even one with no fields) + // means another generic instantiation, which can be costly esp. + // for value types. + //[Serializable] + // Needs to be public to support binary serialization compatibility + //public sealed partial class GenericComparer : Comparer where T : IComparable? + //{ + // public override int Compare(T? x, T? y) + // { + // if (x != null) + // { + // if (y != null) + // { + // return x.CompareTo(y); + // } + + // return 1; + // } + // if (y != null) + // { + // return -1; + // } + + // return 0; + // } + + // // Equals method for the comparer itself. + // public override bool Equals([NotNullWhen(true)] object? obj) => + // obj != null && GetType() == obj.GetType(); + + // public override int GetHashCode() => + // GetType().GetHashCode(); + //} + + ///// + ///// + ///// + ///// + //[Serializable] + //public sealed class NullableComparer : Comparer where T : struct + //{ + // public NullableComparer() { } + + // public override int Compare(T? x, T? y) + // { + // if (x.HasValue) + // { + // if (y.HasValue) + // { + // return Comparer.Default.Compare(x.value, y.value); + // } + + // return 1; + // } + + // if (y.HasValue) + // { + // return -1; + // } + + // return 0; + // } + + // // Equals method for the comparer itself. + // public override bool Equals([NotNullWhen(true)] object? obj) => + // obj != null && GetType() == obj.GetType(); + + // public override int GetHashCode() => + // GetType().GetHashCode(); + //} + + //[Serializable] + //public sealed partial class ObjectComparer : Comparer + //{ + // public override int Compare(T? x, T? y) + // { + // return Default.Compare(x, y); + // } + + // // Equals method for the comparer itself. + // public override bool Equals([NotNullWhen(true)] object? obj) => + // obj != null && GetType() == obj.GetType(); + + // public override int GetHashCode() => + // GetType().GetHashCode(); + //} + + //[Serializable] + //internal sealed partial class EnumComparer : Comparer where T : struct, Enum + //{ + // public EnumComparer() { } + + // public override int Compare(T x, T y) + // { + // // TODO: native? + // throw new NotImplementedException(); + // } + + // // Equals method for the comparer itself. + // public override bool Equals([NotNullWhen(true)] object? obj) => + // obj != null && GetType() == obj.GetType(); + + // public override int GetHashCode() => + // GetType().GetHashCode(); + //} +} diff --git a/nanoFramework.CoreLibrary/System/Collections/Generic/IComparer.cs b/nanoFramework.CoreLibrary/System/Collections/Generic/IComparer.cs new file mode 100644 index 00000000..dd78f6e0 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Collections/Generic/IComparer.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#nullable enable + +namespace System.Collections.Generic +{ + /// + /// Defines a method that a type implements to compare two objects. + /// + /// The type of objects to compare. This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. + public interface IComparer where T : allows ref struct + { + /// + /// Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + /// + /// The first object to compare. + /// The second object to compare. + /// + int Compare(T? x, T? y); + } +} diff --git a/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerable.cs b/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerable.cs new file mode 100644 index 00000000..a09be45d --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerable.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Collections.Generic +{ + /// + /// Exposes the enumerator, which supports a simple iteration over a collection of a specified type. + /// + /// The type of objects to enumerate. This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. + public interface IEnumerable : IEnumerable + where T : allows ref struct + { + /// + /// Returns an enumerator that iterates through the collection. + /// + /// An enumerator that can be used to iterate through the collection. + new IEnumerator GetEnumerator(); + } +} diff --git a/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerator.cs b/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerator.cs new file mode 100644 index 00000000..bdb8cf16 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Collections/Generic/IEnumerator.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Collections.Generic +{ + /// + /// Supports a simple iteration over a generic collection. + /// + /// + /// The type of objects to enumerate. This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. + /// + + public interface IEnumerator : IDisposable, IEnumerator + where T : allows ref struct + { + /// + /// Gets the element in the collection at the current position of the enumerator. + /// + /// The element in the collection at the current position of the enumerator. + new T Current + { + get; + } + + // NOTE: An implementation of an enumerator using a ref struct T will + // not be able to implement IEnumerator.Current to return that T (as + // doing so would require boxing). It should throw a NotSupportedException + // from that property implementation. + } +} diff --git a/nanoFramework.CoreLibrary/System/Collections/IEnumerable.cs b/nanoFramework.CoreLibrary/System/Collections/IEnumerable.cs index d66ecf55..f4aa575a 100644 --- a/nanoFramework.CoreLibrary/System/Collections/IEnumerable.cs +++ b/nanoFramework.CoreLibrary/System/Collections/IEnumerable.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. namespace System.Collections @@ -11,7 +11,7 @@ public interface IEnumerable /// /// Returns an enumerator that iterates through a collection. /// - /// An IEnumerator object that can be used to iterate through the collection. + /// An object that can be used to iterate through the collection. IEnumerator GetEnumerator(); } } diff --git a/nanoFramework.CoreLibrary/System/Collections/IList.cs b/nanoFramework.CoreLibrary/System/Collections/IList.cs index 90e0f63b..ec6f72c7 100644 --- a/nanoFramework.CoreLibrary/System/Collections/IList.cs +++ b/nanoFramework.CoreLibrary/System/Collections/IList.cs @@ -1,10 +1,8 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. namespace System.Collections { - using System; - /// /// Represents a non-generic collection of objects that can be individually accessed by index. /// @@ -27,16 +25,16 @@ object this[int index] /// /// Adds an item to the IList. /// - /// The object to add to the IList. + /// The object to add to the IList. /// The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection. - int Add(Object value); + int Add(object item); /// /// Determines whether the IList contains a specific value. /// - /// The object to locate in the IList. + /// The object to locate in the IList. /// true if the Object is found in the IList; otherwise, false. - bool Contains(Object value); + bool Contains(object item); /// /// Removes all items from the IList. @@ -68,22 +66,22 @@ bool IsFixedSize /// /// Determines the index of a specific item in the IList. /// - /// The object to locate in the IList. + /// The object to locate in the IList. /// The index of value if found in the list; otherwise, -1. - int IndexOf(Object value); + int IndexOf(object item); /// /// Inserts an item to the IList at the specified index. /// /// The zero-based index at which value should be inserted. - /// The object to insert into the IList. - void Insert(int index, Object value); + /// The object to insert into the IList. + void Insert(int index, object item); /// /// Removes the first occurrence of a specific object from the IList. /// - /// The object to remove from the IList. - void Remove(Object value); + /// The object to remove from the IList. + void Remove(object item); /// /// Removes the IList item at the specified index. diff --git a/nanoFramework.CoreLibrary/System/Diagnostics/DebuggerAttributes.cs b/nanoFramework.CoreLibrary/System/Diagnostics/DebuggerAttributes.cs index fc80ca23..1b2d8925 100644 --- a/nanoFramework.CoreLibrary/System/Diagnostics/DebuggerAttributes.cs +++ b/nanoFramework.CoreLibrary/System/Diagnostics/DebuggerAttributes.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Runtime.CompilerServices; @@ -244,7 +244,6 @@ public DebuggerBrowsableState State /// /// Available only in mscorlib build with support for System.Reflection. [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Assembly, AllowMultiple = true)] - [ExcludeType] public sealed class DebuggerTypeProxyAttribute : Attribute { private readonly string _typeName; diff --git a/nanoFramework.CoreLibrary/System/Diagnostics/StackTraceHiddenAttribute.cs b/nanoFramework.CoreLibrary/System/Diagnostics/StackTraceHiddenAttribute.cs new file mode 100644 index 00000000..7ad53368 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Diagnostics/StackTraceHiddenAttribute.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Diagnostics +{ + /// + /// Types and Methods attributed with StackTraceHidden will be omitted from the stack trace text shown in StackTrace.ToString() + /// and Exception.StackTrace + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Struct, Inherited = false)] + public sealed class StackTraceHiddenAttribute : Attribute + { + /// + /// Initializes a new instance of the class. + /// + public StackTraceHiddenAttribute() { } + } +} diff --git a/nanoFramework.CoreLibrary/System/GC.cs b/nanoFramework.CoreLibrary/System/GC.cs index 13f07e8c..7746f4f3 100644 --- a/nanoFramework.CoreLibrary/System/GC.cs +++ b/nanoFramework.CoreLibrary/System/GC.cs @@ -1,39 +1,79 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Runtime.CompilerServices; + namespace System { - using Runtime.CompilerServices; - /// /// Controls the system garbage collector, a service that automatically reclaims unused memory. /// public static class GC { +#pragma warning disable S4200 // Native methods should be wrapped + + /// + /// Enables or disables the output of garbage collection messages. + /// + /// to enable the output of GC messages; otherwise, . + /// + /// + /// Enabling GC messages may not always result in output, depending on the target build options. + /// For example, RTM builds, which remove all non-essential features, may not output these messages. + /// + /// + /// This method is specific of .NET nanoFramework implementation. There is no equivalent in full .NET API. + /// + /// [MethodImpl(MethodImplOptions.InternalCall)] - private static extern bool AnyPendingFinalizers(); + public static extern void EnableGCMessages(bool enable); /// - /// Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue. + /// Retrieves the heap size excluding fragmentation. For example if the total GC heap size is 1MB and fragmentation, ie, space taken up by free objects, takes up 400kB, this API would report 600kB. A parameter indicates whether this method can wait a short interval before returning, to allow the system to collect garbage and finalize objects. /// - public static void WaitForPendingFinalizers() - { - while (AnyPendingFinalizers()) Threading.Thread.Sleep(10); - } + /// to indicate that this method can wait for garbage collection and heap compaction to occur before returning; otherwise, . + /// The heap size, in bytes, excluding fragmentation. + public static long GetTotalMemory(bool forceFullCollection) => Run(forceFullCollection); /// - /// Requests that the system not call the finalizer for the specified object. + /// Requests that the system call the finalizer for the specified object for which has previously been called. /// - /// The object that a finalizer must not be called for. + /// The object that a finalizer must be called for. + /// is . [MethodImpl(MethodImplOptions.InternalCall)] - public static extern void SuppressFinalize(Object obj); + public static extern void ReRegisterForFinalize(object obj); + + /// + /// Forces an immediate garbage collection of all generations. + /// + /// + /// Use this method to try to reclaim all memory that is inaccessible. It performs a blocking garbage collection of all generations. + /// All objects, regardless of how long they have been in memory, are considered for collection; however, objects that are referenced in managed code are not collected. Use this method to force the system to try to reclaim the maximum amount of available memory. + /// + public static void Collect() => Run(true); /// - /// Requests that the system call the finalizer for the specified object for which SuppressFinalize has previously been called. + /// Requests that the common language runtime not call the finalizer for the specified object. /// - /// The object that a finalizer must be called for. + /// The object whose finalizer must not be executed. + /// is . [MethodImpl(MethodImplOptions.InternalCall)] - public static extern void ReRegisterForFinalize(Object obj); + public static extern void SuppressFinalize(object obj); + /// + /// Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue. + /// + public static void WaitForPendingFinalizers() + { + while (AnyPendingFinalizers()) Threading.Thread.Sleep(10); + } + +#pragma warning restore S4200 // Native methods should be wrapped + + [MethodImpl(MethodImplOptions.InternalCall)] + private static extern bool AnyPendingFinalizers(); + + [MethodImpl(MethodImplOptions.InternalCall)] + private static extern uint Run(bool compactHeap); } } diff --git a/nanoFramework.CoreLibrary/System/Guid.cs b/nanoFramework.CoreLibrary/System/Guid.cs index 75e2f066..dece99d2 100644 --- a/nanoFramework.CoreLibrary/System/Guid.cs +++ b/nanoFramework.CoreLibrary/System/Guid.cs @@ -11,7 +11,7 @@ namespace System [Serializable] public struct Guid { - private int[] _data; + private int[] _data = new int[4]; /// /// A read-only instance of the Guid class which consists of all zeros. @@ -141,7 +141,7 @@ public Guid(string g) ArgumentNullException.ThrowIfNull(g); #pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one - if (!TryParseGuidWithDashes( + if (!TryParse( g, out this)) { @@ -163,26 +163,32 @@ public int CompareTo(object value) if (value == null) { return 1; - } -#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one - if (value is not Guid) + } + if (value is not Guid other) { throw new ArgumentException(); } -#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one - int[] other = ((Guid)value)._data; - other ??= new int[4]; + return CompareTo(other); + } + /// + /// Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. + /// + /// An object to compare with this instance. + /// A value that indicates the relative order of the objects being compared. + public int CompareTo(Guid other) + { + _data ??= new int[4]; + other._data ??= new int[4]; for (int i = 0; i < 4; i++) { - if (_data[i] != other[i]) + if (_data[i] != other._data[i]) { - return _data[i] - other[i]; + return _data[i] - other._data[i]; } } - return 0; } @@ -201,6 +207,9 @@ public int CompareTo(object value) /// public byte[] ToByteArray() { + // Initialize if null (treat as Empty) + _data ??= new int[4]; + byte[] buffer = new byte[16]; int index = 0; @@ -289,10 +298,19 @@ public override bool Equals(object o) return false; } - int[] other = ((Guid)o)._data; - other ??= new int[4]; + return o is Guid other && Equals(other); + } - return (_data[0] == other[0]) && (_data[1] == other[1]) && (_data[2] == other[2]) && (_data[3] == other[3]); + /// + /// Indicates whether the current object is equal to another object of the same type. + /// + /// An object to compare with this object. + /// true if the current object is equal to the other parameter; otherwise, false. + public bool Equals(Guid other) + { + _data ??= new int[4]; + other._data ??= new int[4]; + return (_data[0] == other._data[0]) && (_data[1] == other._data[1]) && (_data[2] == other._data[2]) && (_data[3] == other._data[3]); } /// @@ -301,6 +319,8 @@ public override bool Equals(object o) /// The hash code for this instance. public override int GetHashCode() { + // Initialize if null (treat as Empty) + _data ??= new int[4]; return _data[0] ^ _data[1] ^ _data[2] ^ _data[3]; } @@ -331,8 +351,7 @@ private static char HexToChar(int a) /// /// The .NET nanoFramework implementation of this method only supports 'D' and 'N' format specifiers. /// - [Obsolete("This will be renamed to TryParse in a future version.")] - public static bool TryParseGuidWithDashes( + public static bool TryParse( string input, out Guid result) { @@ -447,5 +466,34 @@ private static long HexStringToLong(string str, ref int parsePos, int requiredLe parsePos += requiredLength; return result; } + + /// + /// Determines whether two specified instances of are equal. + /// + /// The first to compare. + /// The second to compare. + /// if equals ; otherwise, . + public static bool operator ==(Guid a, Guid b) + { + // Defensive null handling, though _data should always be initialized + a._data ??= new int[4]; + b._data ??= new int[4]; + + return (a._data[0] == b._data[0]) && + (a._data[1] == b._data[1]) && + (a._data[2] == b._data[2]) && + (a._data[3] == b._data[3]); + } + + /// + /// Determines whether two specified instances of are not equal. + /// + /// The first to compare. + /// The second to compare. + /// if does not equal ; otherwise, . + public static bool operator !=(Guid a, Guid b) + { + return !(a == b); + } } } diff --git a/nanoFramework.CoreLibrary/System/IComparable.cs b/nanoFramework.CoreLibrary/System/IComparable.cs index f73543dd..27abf9b9 100644 --- a/nanoFramework.CoreLibrary/System/IComparable.cs +++ b/nanoFramework.CoreLibrary/System/IComparable.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. namespace System @@ -20,4 +20,46 @@ public interface IComparable int CompareTo(Object obj); } +#if NANOCLR_REFLECTION + +#nullable enable + + /// + /// Defines a generalized comparison method that a value type or class implements to create a type-specific comparison method for ordering or sorting its instances. + /// + /// + /// The type of object to compare. This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. + /// + public interface IComparable where T : allows ref struct + { + // Interface does not need to be marked with the serializable attribute + + /// Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. + /// An object to compare with this instance. + /// + /// A value that indicates the relative order of the objects being compared. The return value has these meanings: + /// + /// + /// Value + /// Meaning + /// + /// + /// Less than zero + /// This instance precedes in the sort order. + /// + /// + /// Zero + /// This instance occurs in the same position in the sort order as . + /// + /// + /// Greater than zero + /// This instance follows in the sort order. + /// + /// + /// + int CompareTo(T? other); + } + +#endif + } diff --git a/nanoFramework.CoreLibrary/System/Nullable.cs b/nanoFramework.CoreLibrary/System/Nullable.cs new file mode 100644 index 00000000..e7c06098 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Nullable.cs @@ -0,0 +1,198 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals +#nullable enable + +namespace System +{ + // Because we have special type system support that says a boxed Nullable + // can be used where a boxed T is used, Nullable can not implement any interfaces + // at all (since T may not). + // + // Do NOT add any interfaces to Nullable! + + /// + /// Represents a value type that can be assigned . + /// + /// The underlying value type of the generic type. + [Serializable] + public partial struct Nullable where T : struct + { + // Do not rename (binary serialization) + private readonly bool hasValue; + // Do not rename (binary serialization) or make readonly (can be mutated in ToString, etc.) + internal T value; + + /// + /// Initializes a new instance of the structure to the specified value. + /// + /// A value type. + /// + /// The constructor initializes the HasValue property of the new object to , and the Value property to the value of the parameter. + /// + public Nullable(T value) + { + this.value = value; + hasValue = true; + } + + /// + /// Gets a value indicating whether the current object has a valid value of its underlying type. + /// + /// + /// if the current object has a value; if the current object has no . + /// + public readonly bool HasValue + { + get => hasValue; + } + + /// + /// Gets the value of the current object if it has been assigned a valid underlying value. + /// + /// + /// The value of the current object if the property is . An exception is thrown if the property is . + /// + /// The property is . + public readonly T Value + { + get + { + if (!hasValue) + { + throw new InvalidOperationException(); + } + return value; + } + } + + /// + /// Retrieves the value of the current object, or the default value of the underlying type. + /// + /// The value of the property if the property is ; otherwise, the default value of the underlying type. + /// + /// The method returns a value even if the property is (unlike the property, which throws an exception). If the property is , the method returns the default value of the underlying type. + /// + public readonly T GetValueOrDefault() => value; + + /// + /// Retrieves the value of the current object, or the specified default value. + /// + /// A value to return if the property is . + /// The value of the property if the property is ; otherwise, the default value of the underlying type. + /// + /// The method returns a value even if the property is (unlike the property, which throws an exception). If the property is , the method returns the default value of the underlying type. + /// + public readonly T GetValueOrDefault(T defaultValue) => + hasValue ? value : defaultValue; + + /// + public override bool Equals(object? other) + { + if (!hasValue) + { + return other == null; + } + + if (other == null) + { + return false; + } + + return value.Equals(other); + } + + /// + public override int GetHashCode() => hasValue ? value.GetHashCode() : 0; + + /// + public override string? ToString() => hasValue ? value.ToString() : ""; + + /// + /// Creates a new object initialized to a specified value. + /// + /// A value type. + /// A object whose property is initialized with the value parameter. + public static implicit operator T?(T value) => + new T?(value); + + /// + /// Defines an explicit conversion of a instance to its underlying value. + /// + /// A nullable value. + /// The value of the property of the parameter. + public static explicit operator T(T? value) => value!.Value; + } + + /// + /// Supports a value type that can be assigned . This class cannot be inherited. + /// + public static class Nullable + { + //public static int Compare(T? n1, T? n2) where T : struct + //{ + // if (n1.HasValue) + // { + // if (n2.HasValue) return Comparer.Default.Compare(n1.value, n2.value); + // return 1; + // } + // if (n2.HasValue) return -1; + // return 0; + //} + + //public static bool Equals(T? n1, T? n2) where T : struct + //{ + // if (n1.HasValue) + // { + // if (n2.HasValue) return EqualityComparer.Default.Equals(n1.value, n2.value); + // return false; + // } + // if (n2.HasValue) return false; + // return true; + //} + + /// + /// Returns the underlying type argument of the specified nullable type. + /// + /// A object that describes a closed generic nullable type. + /// The type argument of the parameter, if the parameter is a closed generic nullable type; otherwise, . + /// is . + // If the type provided is not a Nullable Type, return null. + // Otherwise, return the underlying type of the Nullable type + public static Type? GetUnderlyingType(Type nullableType) + { + ArgumentNullException.ThrowIfNull(nullableType); + + if (nullableType.IsGenericType && !nullableType.IsGenericTypeDefinition) + { + // Instantiated generic type only + Type genericType = nullableType.GetGenericTypeDefinition(); + + if (ReferenceEquals(genericType, typeof(Nullable<>))) + { + return nullableType.GetGenericArguments()[0]; + } + } + return null; + } + + /// + /// Retrieves a readonly reference to the location in the instance where the value is stored. + /// + /// The underlying value type of the generic type. + /// The readonly reference to the input value. + /// A readonly reference to the location where the instance's value is stored. If the instance's is false, the current value at that location may be the default value. + /// + /// As the returned readonly reference refers to data that is stored in the input value, this method should only ever be + /// called when the input reference points to a value with an actual location and not an "rvalue" (an expression that may appear on the right side but not left side of an assignment). That is, if this API is called and the input reference + /// called when the input reference points to a value with an actual location and not an "rvalue" (an expression that may appear on the right side but not left side of an assignment). That is, if this API is called and the input reference + /// points to a value that is produced by the compiler as a defensive copy or a temporary copy, the behavior might not match the desired one. + /// + public static ref readonly T GetValueRefOrDefaultRef(ref readonly T? nullable) + where T : struct + { + return ref nullable.value; + } + } +} diff --git a/nanoFramework.CoreLibrary/System/ReadOnlySpan.cs b/nanoFramework.CoreLibrary/System/ReadOnlySpan.cs new file mode 100644 index 00000000..99272a90 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/ReadOnlySpan.cs @@ -0,0 +1,334 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.CompilerServices; + +#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one +#nullable enable + +namespace System +{ + /// + /// Provides a type-safe and memory-safe read-only representation of a contiguous region of arbitrary memory. + /// + /// The type of items in the . + [DebuggerTypeProxy(typeof(SpanDebugView<>))] + [DebuggerDisplay("{ToString(),raw}")] + public readonly ref struct ReadOnlySpan + { + private readonly T[]? _array; + private readonly int _length; + + /// + /// Creates a new over the entirety of a specified array. + /// + /// The array from which to create the . + /// If the array is , this constructor returns a null . + public ReadOnlySpan(T[]? array) + { + if (array == null) + { + this = default; + return; + } + + NativeReadOnlySpanConstructor( + array, + 0, + array.Length); + } + + /// + /// Creates a new object from a specified number of T elements starting at a specified memory address. + /// + /// A pointer to the starting address of a specified number of T elements in memory. + /// The number of T elements to be included in the . + /// This constructor should be used with care, since it creates arbitrarily typed Ts from a *-typed block of memory, and neither nor are validated by the constructor. + /// T is a reference type or contains pointers and therefore cannot be stored in unmanaged memory. + /// is negative. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.InternalCall)] + public extern unsafe ReadOnlySpan( + void* pointer, + int length); + + /// + /// Creates a new that includes a specified number of elements of an array starting at a specified index. + /// + /// The array from which to create the . + /// The zero-based index of the first element to include. + /// The number of elements to include. + /// This method returns when is . + /// Returns default when is null. + /// + /// + /// is , but or is non-zero. + /// + /// + /// -or- + /// + /// + /// is outside the bounds of the array. + /// + /// + /// -or- + /// + /// + /// and exceeds the number of elements in the array. + /// + /// + public ReadOnlySpan( + T[]? array, + int start, + int length) + { + if (array == null) + { + if (start != 0 || length != 0) + { + throw new ArgumentOutOfRangeException(); + } + + _array = default; + + return; + } + + if ((uint)start > (uint)array.Length + || (uint)length > (uint)(array.Length - start)) + { + throw new ArgumentOutOfRangeException(); + } + + NativeReadOnlySpanConstructor( + array, + start, + length); + } + + /// + /// Returns the specified element of the . + /// + /// The zero-based index. + /// + /// less than zero or greater than or equal to . + /// + public ref readonly T this[int index] + { + get + { + if ((uint)index >= (uint)_length) + { + throw new IndexOutOfRangeException(); + } + + return ref _array![index]; + } + } + + /// + /// The number of items in the read-only span. + /// + public int Length => _length; + + /// + /// Returns a value that indicates the current read-only span is empty. + /// + /// when the current span is empty; otherwise, . + public bool IsEmpty => _length == 0; + + /// + /// Returns an empty object. + /// + public static ReadOnlySpan Empty => default; + + /// Gets an enumerator for this . + /// An enumerator for this span. + public Enumerator GetEnumerator() => new Enumerator(this); + + /// + /// Provides an enumerator for the elements of a . + /// + public ref struct Enumerator : IEnumerator + { + /// The span being enumerated. + private readonly ReadOnlySpan _span; + /// The next index to yield. + private int _index; + + /// Initialize the enumerator. + /// The span to enumerate. + internal Enumerator(ReadOnlySpan span) + { + _span = span; + _index = -1; + } + + /// Advances the enumerator to the next item of the . + /// + /// if the enumerator successfully advanced to the next item; if the end of the span has been passed. + /// + public bool MoveNext() + { + int index = _index + 1; + + if (index < _span.Length) + { + _index = index; + return true; + } + + return false; + } + + /// Gets the element at the current position of the enumerator. + public ref readonly T Current + { + get + { + return ref _span[_index]; + } + } + + /// + T IEnumerator.Current => Current; + + /// + object Collections.IEnumerator.Current => Current!; + + /// + void Collections.IEnumerator.Reset() => _index = -1; + + /// + void IDisposable.Dispose() { } + } + + /// + /// Returns a value that indicates whether two instances are not equal. + /// + /// The first read-only span to compare. + /// The second read-only span to compare. + /// + /// if the two instances are not equal; otherwise, . + /// + /// + /// Two instances are not equal if they have different lengths or if the corresponding elements of and point to different memory locations. + /// + public static bool operator !=(ReadOnlySpan left, ReadOnlySpan right) => !(left == right); + + /// + /// Defines an implicit conversion of an array to a + /// + public static implicit operator ReadOnlySpan(T[]? array) => new ReadOnlySpan(array); + + /// + /// Returns a value that indicates whether two instances are equal. + /// + /// The first span to compare. + /// The second span to compare. + /// + /// if the two instances are equal; otherwise, . + /// + /// + /// This tests if two instances are equal by comparing their lengths and the elements they point to. Two instances point to the same starting memory location, and have the same values. This does not compare the contents of two instances. + /// + public static bool operator ==(ReadOnlySpan left, ReadOnlySpan right) + { + if (left.Length != right.Length) + { + return false; + } + + for (int i = 0; i < left.Length; i++) + { + if (!Equals(left[i], right[i])) + { + return false; + } + } + + return true; + } + + /// + /// Copies the contents of this into a destination . + /// + /// The span to copy items into. + /// + /// is shorter than the source . + /// + /// + /// If the source and overlap, the entirety of source is handled as if it was copied to a temporary location before it is copied to . + /// + [MethodImpl(MethodImplOptions.InternalCall)] + public extern void CopyTo(Span destination); + + /// + /// Forms a slice out of the current span that begins at a specified index. + /// + /// The zero-based index at which to begin the slice. + /// A span that consists of all elements of the current span from to the end of the span. + /// + /// is greater than the number of items in the read-only span. + /// + public ReadOnlySpan Slice(int start) + { + if ((uint)start > (uint)_length) + { + throw new ArgumentOutOfRangeException(); + } + + return new ReadOnlySpan(_array, start, _length - start); + } + + /// + /// Forms a slice out of the current read-only span starting at a specified index for a specified length. + /// + /// The zero-based index at which to begin the slice. + /// The desired length for the slice. + /// A span that consists of elements from the current span starting at . + /// + /// is less than zero or greater than . + /// + public ReadOnlySpan Slice(int start, int length) + { + if ((uint)start > (uint)_length + || (uint)length > (uint)(_length - start)) + { + throw new ArgumentOutOfRangeException(); + } + + return new ReadOnlySpan(_array, start, length); + } + + /// + /// Copies the contents of this read-only span into a new array. + /// + /// + /// An array containing the data in the current span. + /// + /// + /// This method performs a heap allocation and data copy, and therefore, should be avoided if possible. It it sometimes necessary when APIs that support are not available, but APIs that work with arrays are. + /// + public T[] ToArray() + { + T[] destination = new T[_length]; + Array.Copy(_array, 0, destination, 0, _length); + return destination; + } + + #region native methods + + [MethodImpl(MethodImplOptions.InternalCall)] + private extern void NativeReadOnlySpanConstructor( + T[] array, + int start, + int length); + + #endregion + } +} + +#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one diff --git a/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeFeature.cs b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeFeature.cs index a5f408a5..8d1bdf58 100644 --- a/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeFeature.cs +++ b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeFeature.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// 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 @@ -13,17 +13,22 @@ public static partial class RuntimeFeature /// public const string DefaultImplementationsOfInterfaces = nameof(DefaultImplementationsOfInterfaces); + /// + /// Represents a runtime feature where byref-like types can be used in Generic parameters. + /// + public const string ByRefLikeGenerics = nameof(ByRefLikeGenerics); + /// /// Checks whether a certain feature is supported by the Runtime. /// public static bool IsSupported(string feature) { - if (feature == DefaultImplementationsOfInterfaces) + return feature switch { - return true; - } - - return false; + ByRefLikeGenerics or + DefaultImplementationsOfInterfaces => true, + _ => false, + }; } } } diff --git a/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeHelpers.cs b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeHelpers.cs index e306876e..7862f63d 100644 --- a/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeHelpers.cs +++ b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeHelpers.cs @@ -1,8 +1,10 @@ -// Licensed to the .NET Foundation under one or more agreements. +// 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 { +#pragma warning disable S4200 // Native methods should be wrapped + /// /// Provides a set of static methods and properties that provide support for compilers. This class cannot be inherited. /// @@ -43,5 +45,20 @@ public static extern int OffsetToStringData [MethodImpl(MethodImplOptions.InternalCall)] get; } + +#if NANOCLR_REFLECTION + + /// + /// Returns a value that indicates whether the specified type is a reference type or a value type that contains references or by-refs. + /// + /// The type. + /// if the given type is a reference type or a value type that contains references or by-refs; otherwise, . + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern bool IsReferenceOrContainsReferences() where T : allows ref struct; + +#endif + } + +#pragma warning restore S4200 // Native methods should be wrapped } diff --git a/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/Unsafe.cs b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/Unsafe.cs new file mode 100644 index 00000000..6d784b10 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Runtime/CompilerServices/Unsafe.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if NANOCLR_REFLECTION +#nullable enable + +namespace System.Runtime.CompilerServices +{ + /// + /// Contains generic, low-level functionality for manipulating pointers. + /// + public static unsafe partial class Unsafe + { + /// + /// Casts the given object to the specified type, performs no dynamic type checking. + /// + /// The target reference type. The return value will be of this type. + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern T? As(object? o) where T : class?; + } +} + +#endif diff --git a/nanoFramework.CoreLibrary/System/Runtime/InteropServices/InAttribute .cs b/nanoFramework.CoreLibrary/System/Runtime/InteropServices/InAttribute .cs new file mode 100644 index 00000000..fa82a88a --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Runtime/InteropServices/InAttribute .cs @@ -0,0 +1,19 @@ +// 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.InteropServices +{ + /// + /// Specifies that a parameter is passed to a method by reference, but is not modified by the method. + /// + [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] + public sealed class InAttribute : Attribute + { + /// + /// Initializes a new instance of the class. + /// + public InAttribute() + { + } + } +} diff --git a/nanoFramework.CoreLibrary/System/Span.cs b/nanoFramework.CoreLibrary/System/Span.cs new file mode 100644 index 00000000..eb2e07d8 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/Span.cs @@ -0,0 +1,345 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.CompilerServices; + +#pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one +#nullable enable + +namespace System +{ + /// + /// Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed + /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe. + /// + /// The type of items in the . + [DebuggerTypeProxy(typeof(SpanDebugView<>))] + [DebuggerDisplay("{ToString(),raw}")] + public readonly ref struct Span + { + private readonly T[]? _array; + private readonly int _length; + + /// + /// Creates a new object over the entirety of a specified array. + /// + /// The array from which to create the object. + /// If array is , this constructor returns a . + /// is a reference type, and is not an array of type . + public Span(T[]? array) + { + if (array == null) + { + this = default; + return; + } + + if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) + { + throw new ArrayTypeMismatchException(); + } + + NativeSpanConstructor( + array, + 0, + array.Length); + } + + /// + /// Creates a new object from a specified number of T elements starting at a specified memory address. + /// + /// A pointer to the starting address of a specified number of T elements in memory. + /// The number of T elements to be included in the . + /// This constructor should be used with care, since it creates arbitrarily typed Ts from a *-typed block of memory, and neither nor are validated by the constructor. + /// T is a reference type or contains pointers and therefore cannot be stored in unmanaged memory. + /// is negative. + [CLSCompliant(false)] + [MethodImpl(MethodImplOptions.InternalCall)] + public extern unsafe Span(void* pointer, int length); + + /// + /// Creates a new object that includes a specified number of elements of an array starting at a specified index. + /// + /// The source array. + /// The zero-based index of the first element to include in the new . + /// The number of elements to include in the new . + /// This method returns when is . + /// is a reference type, and is not an array of type . + /// + /// + /// is , but or is non-zero. + /// + /// + /// -or- + /// + /// + /// is outside the bounds of the array. + /// + /// + /// -or- + /// + /// + /// and exceeds the number of elements in the array. + /// + /// + public Span( + T[]? array, + int start, + int length) + { + if (array == null) + { + if (start != 0 + || length != 0) + { + throw new ArgumentOutOfRangeException(); + } + + this = default; + return; + } + + if (!typeof(T).IsValueType + && array.GetType() != typeof(T[])) + { + throw new ArrayTypeMismatchException(); + } + + if ((uint)start > (uint)array.Length + || (uint)length > (uint)(array.Length - start)) + { + throw new ArgumentOutOfRangeException(); + } + + NativeSpanConstructor( + array, + start, + length); + } + + /// + /// Returns a reference to specified element of the span. + /// + /// The zero-based index. + /// + /// + /// Thrown when less than 0 or greater than or equal to . + /// + public ref T this[int index] + { + get + { + if ((uint)index >= (uint)_length) + { + throw new IndexOutOfRangeException(); + } + + return ref _array![index]; + } + } + + /// + /// Returns the length of the current span. + /// + public int Length => _length; + + /// + /// Returns a value that indicates whether the current is empty. + /// + /// if this span is empty; otherwise, . + public bool IsEmpty => _length == 0; + + /// + /// Returns a value that indicates whether two objects are not equal. + /// + /// The first span to compare. + /// The second span to compare. + /// + /// if the two objects are not equal; otherwise, . + /// + /// + /// Two objects are are not equal if they have different lengths or if the corresponding elements of and do not point to the same memory. + /// + public static bool operator !=(Span left, Span right) => !(left == right); + + /// + /// Returns an empty object. + /// + public static Span Empty => default; + + /// Gets an enumerator for this . + /// An enumerator for this span. + public Enumerator GetEnumerator() => new Enumerator(this); + + /// + /// Provides an enumerator for the elements of a . + /// + public ref struct Enumerator : IEnumerator + { + /// The span being enumerated. + private readonly Span _span; + /// The next index to yield. + private int _index; + + /// Initialize the enumerator. + /// The span to enumerate. + internal Enumerator(Span span) + { + _span = span; + _index = -1; + } + + /// Advances the enumerator to the next item of the . + /// + /// if the enumerator successfully advanced to the next item; if the end of the span has been passed. + /// + public bool MoveNext() + { + int index = _index + 1; + + if (index < _span.Length) + { + _index = index; + return true; + } + + return false; + } + + /// Gets a reference to the item at the current position of the enumerator. + public ref T Current => ref _span[_index]; + + /// + T IEnumerator.Current => Current; + + /// + object Collections.IEnumerator.Current => Current!; + + /// + void Collections.IEnumerator.Reset() => _index = -1; + + /// + void IDisposable.Dispose() { } + } + + /// + /// Clears the contents of this object. + /// + /// + /// The method sets the items in the object to their default values. It does not remove items from the . + /// + public void Clear() + { + for (int i = 0; i < _length; i++) + { + _array![i] = default!; + } + } + + /// + /// Copies the contents of this into a destination . + /// + /// The destination object. + /// + /// is shorter than the source . + /// + /// + /// This method copies all of source to even if source and overlap. + /// + [MethodImpl(MethodImplOptions.InternalCall)] + public extern void CopyTo(Span destination); + + /// + /// Returns a value that indicates whether two objects are equal. + /// + /// The first span to compare. + /// The second span to compare. + /// + /// if the two objects are equal; otherwise, . + /// + /// + /// Two objects are equal if they have the same length and if the corresponding elements of and point to the same memory. + /// Note that the test for equality does *not* attempt to determine if the contents are equal. + /// + public static bool operator ==(Span left, Span right) => + left._length == right._length && left._array == right._array; + + /// + /// Defines an implicit conversion of a to a + /// + /// The object to convert to a . + /// + /// A read-only span that corresponds to the current instance. + /// + public static implicit operator ReadOnlySpan(Span span) => + new ReadOnlySpan(span._array, 0, span._length); + + /// + /// Forms a slice out of the current span that begins at a specified index. + /// + /// The zero-based index at which to begin the slice. + /// A span that consists of all elements of the current span from to the end of the span. + /// + /// is less than zero or greater than the number of elements in the current span. + /// + public Span Slice(int start) + { + if ((uint)start > (uint)_length) + { + throw new ArgumentOutOfRangeException(); + } + + return new Span(_array, start, _length - start); + } + + /// + /// Forms a slice out of the current span starting at a specified index for a specified length. + /// + /// The zero-based index at which to begin the slice. + /// The desired length for the slice. + /// A span that consists of elements from the current span starting at . + /// + /// or + is less than zero or greater than . + /// + public Span Slice(int start, int length) + { + if ((uint)start > (uint)_length + || (uint)length > (uint)(_length - start)) + { + throw new ArgumentOutOfRangeException(); + } + + return new Span(_array, start, length); + } + + /// + /// Copies the contents of this span into a new array. + /// + /// + /// An array containing the data in the current span. + /// + /// + /// This method performs a heap allocation and therefore should be avoided if possible. Heap allocations are expected in APIs that work with arrays. Using such APIs is unavoidable if an alternative API overload that takes a does not exist. + /// + public T[] ToArray() + { + T[] destination = new T[_length]; + Array.Copy(_array, 0, destination, 0, _length); + return destination; + } + + #region native methods + + [MethodImpl(MethodImplOptions.InternalCall)] + private extern void NativeSpanConstructor( + T[] array, + int start, + int length); + + #endregion + } +} + +#pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one diff --git a/nanoFramework.CoreLibrary/System/SpanDebugView.cs b/nanoFramework.CoreLibrary/System/SpanDebugView.cs new file mode 100644 index 00000000..03c34234 --- /dev/null +++ b/nanoFramework.CoreLibrary/System/SpanDebugView.cs @@ -0,0 +1,27 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace System +{ + [ExcludeType] + internal sealed class SpanDebugView + { + private readonly T[] _array; + + public SpanDebugView(Span span) + { + _array = span.ToArray(); + } + + public SpanDebugView(ReadOnlySpan span) + { + _array = span.ToArray(); + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public T[] Items => _array; + } +} diff --git a/nanoFramework.CoreLibrary/System/String.cs b/nanoFramework.CoreLibrary/System/String.cs index fdcf2909..9d28c0ab 100644 --- a/nanoFramework.CoreLibrary/System/String.cs +++ b/nanoFramework.CoreLibrary/System/String.cs @@ -1,23 +1,12 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Collections; using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; namespace System { - - /* Unmerged change from project 'CoreLibrary' - Before: - using Runtime.CompilerServices; - using System.Collections; - /// - After: - using System.Collections; - using Runtime.CompilerServices; - /// - */ - using System.Collections; - using Runtime.CompilerServices; /// /// Represents text as a sequence of UTF-16 code units. /// @@ -41,7 +30,7 @@ public sealed class String : IComparable, IEnumerable public IEnumerator GetEnumerator() { // Not implemented because of assembly size constraint - // Throw a NotSupportedException in compliance of .net practices + // Throw a NotSupportedException in compliance with .NET practices // (no message to preserve assembly size/memory consumption) // See https://docs.microsoft.com/en-us/dotnet/api/system.notsupportedexception throw new NotSupportedException(); @@ -50,7 +39,7 @@ public IEnumerator GetEnumerator() /// /// Represents the empty string. This field is read-only. /// - public static readonly String Empty = ""; + public static readonly string Empty = ""; /// /// Determines whether this instance and a specified object, which must also be a String object, have the same value. @@ -59,7 +48,7 @@ public IEnumerator GetEnumerator() /// true if obj is a String and its value is the same as this instance; otherwise, false. If obj is null, the method returns false. public override bool Equals(object obj) { - var s = obj as String; + var s = obj as string; return s != null && Equals(this, s); } @@ -68,30 +57,57 @@ public override bool Equals(object obj) /// /// The first string to compare, or null. /// The second string to compare, or null. - /// true if the value of a is the same as the value of b; otherwise, false. If both a and b are null, the method returns true. + /// if the value of is the same as the value of ; otherwise, false. If both and are , the method returns . +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public static extern bool Equals(String a, String b); + public static extern bool Equals(string a, string b); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern bool Equals(string a, string b); +#endif /// /// Determines whether two specified strings have the same value. /// /// The first string to compare, or null. /// The second string to compare, or null. - /// true if the value of a is the same as the value of b; otherwise, false. + /// if the value of is the same as the value of ; otherwise, . +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern bool operator ==(string? a, string? b); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public static extern bool operator ==(String a, String b); + public static extern bool operator ==(string a, string b); +#endif /// /// Determines whether two specified strings have different values. /// /// The first string to compare, or null. /// The second string to compare, or null. - /// true if the value of a is different from the value of b; otherwise, false. + /// if the value of is different from the value of ; otherwise, . +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public static extern bool operator !=(String a, String b); + public static extern bool operator !=(string? a, string? b); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern bool operator !=(string a, string b); +#endif /// - /// Gets the Char object at a specified position in the current String object. + /// Gets the object at a specified position in the current object. /// /// The object at position index. /// A position in the current string. @@ -119,7 +135,7 @@ internal char GetCharByIndex(int index) /// /// The starting position of a substring in this instance. /// The length of the substring in this instance. - /// A Unicode character array whose elements are the length number of characters in this instance starting from character position startIndex. + /// A Unicode character array whose elements are the length number of characters in this instance starting from character position . [MethodImpl(MethodImplOptions.InternalCall)] public extern char[] ToCharArray(int startIndex, int length); @@ -139,35 +155,106 @@ public extern int Length /// Splits a string into substrings that are based on the characters in an array. /// /// A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null. - /// An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. For more information, see the Remarks section. + /// An array whose elements contain the substrings from this instance that are delimited by one or more characters in . +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public extern String[] Split(params char[] separator); + public extern string[] Split(params char[]? separator); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string[] Split(params char[] separator); +#endif /// /// Splits a string into a maximum number of substrings based on the characters in an array. You also specify the maximum number of substrings to return. /// /// A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null. /// The maximum number of substrings to return. - /// An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. For more information, see the Remarks section. + /// An array whose elements contain the substrings in this instance that are delimited by one or more characters in +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string[] Split(char[]? separator, int count); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public extern String[] Split(char[] separator, int count); + public extern string[] Split(char[] separator, int count); +#endif /// /// Retrieves a substring from this instance. The substring starts at a specified character position and continues to the end of the string. /// /// The zero-based starting character position of a substring in this instance. - /// A string that is equivalent to the substring that begins at startIndex in this instance, or Empty if startIndex is equal to the length of this instance. + /// A string that is equivalent to the substring that begins at in this instance, or if is equal to the length of this instance. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String Substring(int startIndex); + public extern string Substring(int startIndex); /// /// Retrieves a substring from this instance. The substring starts at a specified character position and has a specified length. /// /// The zero-based starting character position of a substring in this instance. /// The number of characters in the substring. - /// A string that is equivalent to the substring of length length that begins at startIndex in this instance, or Empty if startIndex is equal to the length of this instance and length is zero. + /// A string that is equivalent to the substring of length that begins at in this instance, or if is equal to the length of this instance and length is zero. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String Substring(int startIndex, int length); + public extern string Substring(int startIndex, int length); + + /// + /// Removes all leading and trailing white-space characters from the current string. + /// + /// The string that remains after all white-space characters are removed from the start and end of the current string. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string Trim(); + +#if NANOCLR_REFLECTION + +#nullable enable + + /// + /// Removes all the leading occurrences of a set of characters specified in an array from the current string. + /// + /// An array of Unicode characters to remove, or . + /// The string that remains after all occurrences of characters in the parameter are removed from the start of the current string. If is or an empty array, white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string Trim(params char[]? trimChars); + + /// + /// Removes all the leading occurrences of a set of characters specified in an array from the current string. + /// + /// The string that remains after all occurrences of characters in the trimChars parameter are removed from the start of the current string. If trimChars is null or an empty array, white-space characters are removed instead. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string TrimStart(); + + /// + /// Removes all the leading occurrences of a set of characters specified in an array from the current string. + /// + /// An array of Unicode characters to remove, or . + /// The string that remains after all occurrences of characters in the parameter are removed from the start of the current string. If is or an empty array, white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string TrimStart(params char[]? trimChars); + + /// + /// Removes all the trailing occurrences of a set of characters specified in an array from the current string. + /// + /// The string that remains after all white-space characters are removed from the end of the current string. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string TrimEnd(); + + /// + /// Removes all the trailing occurrences of a set of characters specified in an array from the current string. + /// + /// An array of Unicode characters to remove, or . + /// The string that remains after all occurrences of the characters in the parameter are removed from the end of the current string. If is or an empty array, Unicode white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern string TrimEnd(params char[]? trimChars); + +#nullable restore + +#else /// /// Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object. @@ -177,23 +264,25 @@ public extern int Length /// If trimChars is null or an empty array, white-space characters are removed instead. If no characters can be trimmed from the current instance, /// the method returns the current instance unchanged. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String Trim(params char[] trimChars); + public extern string Trim(params char[] trimChars); /// - /// Removes all leading occurrences of a set of characters specified in an array from the current String object. + /// Removes all the leading occurrences of a set of characters specified in an array from the current string. /// - /// An array of Unicode characters to remove, or null. - /// The string that remains after all occurrences of characters in the trimChars parameter are removed from the start of the current string. If trimChars is null or an empty array, white-space characters are removed instead. + /// An array of Unicode characters to remove, or . + /// The string that remains after all occurrences of characters in the parameter are removed from the start of the current string. If is or an empty array, white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String TrimStart(params char[] trimChars); + public extern string TrimStart(params char[] trimChars); /// - /// Removes all trailing occurrences of a set of characters specified in an array from the current String object. + /// Removes all the trailing occurrences of a set of characters specified in an array from the current string. /// - /// An array of Unicode characters to remove, or null. - /// The string that remains after all occurrences of the characters in the trimChars parameter are removed from the end of the current string. If trimChars is null or an empty array, Unicode white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. + /// An array of Unicode characters to remove, or . + /// The string that remains after all occurrences of the characters in the parameter are removed from the end of the current string. If is or an empty array, Unicode white-space characters are removed instead. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String TrimEnd(params char[] trimChars); + public extern string TrimEnd(params char[] trimChars); + +#endif /// /// Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length. @@ -224,31 +313,63 @@ public extern int Length /// /// The first string to compare. /// The second string to compare. - /// A 32-bit signed integer that indicates the lexical relationship between the two comparands. + /// + /// A 32-bit signed integer that indicates the lexical relationship between the two comparands. + /// Less than zero : precedes in the sort order. + /// Zero : occurs in the same position as in the sort order. + /// Greater than zero : follows in the sort order. + /// +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern int Compare(string? strA, string? strB); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public static extern int Compare(String strA, String strB); + public static extern int Compare(string strA, string strB); +#endif /// - /// Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object. + /// Compares this instance with a specified and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified . /// - /// An object that evaluates to a String. - /// A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the value parameter. + /// An object that evaluates to a . + /// A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the parameter. +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public extern int CompareTo(Object value); + public extern int CompareTo(object? value); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public extern int CompareTo(object value); +#endif /// - /// Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string. + /// Compares this instance with a specified object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string. /// /// The string to compare with this instance. - /// A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the strB parameter. + /// A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the parameter. +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public extern int CompareTo(String strB); + public extern int CompareTo(string? strB); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public extern int CompareTo(string strB); +#endif /// /// Reports the zero-based index of the first occurrence of the specified Unicode character in this string. /// /// A Unicode character to seek. - /// The zero-based index position of value if that character is found, or -1 if it is not. + /// The zero-based index position of if that character is found, or -1 if it is not. [MethodImpl(MethodImplOptions.InternalCall)] public extern int IndexOf(char value); @@ -257,7 +378,7 @@ public extern int Length /// /// A Unicode character to seek. /// The search starting position. - /// The zero-based index position of value from the start of the string if that character is found, or -1 if it is not. + /// The zero-based index position of from the start of the string if that character is found, or -1 if it is not. [MethodImpl(MethodImplOptions.InternalCall)] public extern int IndexOf(char value, int startIndex); @@ -267,69 +388,69 @@ public extern int Length /// A Unicode character to seek. /// The search starting position. /// The number of character positions to examine. - /// The zero-based index position of value if that character is found, or -1 if it is not. + /// The zero-based index position of if that character is found, or -1 if it is not. [MethodImpl(MethodImplOptions.InternalCall)] public extern int IndexOf(char value, int startIndex, int count); /// - /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. + /// Reports the zero-based index of the first occurrence of the specified string in this instance. /// - /// A Unicode character array containing one or more characters to seek. - /// The zero-based index position of the first occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found. + /// The string to seek. + /// The zero-based index position of if that string is found, or -1 if it is not. If is , the return value is 0. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOfAny(char[] anyOf); + public extern int IndexOf(string value); /// - /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position. + /// Reports the zero-based index of the first occurrence of the specified string in this instance. The search starts at a specified character position. /// - /// A Unicode character array containing one or more characters to seek. + /// The string to seek. /// The search starting position. - /// The zero-based index position of the first occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found. + /// The zero-based index position of from the start of the current instance if that string is found, or -1 if it is not. If is , the return value is . [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOfAny(char[] anyOf, int startIndex); + public extern int IndexOf(string value, int startIndex); /// - /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position and examines a specified number of character positions. + /// Reports the zero-based index of the first occurrence of the specified string in this instance. The search starts at a specified character position and examines a specified number of character positions. /// - /// A Unicode character array containing one or more characters to seek. + /// The string to seek. /// The search starting position. /// The number of character positions to examine. - /// The zero-based index position of the first occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found. + /// The zero-based index position of value from the start of the current instance if that string is found, or -1 if it is not. If value is String.Empty, the return value is startIndex. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOfAny(char[] anyOf, int startIndex, int count); + public extern int IndexOf(string value, int startIndex, int count); /// - /// Reports the zero-based index of the first occurrence of the specified string in this instance. + /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. /// - /// The string to seek. - /// The zero-based index position of value if that string is found, or -1 if it is not. If value is String.Empty, the return value is 0. + /// A Unicode character array containing one or more characters to seek. + /// The zero-based index position of the first occurrence in this instance where any character in was found; -1 if no character in was found. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOf(String value); + public extern int IndexOfAny(char[] anyOf); /// - /// Reports the zero-based index of the first occurrence of the specified string in this instance. The search starts at a specified character position. + /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position. /// - /// The string to seek. + /// A Unicode character array containing one or more characters to seek. /// The search starting position. - /// The zero-based index position of value from the start of the current instance if that string is found, or -1 if it is not. If value is String.Empty, the return value is startIndex. + /// The zero-based index position of the first occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOf(String value, int startIndex); + public extern int IndexOfAny(char[] anyOf, int startIndex); /// - /// Reports the zero-based index of the first occurrence of the specified string in this instance. The search starts at a specified character position and examines a specified number of character positions. + /// Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. The search starts at a specified character position and examines a specified number of character positions. /// - /// The string to seek. + /// A Unicode character array containing one or more characters to seek. /// The search starting position. /// The number of character positions to examine. - /// The zero-based index position of value from the start of the current instance if that string is found, or -1 if it is not. If value is String.Empty, the return value is startIndex. + /// The zero-based index position of the first occurrence in this instance where any character in was found; -1 if no character in was found. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int IndexOf(String value, int startIndex, int count); + public extern int IndexOfAny(char[] anyOf, int startIndex, int count); /// /// Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. /// /// The Unicode character to seek. - /// The zero-based index position of value if that character is found, or -1 if it is not. + /// The zero-based index position of if that character is found, or -1 if it is not. [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOf(char value); @@ -337,8 +458,8 @@ public extern int Length /// Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string. /// /// The Unicode character to seek. - /// The starting position of the search. The search proceeds from startIndex toward the beginning of this instance. - /// The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals String.Empty. + /// The starting position of the search. The search proceeds from toward the beginning of this instance. + /// The zero-based index position of if that character is found, or -1 if it is not found or if the current instance equals . [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOf(char value, int startIndex); @@ -346,9 +467,9 @@ public extern int Length /// Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions. /// /// The Unicode character to seek. - /// The starting position of the search. The search proceeds from startIndex toward the beginning of this instance. + /// The starting position of the search. The search proceeds from toward the beginning of this instance. /// The number of character positions to examine. - /// The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals String.Empty. + /// The zero-based index position of if that character is found, or -1 if it is not found or if the current instance equals . [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOf(char value, int startIndex, int count); @@ -356,7 +477,7 @@ public extern int Length /// Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. /// /// A Unicode character array containing one or more characters to seek. - /// The index position of the last occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found. + /// The index position of the last occurrence in this instance where any character in was found; -1 if no character in was found. [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOfAny(char[] anyOf); @@ -365,7 +486,7 @@ public extern int Length /// /// A Unicode character array containing one or more characters to seek. /// The search starting position. The search proceeds from startIndex toward the beginning of this instance. - /// The index position of the last occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found or if the current instance equals String.Empty. + /// The index position of the last occurrence in this instance where any character in was found; -1 if no character in was found or if the current instance equals . [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOfAny(char[] anyOf, int startIndex); @@ -375,7 +496,7 @@ public extern int Length /// A Unicode character array containing one or more characters to seek. /// The search starting position. The search proceeds from startIndex toward the beginning of this instance. /// The number of character positions to examine. - /// The index position of the last occurrence in this instance where any character in anyOf was found; -1 if no character in anyOf was found or if the current instance equals String.Empty. + /// The index position of the last occurrence in this instance where any character in was found; -1 if no character in was found or if the current instance equals . [MethodImpl(MethodImplOptions.InternalCall)] public extern int LastIndexOfAny(char[] anyOf, int startIndex, int count); @@ -383,18 +504,18 @@ public extern int Length /// Reports the zero-based index position of the last occurrence of a specified string within this instance. /// /// The string to seek. - /// The zero-based starting index position of value if that string is found, or -1 if it is not. If value is String.Empty, the return value is the last index position in this instance. + /// The zero-based starting index position of if that string is found, or -1 if it is not. If is , the return value is the last index position in this instance. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int LastIndexOf(String value); + public extern int LastIndexOf(string value); /// /// Reports the zero-based index position of the last occurrence of a specified string within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string. /// /// The string to seek. /// The search starting position. The search proceeds from startIndex toward the beginning of this instance. - /// The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals String.Empty. If value is String.Empty, the return value is the smaller of startIndex and the last index position in this instance. + /// The zero-based starting index position of if that string is found, or -1 if it is not found or if the current instance equals . If is , the return value is the smaller of and the last index position in this instance. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int LastIndexOf(String value, int startIndex); + public extern int LastIndexOf(string value, int startIndex); /// /// Reports the zero-based index position of the last occurrence of a specified string within this instance. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions. @@ -402,45 +523,39 @@ public extern int Length /// The string to seek. /// The search starting position. The search proceeds from startIndex toward the beginning of this instance. /// The number of character positions to examine. - /// The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals String.Empty. If value is Empty, the return value is the smaller of startIndex and the last index position in this instance. + /// The zero-based starting index position of if that string is found, or -1 if it is not found or if the current instance equals . If is , the return value is the smaller of and the last index position in this instance. [MethodImpl(MethodImplOptions.InternalCall)] - public extern int LastIndexOf(String value, int startIndex, int count); + public extern int LastIndexOf(string value, int startIndex, int count); /// /// Returns a copy of this string converted to lowercase. /// /// A string in lowercase. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String ToLower(); + public extern string ToLower(); /// /// Returns a copy of this string converted to uppercase. /// /// The uppercase equivalent of the current string. [MethodImpl(MethodImplOptions.InternalCall)] - public extern String ToUpper(); + public extern string ToUpper(); /// /// Returns this instance of String; no actual conversion is performed. /// /// The current string. - public override String ToString() + public override string ToString() { return this; } - /// - /// Removes all leading and trailing white-space characters from the current String object. - /// - /// The string that remains after all white-space characters are removed from the start and end of the current string. If no characters can be trimmed from the current instance, the method returns the current instance unchanged. - [MethodImpl(MethodImplOptions.InternalCall)] - public extern String Trim(); /// /// Creates the string representation of a specified object. /// /// The object to represent, or null. /// The string representation of the value of arg0, or String.Empty if arg0 is null. - public static String Concat(Object arg0) + public static string Concat(object arg0) { return arg0 == null ? Empty : arg0.ToString(); } @@ -451,17 +566,11 @@ public static String Concat(Object arg0) /// The first object to concatenate. /// The second object to concatenate. /// The concatenated string representations of the values of arg0 and arg1. - public static String Concat(Object arg0, Object arg1) + public static string Concat(object arg0, object arg1) { - if (arg0 == null) - { - arg0 = Empty; - } + arg0 ??= Empty; - if (arg1 == null) - { - arg1 = Empty; - } + arg1 ??= Empty; return Concat(arg0.ToString(), arg1.ToString()); } @@ -473,22 +582,11 @@ public static String Concat(Object arg0, Object arg1) /// The second object to concatenate. /// The third object to concatenate. /// The concatenated string representations of the values of arg0, arg1 and arg2. - public static String Concat(Object arg0, Object arg1, Object arg2) + public static string Concat(object arg0, object arg1, object arg2) { - if (arg0 == null) - { - arg0 = Empty; - } - - if (arg1 == null) - { - arg1 = Empty; - } - - if (arg2 == null) - { - arg2 = Empty; - } + arg0 ??= Empty; + arg1 ??= Empty; + arg2 ??= Empty; return Concat(arg0.ToString(), arg1.ToString(), arg2.ToString()); } @@ -499,14 +597,17 @@ public static String Concat(Object arg0, Object arg1, Object arg2) /// An object array that contains the elements to concatenate. /// The concatenated string representations of the values of the elements in args. /// - public static String Concat(params Object[] args) + public static string Concat(params object[] args) { - if (args == null) throw new ArgumentNullException("args"); + if (args == null) + { + throw new ArgumentNullException("args"); + } - var length = args.Length; - var sArgs = new String[length]; + int length = args.Length; + string[] sArgs = new string[length]; - for (var i = 0; i < length; i++) + for (int i = 0; i < length; i++) { sArgs[i] = args[i] == null ? Empty : args[i].ToString(); } @@ -515,59 +616,95 @@ public static String Concat(params Object[] args) } /// - /// Concatenates two specified instances of String. + /// Concatenates two specified instances of . /// /// The first string to concatenate. /// The second string to concatenate. - /// The concatenation of str0 and str1. + /// The concatenation of and . +#if NANOCLR_REFLECTION + +#nullable enable [MethodImpl(MethodImplOptions.InternalCall)] - public static extern String Concat(String str0, String str1); + public static extern string Concat(string? str0, string? str1); +#nullable restore + +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Concat(string str0, string str1); +#endif /// - /// Concatenates three specified instances of String. + /// Concatenates three specified instances of . /// /// The first string to concatenate. /// The second string to concatenate. /// The third string to concatenate. - /// The concatenation of str0, str1 and str2. + /// The concatenation of , and . +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Concat(string? str0, string? str1, string? str2); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public static extern String Concat(String str0, String str1, String str2); + public static extern string Concat(string str0, string str1, string str2); +#endif /// - /// Concatenates four specified instances of String. + /// Concatenates four specified instances of . /// /// The first string to concatenate. /// The second string to concatenate. /// The third string to concatenate. /// The fourth string to concatenate. /// The concatenation of str0, str1, str2 and str3. +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Concat(string? str0, string? str1, string? str2, string? str3); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public static extern String Concat(String str0, String str1, String str2, String str3); + public static extern string Concat(string str0, string str1, string str2, string str3); +#endif /// - /// Concatenates the elements of a specified String array. + /// Concatenates the elements of a specified array. /// /// An array of string instances. - /// The concatenated elements of values. + /// The concatenated elements of . +#if NANOCLR_REFLECTION + +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Concat(params string?[] values); +#nullable restore + +#else [MethodImpl(MethodImplOptions.InternalCall)] - public static extern String Concat(params String[] values); + public static extern string Concat(params string[] values); +#endif /// - /// Retrieves the system's reference to the specified String. + /// Retrieves the system's reference to the specified . /// /// A string to search for in the intern pool. - /// The system's reference to str, if it is interned; otherwise, a new reference to a string with the value of str. - public static String Intern(String str) + /// The system's reference to , if it is interned; otherwise, a new reference to a string with the value of . + public static string Intern(string str) { return str; } /// - /// Retrieves a reference to a specified String. + /// Retrieves a reference to a specified . /// /// The string to search for in the intern pool. - /// A reference to str if it is in the common language runtime intern pool; otherwise, null. - public static String IsInterned(String str) + /// A reference to if it is in the common language runtime intern pool; otherwise, . + public static string IsInterned(string str) { return str; } @@ -577,221 +714,31 @@ public static String IsInterned(String str) /// /// A composite format string /// An object array that contains zero or more objects to format. - /// A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args. - public static string Format(string format, params object[] args) - { - var index = 0; - var alignment = 0; - var chr = '\0'; - var len = format.Length; - var fmt = Empty; - var token = Empty; - var output = Empty; - - if (format is null) - { - throw new ArgumentNullException("format can't be null"); - } - - for (var i = 0; i < len; i++) - { - token = Empty; - chr = format[i]; - - if (chr == '{') - { - if (i + 1 == len) - { - throw new ArgumentException("Format error: no closed brace, column " + i); - } - - if (format[i + 1] == '{') - { - output += chr; - i++; - continue; - } - else - { - alignment = 0; - fmt = Empty; - - for (i++; i < len; i++) - { - chr = format[i]; - - if (chr >= '0' && chr <= '9') - { - token += chr; - } - else if (chr == ',' || chr == ':' || chr == '}') - { - break; - } - else - { - throw new ArgumentException("Format error: wrong symbol at {}, column " + i); - } - } - - if (token.Length > 0) - { - index = int.Parse(token); - } - else - { - throw new ArgumentException("Format error: empty {}, column " + i); - } - - if (chr == ',') - { - if (format[i + 1] == '-') - { - token = "-"; - i++; - } - else - { - token = Empty; - } - - for (i++; i < len; i++) - { - chr = format[i]; - - if (chr >= '0' && chr <= '9') - { - token += chr; - } - else if (chr == ':' || chr == '}') - { - break; - } - else - { - throw new ArgumentException("Format error: wrong symbol at alignment, column " + i); - } - } - - if (token.Length > 0) - { - alignment = int.Parse(token); - } - else - { - throw new ArgumentException("Format error: empty alignment, column " + i); - } - } - - if (chr == ':') - { - token = Empty; - for (i++; i < len; i++) - { - chr = format[i]; - - if (chr == '}') - { - break; - } - else - { - token += chr; - } - } - - if (token.Length > 0) - { - fmt = token; - } - else - { - throw new ArgumentException("Format error: empty format after ':', column " + i); - } - } - } - - if (chr != '}') - { - throw new ArgumentException("Format error: no closed brace, column " + i); - } - - if (fmt.Length > 0) - { + /// A copy of in which the format items have been replaced by the string representation of the corresponding objects in . #if NANOCLR_REFLECTION - if (args[index] is null) - { - token = ""; - } - else - { - var method = args[index].GetType().GetMethod("ToString", new Type[] { typeof(string) }); - token = (method is null) - ? args[index].ToString() - : method.Invoke(args[index], new object[] { token }).ToString(); - } -#else - throw new NotImplementedException(); -#endif // NANOCLR_REFLECTION - - } - else - { - token = args[index] == null ? "" : args[index].ToString(); - } - - if (alignment > 0) - { - output += token.PadLeft(alignment); - } - else if (alignment < 0) - { - output += token.PadRight(MathInternal.Abs(alignment)); - } - else - { - output += token; - } - } - else if (chr == '}') - { - if (i + 1 == len) - { - throw new ArgumentException("Format error: no closed brace, column " + i); - } - - if (format[i + 1] == '}') - { - output += chr; - i++; - } - else - { - throw new ArgumentException("Format error: no closed brace, column " + i); - } - } - else - { - output += chr; - } - } +#nullable enable + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Format(string format, params object?[] args); +#nullable restore - return output; - } +#else + [MethodImpl(MethodImplOptions.InternalCall)] + public static extern string Format(string format, params object[] args); +#endif /// /// Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length. /// /// The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters. /// A Unicode padding character. - /// - public String PadLeft(int totalWidth, char paddingChar = ' ') + /// A new string that is equivalent to this instance, but right-aligned and padded on the left with as many characters as needed to create a length of . However, if is less than the length of this instance, the method returns a reference to the existing instance. If is equal to the length of this instance, the method returns a new string that is identical to this instance. + public string PadLeft(int totalWidth, char paddingChar = ' ') { if (totalWidth < 0) { #pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one - throw new ArgumentOutOfRangeException("totalWidth can't be less than 0"); + throw new ArgumentOutOfRangeException(); #pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one } @@ -801,7 +748,7 @@ public String PadLeft(int totalWidth, char paddingChar = ' ') } else { - return new String(paddingChar, totalWidth - Length) + this; + return new string(paddingChar, totalWidth - Length) + this; } } @@ -810,13 +757,13 @@ public String PadLeft(int totalWidth, char paddingChar = ' ') /// /// The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters. /// A Unicode padding character. - /// - public String PadRight(int totalWidth, char paddingChar = ' ') + /// A new string that is equivalent to this instance, but left-aligned and padded on the right with as many characters as needed to create a length of . However, if is less than the length of this instance, the method returns a reference to the existing instance. If is equal to the length of this instance, the method returns a new string that is identical to this instance. + public string PadRight(int totalWidth, char paddingChar = ' ') { if (totalWidth < 0) { #pragma warning disable S3928 // Parameter names used into ArgumentException constructors should match an existing one - throw new ArgumentOutOfRangeException("totalWidth can't be less than 0"); + throw new ArgumentOutOfRangeException(); #pragma warning restore S3928 // Parameter names used into ArgumentException constructors should match an existing one } @@ -826,7 +773,7 @@ public String PadRight(int totalWidth, char paddingChar = ' ') } else { - return this + new String(paddingChar, totalWidth - Length); + return this + new string(paddingChar, totalWidth - Length); } } @@ -835,7 +782,15 @@ public String PadRight(int totalWidth, char paddingChar = ' ') /// /// The string to test. /// if the value parameter is or an empty string (""); otherwise, . - public static bool IsNullOrEmpty([NotNullWhen(false)] string value) +#if NANOCLR_REFLECTION + +#nullable enable + public static bool IsNullOrEmpty([NotNullWhen(false)] string? value) +#nullable restore + +#else + public static bool IsNullOrEmpty(string value) +#endif { return value == null || value.Length == 0; } diff --git a/nanoFramework.CoreLibrary/System/Type.cs b/nanoFramework.CoreLibrary/System/Type.cs index d7a134f5..e37e067d 100644 --- a/nanoFramework.CoreLibrary/System/Type.cs +++ b/nanoFramework.CoreLibrary/System/Type.cs @@ -51,6 +51,20 @@ public static Type GetType(String typeName) return GetTypeInternal(name, assemblyName, fVersion, ver); } + /// + /// Returns a object that represents a generic type definition from which the current generic type can be constructed. + /// + /// A object representing a generic type from which the current type can be constructed. + [MethodImpl(MethodImplOptions.InternalCall)] + public virtual extern Type GetGenericTypeDefinition(); + + /// + /// Returns an array of objects that represent the type arguments of a closed generic type or the type parameters of a generic type definition. + /// + /// An array of objects that represent the type arguments of a generic type. Returns an empty array if the current type is not a generic type. + [MethodImpl(MethodImplOptions.InternalCall)] + public extern Type[] GetGenericArguments(); + [Diagnostics.DebuggerHidden] [MethodImpl(MethodImplOptions.InternalCall)] private static extern Type GetTypeInternal(String typeName, string assemblyName, bool fVersion, int[] ver); @@ -357,6 +371,30 @@ public extern bool IsArray get; } + /// + /// Gets a value indicating whether the current type is a generic type. + /// + /// + /// if the current type is a generic type; otherwise, . + /// + public extern bool IsGenericType + { + [MethodImpl(MethodImplOptions.InternalCall)] + get; + } + + /// + /// Gets a value that indicates whether the type is a generic type definition. + /// + /// + /// if the current type is a generic type definition; otherwise, . + /// + public extern bool IsGenericTypeDefinition + { + [MethodImpl(MethodImplOptions.InternalCall)] + get; + } + /// /// When overridden in a derived class, returns the Type of the object encompassed or referred to by the current array, pointer or reference type. /// diff --git a/nanoFramework.TestFramework b/nanoFramework.TestFramework index 18e4b3d4..9f6e02c6 160000 --- a/nanoFramework.TestFramework +++ b/nanoFramework.TestFramework @@ -1 +1 @@ -Subproject commit 18e4b3d4b0c6b647bc3c2a8a0d11a53c059145a7 +Subproject commit 9f6e02c66b16c0078e2c01490925e33eb3537d98 diff --git a/version.json b/version.json index 7cad52c4..3269dd37 100644 --- a/version.json +++ b/version.json @@ -1,6 +1,6 @@ { "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json", - "version": "1.17", + "version": "2.0.0-preview.{height}", "assemblyVersion": { "precision": "build" }, @@ -11,6 +11,7 @@ "publicReleaseRefSpec": [ "^refs/heads/develop$", "^refs/heads/main$", + "^refs/heads/generics$", "^refs/heads/v\\d+(?:\\.\\d+)?$" ], "cloudBuild": {