diff --git a/Sources/Adwaita/Generated/SpinRow.swift b/Sources/Adwaita/Generated/SpinRow.swift index 4ec8eca..c695dd6 100644 --- a/Sources/Adwaita/Generated/SpinRow.swift +++ b/Sources/Adwaita/Generated/SpinRow.swift @@ -159,11 +159,3 @@ public final class SpinRow: ActionRow { SignalHelper.connect(self, signal: .wrapped, handler: handler) } } - -/// Reads the text of a `GtkEditable` (which `AdwSpinRow` is) from its instance -/// pointer. Kept at file scope so the `input` signal closure can read the -/// entry's text without capturing the `SpinRow` wrapper, which would keep the -/// wrapper alive forever. -private func spinRowEditableText(_ ptr: OpaquePointer) -> String { - String(cString: gtk_editable_get_text(ptr)) -} diff --git a/Sources/Adwaita/SpinRow+Editable.swift b/Sources/Adwaita/SpinRow+Editable.swift new file mode 100644 index 0000000..620b966 --- /dev/null +++ b/Sources/Adwaita/SpinRow+Editable.swift @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: MIT +// SPDX-FileCopyrightText: 2026 Sergey Armodin + +import CAdwaita + +/// Reads the text of a `GtkEditable` (which `AdwSpinRow` is) from its instance +/// pointer. Kept as a free function so the `input` signal closure can read the +/// entry's text without capturing the `SpinRow` wrapper, which would keep the +/// wrapper alive forever. +func spinRowEditableText(_ ptr: OpaquePointer) -> String { + String(cString: gtk_editable_get_text(ptr)) +} diff --git a/Sources/GObjectSupport/Signal.swift b/Sources/GObjectSupport/Signal.swift index 5170600..994f65c 100644 --- a/Sources/GObjectSupport/Signal.swift +++ b/Sources/GObjectSupport/Signal.swift @@ -656,7 +656,7 @@ public enum SignalHelper { trampoline: unsafeBitCast( signalTrampolineDragCancel as @convention(c) ( UnsafeMutableRawPointer, - OpaquePointer, + OpaquePointer?, UInt32, UnsafeMutableRawPointer ) -> gboolean, diff --git a/Sources/GObjectSupport/SignalTrampolines.swift b/Sources/GObjectSupport/SignalTrampolines.swift index 57dbf0a..a3f92e9 100644 --- a/Sources/GObjectSupport/SignalTrampolines.swift +++ b/Sources/GObjectSupport/SignalTrampolines.swift @@ -416,7 +416,7 @@ func signalTrampolineInput( /// animation runs; the Swift handler is invoked purely as an observer. func signalTrampolineDragCancel( _ instance: UnsafeMutableRawPointer, - _ drag: OpaquePointer, + _ drag: OpaquePointer?, _ reason: UInt32, _ userData: UnsafeMutableRawPointer ) -> gboolean { diff --git a/Tests/AdwaitaTests/MediaProtocolTests.swift b/Tests/AdwaitaTests/MediaProtocolTests.swift index d9d21c7..66d5787 100644 --- a/Tests/AdwaitaTests/MediaProtocolTests.swift +++ b/Tests/AdwaitaTests/MediaProtocolTests.swift @@ -340,6 +340,25 @@ extension SerializedLifecycleSuites { conn.disconnect() } + @Test @MainActor func spinRowOnInputSignalDoesNotLeakRow() { + ensureAdwInit() + // Regression test for the `self` capture: when the `input` + // trampoline closure captured the `SpinRow` wrapper, the C object + // kept the closure box, the box kept the wrapper, and the wrapper + // kept the C object — a cycle the row could never break, so it + // never finalized. The handler must capture nothing, and the row + // must go away once the wrapper leaves scope. + var weakSlot: WeakPointerSlot? + do { + let row = SpinRow(title: "Volume", min: 0, max: 100, step: 1) + row.value = 1 + weakSlot = WeakPointerSlot(watching: row.gobjectPointer) + row.onInput { _ in .value(1) } + } + spinMainLoop() + #expect(weakSlot?.isCleared == true, "the SpinRow must finalize once the wrapper goes out of scope") + } + @Test @MainActor func expanderRowConvenienceInit() { ensureAdwInit() let row = ExpanderRow(title: "Advanced") diff --git a/Tests/AdwaitaTests/NavigationAndTabTests.swift b/Tests/AdwaitaTests/NavigationAndTabTests.swift index fc7c941..8cf71c2 100644 --- a/Tests/AdwaitaTests/NavigationAndTabTests.swift +++ b/Tests/AdwaitaTests/NavigationAndTabTests.swift @@ -216,6 +216,22 @@ struct NavigationAndTabTests { conn.disconnect() } + @Test @MainActor func tabViewOnClosePageReturnFalseClosesPage() { + ensureAdwInit() + let tabView = TabView() + let page = tabView.append(Label("x")) + var fired = false + let conn = tabView.onClosePage { p in + fired = true + _ = p + return false + } + tabView.closePage(page) + #expect(fired, "onClosePage handler should fire") + #expect(tabView.nPages == 0, "returning false must fall through to the default close") + conn.disconnect() + } + @Test @MainActor func tabViewOnCreateWindowSignal() { ensureAdwInit() let tabView = TabView() @@ -266,7 +282,7 @@ struct NavigationAndTabTests { ensureAdwInit() let navView = NavigationView() var created = false - var weakSlot: UnsafeMutableRawPointer? + var weakSlot: WeakPointerSlot? // The handler keeps NO reference to the page it creates. This is the // case that would use-after-free if the return-object trampoline failed // to add its `g_object_ref` before the caller's temporary `NavigationPage` @@ -276,19 +292,20 @@ struct NavigationAndTabTests { navView.onGetNextPage { created = true let p = NavigationPage(child: Label("next"), title: "next") - weakSlot = p.pointer - g_object_add_weak_pointer(p.gobjectPointer, &weakSlot) + weakSlot = WeakPointerSlot(watching: p.gobjectPointer) return p } let raw = cadw_signal_emit_get_next_page(navView.gobjectPointer) #expect(created, "onGetNextPage handler should fire") #expect(raw != nil, "the signal must hand back a live reference to the page") - #expect(weakSlot != nil, "the page must still be alive once handed to the caller (transfer-full ref)") + #expect(weakSlot != nil, "the handler must have registered the weak pointer") + let stillAlive = weakSlot?.isCleared == false + #expect(stillAlive, "the page must still be alive once handed to the caller (transfer-full ref)") if let raw { g_object_unref(raw.assumingMemoryBound(to: GObject.self)) } spinMainLoop() - #expect(weakSlot == nil, "the page must finalize exactly once after the caller releases it") + #expect(weakSlot?.isCleared == true, "the page must finalize exactly once after the caller releases it") } @Test @MainActor func tabViewTransferPage() { @@ -333,16 +350,15 @@ struct NavigationAndTabTests { // With the refcount balanced the page finalizes exactly once (weak // pointer reset to NULL); an over-release crashes and a leak keeps the // weak pointer set. - var weakSlot: UnsafeMutableRawPointer? + var weakSlot: WeakPointerSlot? if let page = tabView.selectedPage { - // Seed the weak slot with the live pointer and watch it: on a - // balanced refcount the page finalizes exactly once (when `page` - // and the tab view both release it on close) and the slot is reset - // to NULL; an over-release crashes earlier, a leak leaves it set. - // The check lives below the `if` so `page`'s own reference is - // dropped first — otherwise the page cannot reach refcount zero. - weakSlot = page.pointer - g_object_add_weak_pointer(page.gobjectPointer, &weakSlot) + // Watch the underlying C object from a heap slot: on a balanced + // refcount the page finalizes exactly once (when `page` and the + // tab view both release it on close) and the slot is cleared; an + // over-release crashes earlier, a leak leaves it set. The check + // lives below the `if` so `page`'s own reference is dropped + // first — otherwise the page cannot reach refcount zero. + weakSlot = WeakPointerSlot(watching: page.gobjectPointer) tabView.onClosePage { p in tabView.closePageFinish(p, confirm: true) return true @@ -350,7 +366,7 @@ struct NavigationAndTabTests { tabView.closePage(page) } spinMainLoop() - #expect(weakSlot == nil, "Closed page must finalize exactly once (balanced refcount)") + #expect(weakSlot?.isCleared == true, "Closed page must finalize exactly once (balanced refcount)") } // MARK: - TabBar Tests diff --git a/Tests/AdwaitaTests/TestHelpers.swift b/Tests/AdwaitaTests/TestHelpers.swift index 7e060a1..0468245 100644 --- a/Tests/AdwaitaTests/TestHelpers.swift +++ b/Tests/AdwaitaTests/TestHelpers.swift @@ -69,6 +69,37 @@ func withMainLoopDrain(iterations: Int = 20, _ body: () throws -> T) rethrows return result } +/// A stable heap slot for `g_object_add_weak_pointer`. +/// +/// `&local` addresses are only valid for the duration of the C call, but GLib +/// stores the slot for as long as the watched object can still finalize, so it +/// must live on the heap instead. When this instance goes out of scope the +/// weak pointer is removed if the watched object is still alive (so it can +/// never write into the deallocated slot), and the slot is deallocated. +final class WeakPointerSlot { + private let slot: UnsafeMutablePointer + private let object: UnsafeMutablePointer + + init(watching object: UnsafeMutablePointer) { + self.object = object + slot = .allocate(capacity: 1) + slot.initialize(to: UnsafeMutableRawPointer(object)) + g_object_add_weak_pointer(object, slot) + } + + /// Whether GLib cleared the slot, i.e. the watched object finalized. + var isCleared: Bool { + slot.pointee == nil + } + + deinit { + if !isCleared { + g_object_remove_weak_pointer(object, slot) + } + slot.deallocate() + } +} + actor BoolRecorder { private var value = false diff --git a/Tests/AdwaitaTests/macOS/ExpandedWidgetXCTests.swift b/Tests/AdwaitaTests/macOS/ExpandedWidgetXCTests.swift index d90e1f1..b768a1d 100644 --- a/Tests/AdwaitaTests/macOS/ExpandedWidgetXCTests.swift +++ b/Tests/AdwaitaTests/macOS/ExpandedWidgetXCTests.swift @@ -113,7 +113,7 @@ final class ExpandedWidgetXCTests: XCTestCase { XCTAssertNotNil(overview.child) } - @MainActor func test_tabOverviewCreateTabSignal() { + @MainActor func test_tabOverviewCreateTabSignalConnect() { ensureAdwInit() let overview = TabOverview() let tabView = TabView() diff --git a/Tests/AdwaitaTests/macOS/InputDialogXCTests.swift b/Tests/AdwaitaTests/macOS/InputDialogXCTests.swift index 43b2509..e46a0da 100644 --- a/Tests/AdwaitaTests/macOS/InputDialogXCTests.swift +++ b/Tests/AdwaitaTests/macOS/InputDialogXCTests.swift @@ -59,6 +59,21 @@ final class InputDialogXCTests: XCTestCase { XCTAssertTrue(source.isDragging == false) } + @MainActor func test_dragSourceOnDragCancelledSignal() { + ensureAdwInit() + let source = DragSource() + var fired = false + let conn = source.onDragCancelled { + fired = true + } + XCTAssertFalse(fired, "onDragCancelled should not fire before a drag is cancelled") + // Real `GtkDragSource::drag-cancel` is `(GdkDrag*, GdkDragCancelReason) -> + // gboolean` (see Gtk-4.0.gir); the emit shim and the C trampoline match it. + _ = cadw_signal_emit_drag_cancel(source.pointer, nil, 0) + XCTAssertTrue(fired, "onDragCancelled must fire when the drag-cancel signal is emitted") + conn.disconnect() + } + // MARK: - DropTarget @MainActor func test_dropTargetCreation() { diff --git a/Tests/AdwaitaTests/macOS/MediaProtocolXCTests.swift b/Tests/AdwaitaTests/macOS/MediaProtocolXCTests.swift index ff759ee..6deb083 100644 --- a/Tests/AdwaitaTests/macOS/MediaProtocolXCTests.swift +++ b/Tests/AdwaitaTests/macOS/MediaProtocolXCTests.swift @@ -269,6 +269,68 @@ final class MediaProtocolXCTests: XCTestCase { XCTAssertTrue(row.title == "Volume") } + @MainActor func test_spinRowOnOutputSignalReturnsBool() { + ensureAdwInit() + let row = SpinRow(title: "Volume", min: 0, max: 100, step: 1) + row.value = 42 + var called = false + let conn = row.onOutput { + called = true + return true + } + let ret = cadw_signal_emit_bool_return(row.pointer, "output") + XCTAssertTrue(called, "onOutput handler should fire") + XCTAssertTrue(ret != 0, "the handler's TRUE must become the signal's return value") + conn.disconnect() + } + + @MainActor func test_spinRowOnInputSignalWritesValue() { + ensureAdwInit() + let row = SpinRow(title: "Volume", min: 0, max: 100, step: 1) + row.value = 1 + var called = false + let conn = row.onInput { text in + called = true + _ = text + return .value(7) + } + var outValue: Double = -1 + let ret = cadw_signal_emit_spin_row_input(row.pointer, &outValue) + XCTAssertTrue(called, "onInput handler should fire") + XCTAssertEqual(ret, 1, "a .value result must return TRUE (1)") + XCTAssertEqual(outValue, 7.0, "the handler must write the value through the out-pointer") + conn.disconnect() + } + + @MainActor func test_spinRowOnInputReceivesEditableText() { + ensureAdwInit() + let row = SpinRow(title: "Volume", min: 0, max: 100, step: 1) + row.value = 42 + var received: String? + let conn = row.onInput { text in + received = text + return .value(Double(text) ?? 0) + } + var outValue: Double = -1 + _ = cadw_signal_emit_spin_row_input(row.pointer, &outValue) + let editableText = String(cString: gtk_editable_get_text(row.opaquePointer)) + XCTAssertNotNil(received, "onInput handler should fire") + XCTAssertEqual(received, editableText, "onInput must receive the row's current editable text") + XCTAssertEqual(outValue, 42.0, "the handler must parse the text back to the row's value") + conn.disconnect() + } + + @MainActor func test_spinRowOnInputSignalInvalid() { + ensureAdwInit() + let row = SpinRow(title: "Volume", min: 0, max: 100, step: 1) + let conn = row.onInput { _ in .invalid } + var outValue: Double = -1 + let ret = cadw_signal_emit_spin_row_input(row.pointer, &outValue) + XCTAssertEqual(ret, -1, "an .invalid result must return GTK_INPUT_ERROR (-1)") + _ = outValue + conn.disconnect() + } + @MainActor func test_expanderRowConvenienceInit() { ensureAdwInit() let row = ExpanderRow(title: "Advanced") diff --git a/Tests/AdwaitaTests/macOS/NavigationAndTabXCTests.swift b/Tests/AdwaitaTests/macOS/NavigationAndTabXCTests.swift index 8beedbb..f7ad34a 100644 --- a/Tests/AdwaitaTests/macOS/NavigationAndTabXCTests.swift +++ b/Tests/AdwaitaTests/macOS/NavigationAndTabXCTests.swift @@ -166,6 +166,116 @@ final class NavigationAndTabXCTests: XCTestCase { conn.disconnect() } + @MainActor func test_tabViewOnClosePageSignalEmitted() { + ensureAdwInit() + let tabView = TabView() + let page = tabView.append(Label("x")) + var fired = false + let conn = tabView.onClosePage { p in + fired = true + _ = p + return true + } + let ret = cadw_signal_emit_close_page(tabView.pointer, page.pointer) + XCTAssertTrue(fired, "onClosePage handler should fire") + XCTAssertTrue(ret != 0, "the handler's return value must reach the signal's return") + conn.disconnect() + } + + @MainActor func test_tabViewOnClosePageCancelKeepsPage() { + ensureAdwInit() + let tabView = TabView() + let page = tabView.append(Label("x")) + var fired = false + let conn = tabView.onClosePage { p in + fired = true + tabView.closePageFinish(p, confirm: false) + return true + } + tabView.closePage(page) + XCTAssertTrue(fired, "onClosePage handler should fire") + XCTAssertTrue(tabView.nPages == 1, "cancelling the close must keep the page") + conn.disconnect() + } + + @MainActor func test_tabViewOnClosePageConfirmClosesPage() { + ensureAdwInit() + let tabView = TabView() + let page = tabView.append(Label("x")) + var fired = false + let conn = tabView.onClosePage { p in + fired = true + tabView.closePageFinish(p, confirm: true) + return true + } + tabView.closePage(page) + XCTAssertTrue(fired, "onClosePage handler should fire") + XCTAssertTrue(tabView.nPages == 0, "confirming the close must remove the page") + conn.disconnect() + } + + @MainActor func test_tabViewOnClosePageReturnFalseClosesPage() { + ensureAdwInit() + let tabView = TabView() + let page = tabView.append(Label("x")) + var fired = false + let conn = tabView.onClosePage { p in + fired = true + _ = p + return false + } + tabView.closePage(page) + XCTAssertTrue(fired, "onClosePage handler should fire") + XCTAssertTrue(tabView.nPages == 0, "returning false must fall through to the default close") + conn.disconnect() + } + + @MainActor func test_tabViewOnCreateWindowSignal() { + ensureAdwInit() + let tabView = TabView() + var fired = false + let conn = tabView.onCreateWindow { + fired = true + return nil + } + cadw_signal_emit_no_args(tabView.pointer, "create-window") + XCTAssertTrue(fired, "onCreateWindow handler should fire (nil result)") + conn.disconnect() + } + + @MainActor func test_tabViewOnCreateWindowSignalReturnsView() { + ensureAdwInit() + let tabView = TabView() + let dest = TabView() + var fired = false + let conn = tabView.onCreateWindow { + fired = true + return dest + } + let raw = cadw_signal_emit_create_window(tabView.gobjectPointer) + XCTAssertTrue(fired, "onCreateWindow handler should fire and return the destination view") + XCTAssertNotNil(raw, "the signal must hand back the destination view") + XCTAssertTrue(raw == dest.pointer, "the returned pointer must reach the caller (transfer-none borrow)") + conn.disconnect() + } + + @MainActor func test_navigationViewOnGetNextPageSignal() { + ensureAdwInit() + let navView = NavigationView() + var fired = false + let conn = navView.onGetNextPage { + fired = true + return NavigationPage(child: Label("next"), title: "next") + } + let raw = cadw_signal_emit_get_next_page(navView.gobjectPointer) + XCTAssertTrue(fired, "onGetNextPage handler should fire") + XCTAssertNotNil(raw, "the signal must hand back the created page") + if let raw { + g_object_unref(raw.assumingMemoryBound(to: GObject.self)) + } + conn.disconnect() + } + @MainActor func test_tabViewTransferPage() { ensureAdwInit() let tabView1 = TabView()