add some needed stuff

Author: LoneWandererProductions

CommonExtendedObjectsTests/SortedKvStoreTests.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Diagnostics;
+using ExtendedSystemObjects;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CommonExtendedObjectsTests
+{
+    /// <summary>
+    /// Test my Key Value class
+    /// </summary>
+    [TestClass]
+    public class SortedKvStoreTests
+    {
+        /// <summary>
+        /// The item count
+        /// </summary>
+        private const int ItemCount = 100_000;
+
+        /// <summary>
+        /// Adds the and try get works.
+        /// </summary>
+        [TestMethod]
+        public void AddAndTryGetWorks()
+        {
+            var store = new SortedKvStore();
+            store.Add(10, 100);
+            store.Add(5, 50);
+            store.Add(15, 150);
+
+            Assert.IsTrue(store.TryGet(10, out var val10));
+            Assert.AreEqual(100, val10);
+
+            Assert.IsTrue(store.TryGet(5, out var val5));
+            Assert.AreEqual(50, val5);
+
+            Assert.IsTrue(store.TryGet(15, out var val15));
+            Assert.AreEqual(150, val15);
+
+            Assert.IsFalse(store.TryGet(99, out _));
+        }
+
+        /// <summary>
+        /// Tries the remove removes existing.
+        /// </summary>
+        [TestMethod]
+        public void TryRemoveRemovesExisting()
+        {
+            var store = new SortedKvStore();
+            store.Add(1, 10);
+            store.Add(2, 20);
+
+            Assert.IsTrue(store.TryRemove(1, out var idx));
+            Assert.IsFalse(store.TryGet(1, out _));
+            Assert.IsTrue(idx >= 0);
+        }
+
+        /// <summary>
+        /// Removes the many works.
+        /// </summary>
+        [TestMethod]
+        public void RemoveManyWorks()
+        {
+            var store = new SortedKvStore();
+            for (var i = 0; i < 10; i++)
+                store.Add(i, i * 10);
+
+            store.RemoveMany(new int[] { 2, 4, 6 });
+
+            Assert.IsFalse(store.TryGet(2, out _));
+            Assert.IsFalse(store.TryGet(4, out _));
+            Assert.IsFalse(store.TryGet(6, out _));
+
+            Assert.IsTrue(store.TryGet(3, out _));
+        }
+
+        /// <summary>
+        /// Compacts the removes unoccupied.
+        /// </summary>
+        [TestMethod]
+        public void CompactRemovesUnoccupied()
+        {
+            var store = new SortedKvStore();
+            for (var i = 0; i < 10; i++)
+                store.Add(i, i * 10);
+
+            store.Remove(1);
+            store.Remove(3);
+            store.Compact();
+
+            Assert.AreEqual(8, store.Count);
+            Assert.IsFalse(store.TryGet(1, out _));
+        }
+
+        /// <summary>
+        /// Indexers the works.
+        /// </summary>
+        [TestMethod]
+        public void IndexerWorks()
+        {
+            var store = new SortedKvStore();
+            store[42] = 123;
+            Assert.AreEqual(123, store[42]);
+
+            store[42] = 456;
+            Assert.AreEqual(456, store[42]);
+        }
+
+        /// <summary>
+        /// Adds the and try get should return expected values.
+        /// </summary>
+        [TestMethod]
+        public void AddAndTryGetShouldReturnExpectedValues()
+        {
+            var store = new SortedKvStore();
+
+            for (int i = 0; i < 1000; i++)
+                store.Add(i, i * 10);
+
+            for (int i = 0; i < 1000; i++)
+            {
+                Assert.IsTrue(store.TryGet(i, out var value));
+                Assert.AreEqual(i * 10, value);
+            }
+
+            Assert.IsFalse(store.TryGet(1001, out _));
+        }
+
+        /// <summary>
+        /// Performances the add and try get.
+        /// </summary>
+        [TestMethod]
+        public void PerformanceAddAndTryGet()
+        {
+            var store = new SortedKvStore(ItemCount);
+
+            var sw = Stopwatch.StartNew();
+
+            for (int i = 0; i < ItemCount; i++)
+                store.Add(i, i * 2);
+
+            sw.Stop();
+            Trace.WriteLine($"Add {ItemCount} items: {sw.ElapsedMilliseconds} ms");
+
+            sw.Restart();
+
+            int hits = 0;
+            for (int i = 0; i < ItemCount; i++)
+            {
+                if (store.TryGet(i, out var value) && value == i * 2)
+                    hits++;
+            }
+
+            sw.Stop();
+            Trace.WriteLine($"TryGet {ItemCount} items: {sw.ElapsedMilliseconds} ms");
+
+            Assert.AreEqual(ItemCount, hits);
+        }
+
+        /// <summary>
+        /// Performances the remove compact.
+        /// </summary>
+        [TestMethod]
+        public void PerformanceRemoveCompact()
+        {
+            var store = new SortedKvStore(ItemCount);
+
+            for (int i = 0; i < ItemCount; i++)
+                store.Add(i, i);
+
+            // Remove half of them
+            for (int i = 0; i < ItemCount; i += 2)
+                store.Remove(i);
+
+            var sw = Stopwatch.StartNew();
+            store.Compact();
+            sw.Stop();
+
+            Trace.WriteLine($"Compact after removing half: {sw.ElapsedMilliseconds} ms");
+            Assert.AreEqual(ItemCount / 2, store.Count);
+        }
+    }
+}

CommonExtendedObjectsTests/Utilities.cs

@@ -6,7 +6,9 @@
  * PROGRAMER:   Peter Geinitz (Wayfarer)
  */
 
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using ExtendedSystemObjects;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -264,5 +266,92 @@ public void FindSequencesShouldReturnCorrectResultWhenListHasMixedSequences()
             Assert.AreEqual((8, 9, 6), result[4]);
             Assert.AreEqual((10, 10, 7), result[5]);
         }
+
+        /// <summary>
+        /// Binaries the search performance and correctness.
+        /// </summary>
+        [TestMethod]
+        public void BinarySearchPerformanceAndCorrectness()
+        {
+            const int N = 1_000_000;
+            int[] sortedKeys = new int[N];
+            for (int i = 0; i < N; i++)
+                sortedKeys[i] = i * 2; // even numbers sorted
+
+            var keysSpan = sortedKeys.AsSpan();
+
+            // Warm-up to avoid JIT bias
+            for (int i = 0; i < 10_000; i++)
+            {
+                Utility.BinarySearch(keysSpan, N, i * 2);
+            }
+
+            var sw = Stopwatch.StartNew();
+
+            int foundCount = 0;
+            for (int i = 0; i < N; i++)
+            {
+                int val = i * 2;
+                int idx = Utility.BinarySearch(keysSpan, N, val);
+
+                Assert.IsTrue(idx >= 0, $"Key {val} should be found.");
+                Assert.AreEqual(val, sortedKeys[idx]);
+
+                foundCount++;
+            }
+
+            sw.Stop();
+
+            Trace.WriteLine($"BinarySearch found {foundCount} keys out of {N} in {sw.ElapsedMilliseconds} ms");
+
+            // Optional: Assert performance threshold (example: must finish under 200ms)
+            Assert.IsTrue(sw.ElapsedMilliseconds < 1000, $"BinarySearch took too long: {sw.ElapsedMilliseconds} ms");
+        }
+
+        [TestMethod]
+        public void CompareCustomVsArrayBinarySearch_Performance()
+        {
+            const int N = 1_000_000;
+            int[] sortedKeys = new int[N];
+            for (int i = 0; i < N; i++)
+                sortedKeys[i] = i * 2; // even numbers sorted
+
+            var keysSpan = sortedKeys.AsSpan();
+
+            // Warm-up both methods
+            for (int i = 0; i < 10_000; i++)
+            {
+                Utility.BinarySearch(keysSpan, N, i * 2);
+                Array.BinarySearch(sortedKeys, i * 2);
+            }
+
+            // Custom BinarySearch benchmark
+            var swCustom = Stopwatch.StartNew();
+            for (int i = 0; i < N; i++)
+            {
+                int val = i * 2;
+                int idx = Utility.BinarySearch(keysSpan, N, val);
+                Assert.IsTrue(idx >= 0);
+            }
+            swCustom.Stop();
+
+            // Array.BinarySearch benchmark
+            var swArray = Stopwatch.StartNew();
+            for (int i = 0; i < N; i++)
+            {
+                int val = i * 2;
+                int idx = Array.BinarySearch(sortedKeys, val);
+                Assert.IsTrue(idx >= 0);
+            }
+            swArray.Stop();
+
+            Trace.WriteLine($"Custom BinarySearch: {swCustom.ElapsedMilliseconds} ms");
+            Trace.WriteLine($"Array.BinarySearch: {swArray.ElapsedMilliseconds} ms");
+
+            // Optionally assert your method is within some factor of Array.BinarySearch
+            Assert.IsTrue(swCustom.ElapsedMilliseconds < swArray.ElapsedMilliseconds * 2,
+                $"Custom BinarySearch is too slow: {swCustom.ElapsedMilliseconds} ms vs {swArray.ElapsedMilliseconds} ms");
+        }
+
     }
 }

CommonLibraryGuiTests/Image/example Polaris.png

@@ -22,8 +22,14 @@ namespace ExtendedSystemObjects
     /// </summary>
     public sealed unsafe class IntArray : IUnmanagedArray<int>
     {
+        /// <summary>
+        /// The buffer
+        /// </summary>
         private IntPtr _buffer;
 
+        /// <summary>
+        /// The pointer
+        /// </summary>
         private int* _ptr;
 
         /// <summary>
@@ -286,6 +292,9 @@ public void EnsureCapacity(int minCapacity)
             Resize(newCapacity);
         }
 
+        /// <summary>
+        /// Finalizes an instance of the <see cref="IntArray"/> class.
+        /// </summary>
         ~IntArray()
         {
             Dispose();