Add more BrowserWindowTests (window state)

Author: softworkz

src/ElectronNET.IntegrationTests/Tests/BrowserWindowTests.cs

@@ -238,5 +238,144 @@ public async Task Represented_filename_and_edited_flags()
 
             win.SetDocumentEdited(false);
         }
+
+        // --- Added window state tests ---
+
+        [Fact(Timeout = 20000)]
+        public async Task Fullscreen_toggle_and_query()
+        {
+            var win = this.fx.MainWindow;
+            win.Show();
+            await Task.Delay(300);
+            (await win.IsVisibleAsync()).Should().BeTrue();
+
+            // Ensure window is fullscreenable
+            win.SetFullScreenable(true);
+            await Task.Delay(200);
+
+            // Poll for fullscreen state instead of fixed waits (Electron can be slow)
+            win.SetFullScreen(true);
+            var entered = await WaitUntil(async () => await win.IsFullScreenAsync(), 3000);
+            entered.Should().BeTrue("Window should enter fullscreen within timeout");
+
+            win.SetFullScreen(false);
+            var left = await WaitUntil(async () => !(await win.IsFullScreenAsync()), 3000);
+            left.Should().BeTrue("Window should exit fullscreen within timeout");
+        }
+
+        [Fact(Timeout = 20000)]
+        public async Task Maximize_unmaximize_roundtrip()
+        {
+            var win = this.fx.MainWindow;
+            win.Unmaximize(); // ensure not maximized
+            await Task.Delay(500);
+            (await win.IsMaximizedAsync()).Should().BeFalse();
+            win.Maximize();
+            await Task.Delay(800);
+            (await win.IsMaximizedAsync()).Should().BeTrue();
+            win.Unmaximize();
+            await Task.Delay(1500);
+            (await win.IsMaximizedAsync()).Should().BeFalse();
+        }
+
+        [Fact(Timeout = 20000)]
+        public async Task Minimize_restore_roundtrip()
+        {
+            var win = this.fx.MainWindow;
+            win.Restore(); // ensure not minimized
+            await Task.Delay(500);
+            (await win.IsMinimizedAsync()).Should().BeFalse();
+            win.Minimize();
+            await Task.Delay(1500);
+            (await win.IsMinimizedAsync()).Should().BeTrue();
+            win.Restore();
+            await Task.Delay(1500);
+            (await win.IsMinimizedAsync()).Should().BeFalse();
+        }
+
+        [Fact(Timeout = 20000)]
+        public async Task Fullscreen_events_fire_on_toggle()
+        {
+            var window = await Electron.WindowManager.CreateWindowAsync(new BrowserWindowOptions { Show = true, Fullscreenable = true }, "about:blank");
+            try
+            {
+                bool entered = false, left = false;
+                window.OnEnterFullScreen += () => entered = true;
+                window.OnLeaveFullScreen += () => left = true;
+                await Task.Delay(400);
+
+                window.SetFullScreen(true);
+                await WaitUntil(() => Task.FromResult(entered), 4000);
+                entered.Should().BeTrue();
+
+                window.SetFullScreen(false);
+                await WaitUntil(() => Task.FromResult(left), 4000);
+                left.Should().BeTrue();
+            }
+            finally
+            {
+                window.Destroy();
+            }
+        }
+
+        [Fact(Timeout = 20000)]
+        public async Task Maximize_and_unmaximize_events_fire()
+        {
+            var window = await Electron.WindowManager.CreateWindowAsync(new BrowserWindowOptions { Show = true }, "about:blank");
+            try
+            {
+                bool maximized = false, unmaximized = false;
+                window.OnMaximize += () => maximized = true;
+                window.OnUnmaximize += () => unmaximized = true;
+                await Task.Delay(500);
+                window.Maximize();
+                await Task.Delay(1500);
+                maximized.Should().BeTrue();
+                window.Unmaximize();
+                await Task.Delay(1500);
+                unmaximized.Should().BeTrue();
+            }
+            finally
+            {
+                window.Destroy();
+            }
+        }
+
+        [Fact(Timeout = 20000)]
+        public async Task Minimize_and_restore_events_fire()
+        {
+            var window = await Electron.WindowManager.CreateWindowAsync(new BrowserWindowOptions { Show = true }, "about:blank");
+            try
+            {
+                bool minimized = false, restored = false;
+                window.OnMinimize += () => minimized = true;
+                window.OnRestore += () => restored = true;
+                await Task.Delay(500);
+                window.Minimize();
+                await Task.Delay(1500); // minimize may take longer
+                minimized.Should().BeTrue();
+                window.Restore();
+                await Task.Delay(1500);
+                restored.Should().BeTrue();
+            }
+            finally
+            {
+                window.Destroy();
+            }
+        }
+
+        private static async Task<bool> WaitUntil(Func<Task<bool>> predicate, int timeoutMs, int pollIntervalMs = 100)
+        {
+            var start = DateTime.UtcNow;
+            while ((DateTime.UtcNow - start).TotalMilliseconds < timeoutMs)
+            {
+                if (await predicate().ConfigureAwait(false))
+                {
+                    return true;
+                }
+                await Task.Delay(pollIntervalMs).ConfigureAwait(false);
+            }
+            return await predicate().ConfigureAwait(false);
+        }
     }
 }