Add some more stuff

Author: LoneWandererProductions

CommonExtendedObjectsTests/IntListTests.cs

@@ -79,6 +79,87 @@ public void CapacityResizesCorrectly()
             Assert.AreEqual(999, list[999]);
         }
 
+#if DEBUG
+        /// <summary>
+        /// Indexes the get out of bounds throws.
+        /// </summary>
+        [TestMethod]
+        [ExpectedException(typeof(IndexOutOfRangeException))]
+        public void IndexGetOutOfBoundsThrows()
+        {
+            using var list = new UnmanagedIntList(1);
+            var _ = list[5];
+        }
+
+        /// <summary>
+        /// Indexes the set out of bounds throws.
+        /// </summary>
+        [TestMethod]
+        [ExpectedException(typeof(IndexOutOfRangeException))]
+        public void IndexSetOutOfBoundsThrows()
+        {
+            using var list = new UnmanagedIntList(1) {[3] = 99};
+        }
+#endif
+
+        /// <summary>
+        /// Removes at invalid index throws.
+        /// </summary>
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentOutOfRangeException))]
+        public void RemoveAtInvalidIndexThrows()
+        {
+            using var list = new UnmanagedIntList(1) {1};
+            list.RemoveAt(2);
+        }
+
+        /// <summary>
+        /// Inserts at adds elements correctly.
+        /// </summary>
+        [TestMethod]
+        public void InsertAtAddsElementsCorrectly()
+        {
+            using var list = new UnmanagedIntList(2) {1, 2};
+            list.InsertAt(1, 99); // Between 1 and 2
+
+            Assert.AreEqual(3, list.Length);
+            Assert.AreEqual(1, list[0]);
+            Assert.AreEqual(99, list[1]);
+            Assert.AreEqual(2, list[2]);
+        }
+
+        /// <summary>
+        /// Inserts at with count adds multiple.
+        /// </summary>
+        [TestMethod]
+        public void InsertAtWithCountAddsMultiple()
+        {
+            using var list = new UnmanagedIntList(2) {1, 2};
+            list.InsertAt(1, 99, 2); // Insert 99 twice at index 1
+
+            Assert.AreEqual(4, list.Length);
+            Assert.AreEqual(1, list[0]);
+            Assert.AreEqual(99, list[1]);
+            Assert.AreEqual(99, list[2]);
+            Assert.AreEqual(2, list[3]);
+        }
+
+        /// <summary>
+        /// Disposes the state of the frees memory and invalidates.
+        /// </summary>
+        [TestMethod]
+        public void DisposeFreesMemoryAndInvalidatesState()
+        {
+            var list = new UnmanagedIntList(2) { 1 };
+            list.Dispose();
+
+            // Post-condition: buffer is cleared, pointers null, Length and Capacity are zero.
+            // Behavior is undefined after Dispose. No exception is required.
+            // Test only verifies internal reset, not enforcement.
+            Assert.AreEqual(0, list.Length);
+            Assert.AreEqual(0, list.Capacity);
+        }
+
         /// <summary>
         ///     Performances the benchmark.
         /// </summary>

CommonLibraryGuiTests/Image/example Polaris.png

@@ -6,6 +6,8 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
+// ReSharper disable UnusedMember.Global
+
 using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -116,5 +118,68 @@ internal static unsafe void ShiftLeft<T>(T* ptr, int index, int count, int lengt
                 elementsToShift * sizeof(T),
                 elementsToShift * sizeof(T));
         }
+
+        /// <summary>
+        ///     Copies a block of unmanaged memory from source to destination.
+        ///     Similar to memcpy.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe void Copy<T>(T* source, T* destination, int count) where T : unmanaged
+        {
+            Buffer.MemoryCopy(source, destination, count * sizeof(T), count * sizeof(T));
+        }
+
+        /// <summary>
+        ///     Allocates and clones a block of unmanaged memory from a given source.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe IntPtr Clone<T>(T* source, int count) where T : unmanaged
+        {
+            var size = sizeof(T) * count;
+            var dest = Marshal.AllocHGlobal(size);
+            Buffer.MemoryCopy(source, dest.ToPointer(), size, size);
+            return dest;
+        }
+
+        /// <summary>
+        ///     Fills a block of unmanaged memory with a given value.
+        ///     Equivalent to memset with a pattern.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe void Fill<T>(T* ptr, T value, int count) where T : unmanaged
+        {
+            for (int i = 0; i < count; i++)
+            {
+                ptr[i] = value;
+            }
+        }
+
+        /// <summary>
+        ///     Searches for the first occurrence of a value in unmanaged memory.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe int IndexOf<T>(T* ptr, T value, int length) where T : unmanaged, IEquatable<T>
+        {
+            for (int i = 0; i < length; i++)
+            {
+                if (ptr[i].Equals(value))
+                    return i;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        ///     Swaps two elements in unmanaged memory.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe void Swap<T>(T* ptr, int indexA, int indexB) where T : unmanaged
+        {
+            if (indexA == indexB) return;
+
+            T temp = ptr[indexA];
+            ptr[indexA] = ptr[indexB];
+            ptr[indexB] = temp;
+        }
     }
 }