add some leak tests.

Author: Wayfarer

ImagingTests/ImagingLeakTests.cs

@@ -0,0 +1,44 @@
+using System.Drawing;
+using Imaging;
+
+namespace ImagingTests
+{
+    [TestClass]
+    public class ImagingLeakTests
+    {
+        [TestMethod]
+        public void TestPixelateForMemoryLeaks()
+        {
+            // 1. Setup a dummy bitmap
+            using var testBmp = new Bitmap(2000, 2000);
+
+            // 2. Wrap the execution in our Monitor
+            LeakDetector.Monitor(() =>
+            {
+                // Run the operation multiple times in one go to amplify any small leak
+                for (var i = 0; i < 5; i++)
+                {
+                    // We simulate the UI usage: Load -> Process -> Convert -> Dispose
+                    using (var result = ImagingFacade.Resize(testBmp, 1000, 1000))
+                    {
+                        var uiImage = ImagingFacade.ToBitmapImage(result);
+                        // uiImage is now managed by WPF, result is disposed here
+                    }
+                }
+            }, "Facade Resize and Convert Leak Test");
+        }
+
+        [TestMethod]
+        public void TestFilterLeak()
+        {
+            using var testBmp = new Bitmap(1000, 1000);
+
+            LeakDetector.Monitor(() =>
+            {
+                // Testing if ApplyFilter cleans up its internal DirectBitmap
+                var filtered = ImagingFacade.ApplyFilter(testBmp, Imaging.Enums.FiltersType.Sepia);
+                filtered?.Dispose();
+            }, "Sepia Filter Disposal Test");
+        }
+    }
+}

ImagingTests/LeakDetector.cs

@@ -0,0 +1,48 @@
+using System.Diagnostics;
+
+namespace ImagingTests
+{
+        public static class LeakDetector
+        {
+            // Switch this off in Production
+            public static bool IsEnabled { get; set; } = true;
+
+            public static void Monitor(Action action, string label, long thresholdBytes = 1024 * 1024)
+            {
+                if (!IsEnabled)
+                {
+                    action();
+                    return;
+                }
+
+                // Clean the slate
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                long startMem = Process.GetCurrentProcess().PrivateMemorySize64;
+
+                action();
+
+                // Clean up after action
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+
+                long endMem = Process.GetCurrentProcess().PrivateMemorySize64;
+                long diff = endMem - startMem;
+
+                if (diff > thresholdBytes)
+                {
+                    string msg = $"[LEAK WARNING] {label}: Memory increased by {diff / 1024.0 / 1024.0:F2} MB";
+                    Debug.WriteLine(msg);
+                    // In a Unit Test environment, you might throw an exception here:
+                    // throw new Exception(msg);
+                }
+                else
+                {
+                    Debug.WriteLine($"[OK] {label}: Memory stable (Diff: {diff} bytes).");
+                }
+            }
+        }
+}