Some smaller fixes

LoneWandererProductions · LoneWandererProductions · commit 90fe6f68c0ca · 2026-03-02T14:35:32.000+01:00
diff --git a/CommonExtendedObjectsTests/IntListTests.cs b/CommonExtendedObjectsTests/IntListTests.cs
@@ -314,8 +314,8 @@ public void BenchmarkAddPerformance()
 
             swUnmanaged.Stop();
 
-            Console.WriteLine($"List<int>.Add: {swList.ElapsedMilliseconds} ms");
-            Console.WriteLine($"UnmanagedIntList.Add: {swUnmanaged.ElapsedMilliseconds} ms");
+            Trace.WriteLine($"List<int>.Add: {swList.ElapsedMilliseconds} ms");
+            Trace.WriteLine($"UnmanagedIntList.Add: {swUnmanaged.ElapsedMilliseconds} ms");
 
             unmanaged.Dispose();
 
@@ -324,7 +324,6 @@ public void BenchmarkAddPerformance()
                 "UnmanagedIntList.Add is too slow.");
         }
 
-
         /// <summary>
         ///     Benchmarks the remove performance.
         /// </summary>
@@ -334,6 +333,7 @@ public void BenchmarkRemovePerformance()
             var list = new List<int>();
             var unmanaged = new UnmanagedIntList();
 
+            // Setup Phase
             for (var i = 0; i < ItemCount; i++)
             {
                 list.Add(i);
@@ -343,30 +343,40 @@ public void BenchmarkRemovePerformance()
             const int removeCount = 1000;
             var removeIndex = list.Count / 2; // fixed middle index
 
+            // WARMUP: Force JIT to compile the methods and Stopwatch before measuring
+            list.RemoveAt(list.Count - 1);
+            unmanaged.RemoveAt(unmanaged.Length - 1);
+
+            // CLEAN SLATE: Force GC to clean up the arrays abandoned during the 'Add' phase
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
+            // 1. Measure List<int>
             var swList = Stopwatch.StartNew();
             for (var i = 0; i < removeCount; i++)
             {
                 list.RemoveAt(removeIndex);
             }
-
             swList.Stop();
 
+            // CLEAN SLATE AGAIN
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
+            // 2. Measure UnmanagedIntList
             var swUnmanaged = Stopwatch.StartNew();
             for (var i = 0; i < removeCount; i++)
             {
                 unmanaged.RemoveAt(removeIndex);
             }
-
             swUnmanaged.Stop();
 
-            Console.WriteLine($"List<int>.RemoveAt: {swList.ElapsedMilliseconds} ms");
-            Console.WriteLine($"UnmanagedIntList.RemoveAt: {swUnmanaged.ElapsedMilliseconds} ms");
-
-            unmanaged.Dispose();
+            // Use TotalMilliseconds for high-precision decimal values!
+            Trace.WriteLine($"List<int>.RemoveAt: {swList.Elapsed.TotalMilliseconds:F4} ms");
+            Trace.WriteLine($"UnmanagedIntList.RemoveAt: {swUnmanaged.Elapsed.TotalMilliseconds:F4} ms");
 
-            //TODO fix this!
 #if DEBUG
-            //Assert.AreEqual(list.Count, unmanaged.Length);
+            Assert.AreEqual(list.Count, unmanaged.Length, "The lists should have the exact same number of elements.");
 #endif
         }
 
diff --git a/CommonLibraryGuiTests/BitmapComparisonTests.cs b/CommonLibraryGuiTests/BitmapComparisonTests.cs
@@ -12,6 +12,7 @@
 using System.Drawing.Imaging;
 using System.IO;
 using System.Threading;
+using System.Windows;
 using System.Windows.Media.Imaging;
 using Imaging;
 using NUnit.Framework;
@@ -128,57 +129,105 @@ private static double MeasureNativeBitmapRendering()
         [Apartment(ApartmentState.STA)]
         public void CompareRenderingSpeedsForMultipleUpdates()
         {
-            // Number of updates to simulate a slideshow
             const int updateCount = 100;
+            const double toleranceMultiplier = 1.10; // Allow Native to be up to 10% slower due to random noise
 
-            // Measure time for Media.Image with conversion
+            // 1. WARMUP: Run once to force JIT compilation and assembly loading
+            MeasureMediaImageRendering(1);
+            MeasureNativeBitmapRendering(1);
+
+            // 2. FORCE GC: Ensure a clean slate before measuring
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
+            // Measure time for Media.Image
             var mediaImageTime = MeasureMediaImageRendering(updateCount);
 
+            // FORCE GC again
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
             // Measure time for NativeBitmapDisplay
             var nativeDisplayTime = MeasureNativeBitmapRendering(updateCount);
 
-            TestContext.WriteLine($"Media.Image Time for {updateCount} updates: {mediaImageTime}ms");
-            TestContext.WriteLine($"NativeBitmapDisplay Time for {updateCount} updates: {nativeDisplayTime}ms");
+            TestContext.WriteLine($"Media.Image Time: {mediaImageTime}ms");
+            TestContext.WriteLine($"NativeBitmapDisplay Time: {nativeDisplayTime}ms");
 
-            Assert.IsTrue(nativeDisplayTime <= mediaImageTime,
-                "NativeBitmapDisplay should be as fast or faster than Media.Image rendering.");
+            // 3. TOLERANCE: Don't assert strict <=, allow a reasonable buffer
+            Assert.IsTrue(nativeDisplayTime <= (mediaImageTime * toleranceMultiplier),
+                $"NativeBitmapDisplay ({nativeDisplayTime}ms) should be roughly as fast or faster than Media.Image ({mediaImageTime}ms).");
         }
 
         /// <summary>
-        ///     Measures the media image rendering.
+        /// Measures the native bitmap rendering.
         /// </summary>
         /// <param name="updateCount">The update count.</param>
-        /// <returns>elapsed Time</returns>
-        private long MeasureMediaImageRendering(int updateCount)
+        /// <returns></returns>
+        public long MeasureNativeBitmapRendering(int updateCount)
         {
-            var stopwatch = Stopwatch.StartNew();
+            // 1. Initialize the UI Control
+            var display = new NativeBitmapDisplay();
 
-            for (var i = 0; i < updateCount; i++)
+            // 2. Initialize your Shared Memory (DirectBitmap)
+            // Let's assume a 800x600 canvas
+            using var directBitmap = new DirectBitmap(800, 600, Color.Black);
+
+            // 3. THE HANDSHAKE (Do this ONLY ONCE)
+            // This passes the shared memory canvas to the WinForms picture box.
+            display.Bitmap = directBitmap.UnsafeBitmap;
+
+            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+
+            // 4. THE RENDER LOOP
+            for (int i = 0; i < updateCount; i++)
             {
-                // Convert Bitmap to BitmapSource
-                var bitmapSource = BitmapToBitmapSource(_testBitmap);
+                // A. Mutate the pixels directly in RAM (Zero allocations!)
+                // In a real app, this might be copying a video frame array.
+                // Here, we just draw a line to simulate work.
+                directBitmap.DrawHorizontalLine(0, i % 600, 800, Color.Red);
 
-                // Simulate rendering in Media.Image
-                _ = new System.Windows.Controls.Image { Source = bitmapSource };
+                // B. Tell the UI to repaint what is in memory
+                display.InvalidateCanvas();
+
+                // (Optional: In a UI test, you sometimes need to pump the WPF Dispatcher 
+                // here to force it to actually draw to the screen immediately, otherwise 
+                // it just queues up 100 invalidate requests and draws once at the end).
+                DoEvents(display);
             }
 
             stopwatch.Stop();
             return stopwatch.ElapsedMilliseconds;
         }
 
         /// <summary>
-        ///     Measures the native bitmap rendering.
+        /// Helper method to force WPF to actually render during a synchronous test loop
+        /// </summary>
+        /// <param name="control">The control.</param>
+        private static void DoEvents(DependencyObject control)
+        {
+            var frame = new System.Windows.Threading.DispatcherFrame();
+            control.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Render, new Action(delegate {
+                frame.Continue = false;
+            }));
+            System.Windows.Threading.Dispatcher.PushFrame(frame);
+        }
+
+        /// <summary>
+        ///     Measures the media image rendering.
         /// </summary>
         /// <param name="updateCount">The update count.</param>
         /// <returns>elapsed Time</returns>
-        private long MeasureNativeBitmapRendering(int updateCount)
+        private long MeasureMediaImageRendering(int updateCount)
         {
             var stopwatch = Stopwatch.StartNew();
 
             for (var i = 0; i < updateCount; i++)
             {
-                // Simulate rendering in NativeBitmapDisplay
-                _ = new NativeBitmapDisplay { Bitmap = _testBitmap };
+                // Convert Bitmap to BitmapSource
+                var bitmapSource = BitmapToBitmapSource(_testBitmap);
+
+                // Simulate rendering in Media.Image
+                _ = new System.Windows.Controls.Image { Source = bitmapSource };
             }
 
             stopwatch.Stop();
@@ -189,7 +238,7 @@ private long MeasureNativeBitmapRendering(int updateCount)
         ///     Bitmaps to bitmap source.
         /// </summary>
         /// <param name="bitmap">The bitmap.</param>
-        /// <returns></returns>
+        /// <returns>BitmapSource</returns>
         private static BitmapSource BitmapToBitmapSource(Image bitmap)
         {
             using var memoryStream = new MemoryStream();
diff --git a/CommonLibraryTests/FileObserverTests.cs b/CommonLibraryTests/FileObserverTests.cs
@@ -0,0 +1,156 @@
+﻿/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     CommonLibraryTests
+ * FILE:        FileObserverTests.cs
+ * PURPOSE:     Some tests for FileObserver. Not exhaustive, but a good start to validate the core functionality and catch regressions.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using FileHandler;
+
+namespace CommonLibraryTests
+{
+    [TestClass]
+    public class FileObserverTests
+    {
+        /// <summary>
+        /// The temporary directory
+        /// </summary>
+        private string _tempDirectory = string.Empty;
+
+        /// <summary>
+        /// Setups this instance.
+        /// </summary>
+        [TestInitialize]
+        public void Setup()
+        {
+            // Runs before EVERY test to create a pristine, isolated folder
+            _tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        /// <summary>
+        /// Cleanups this instance.
+        /// </summary>
+        [TestCleanup]
+        public void Cleanup()
+        {
+            // Runs after EVERY test to wipe the folder and leave no trace
+            if (Directory.Exists(_tempDirectory))
+            {
+                Directory.Delete(_tempDirectory, true);
+            }
+        }
+
+        /// <summary>
+        /// Constructors the when directory does not exist throws directory not found exception.
+        /// </summary>
+        [TestMethod]
+        public void Constructor_WhenDirectoryDoesNotExist_ThrowsDirectoryNotFoundException()
+        {
+            // Arrange
+            var badPath = Path.Combine(_tempDirectory, "NonExistentFolder");
+
+            // Act & Assert
+            Assert.ThrowsException<DirectoryNotFoundException>(() => new FileObserver(badPath));
+        }
+
+        /// <summary>
+        /// Creates the event when file is created fires successfully.
+        /// </summary>
+        [TestMethod]
+        public async Task CreatedEvent_WhenFileIsCreated_FiresSuccessfully()
+        {
+            // Arrange
+            using var observer = new FileObserver(_tempDirectory);
+            var eventFired = false;
+
+            observer.Created += args =>
+            {
+                eventFired = true;
+                return Task.CompletedTask;
+            };
+
+            // Act
+            observer.Start();
+
+            // Create a file to trigger the OS event
+            var testFile = Path.Combine(_tempDirectory, "test.txt");
+            await File.WriteAllTextAsync(testFile, "Hello World");
+
+            // Give the OS and the observer a moment to process the event
+            await Task.Delay(100);
+
+            // Assert
+            Assert.IsTrue(eventFired, "The Created event did not fire.");
+        }
+
+        /// <summary>
+        /// Changes the event when spammed debounces and fires only once.
+        /// </summary>
+        [TestMethod]
+        public async Task ChangedEvent_WhenSpammed_DebouncesAndFiresOnlyOnce()
+        {
+            // Arrange
+            using var observer = new FileObserver(_tempDirectory);
+            var testFile = Path.Combine(_tempDirectory, "spam.txt");
+
+            // Create the initial file before we start watching so it doesn't trigger 'Created'
+            await File.WriteAllTextAsync(testFile, "Initial Setup");
+
+            var eventCount = 0;
+            observer.Changed += args =>
+            {
+                Interlocked.Increment(ref eventCount); // Thread-safe counter
+                return Task.CompletedTask;
+            };
+
+            observer.Start();
+
+            // Act: Spam the file with 5 rapid saves
+            for (var i = 0; i < 5; i++)
+            {
+                using var fs = new FileStream(testFile, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
+                using var writer = new StreamWriter(fs);
+                await writer.WriteAsync($"Spam {i}");
+            }
+
+            // Wait just slightly longer than your 200ms debounce limit
+            await Task.Delay(300);
+
+            // Assert
+            // Without your debounce logic, this would be 5 (or more, due to OS quirks).
+            // With your logic, it should be exactly 1.
+            Assert.AreEqual(1, eventCount);
+        }
+
+        /// <summary>
+        /// Runs the until cancelled asynchronous when token is cancelled exits gracefully.
+        /// </summary>
+        [TestMethod]
+        public async Task RunUntilCancelledAsync_WhenTokenIsCancelled_ExitsGracefully()
+        {
+            // Arrange
+            using var observer = new FileObserver(_tempDirectory);
+            using var cts = new CancellationTokenSource();
+
+            // Act
+            var runTask = observer.RunUntilCancelledAsync(cts.Token);
+
+            // Cancel it almost immediately
+            cts.Cancel();
+
+            // Await the task. If it throws an unhandled exception, the test fails. 
+            await runTask;
+
+            // Assert
+            Assert.IsTrue(runTask.IsCompletedSuccessfully);
+        }
+    }
+}
diff --git a/Imaging/NativeBitmapDisplay.cs b/Imaging/NativeBitmapDisplay.cs
