@gtkx/testing 0.21.0 → 1.0.0-rc.2

package/src/editable.ts

@@ -0,0 +1,37 @@
+import * as Gtk from "@gtkx/gi/gtk";
+
+type EditableTarget = Gtk.Editable | Gtk.TextView;
+
+const EDITABLE_ROLES: Set<Gtk.AccessibleRole> = new Set<Gtk.AccessibleRole>([
+    Gtk.AccessibleRole.TEXT_BOX,
+    Gtk.AccessibleRole.SEARCH_BOX,
+    Gtk.AccessibleRole.SPIN_BUTTON,
+]);
+
+const isEditable = (widget: unknown): widget is EditableTarget =>
+    widget instanceof Gtk.Editable || widget instanceof Gtk.TextView;
+
+const getEditableDelegate = (widget: Gtk.Widget): Gtk.Widget | null => {
+    if (!(widget instanceof Gtk.Editable)) {
+        return null;
+    }
+
+    return widget.getDelegate();
+};
+
+const readTextViewBufferText = (widget: Gtk.TextView): string => {
+    const buffer = widget.getBuffer();
+    const [start, end] = buffer.getBounds();
+
+    return buffer.getText(start, end, true);
+};
+
+const readEditableText = (widget: EditableTarget): string => {
+    if (widget instanceof Gtk.TextView) {
+        return readTextViewBufferText(widget);
+    }
+
+    return widget.getText();
+};
+
+export { EDITABLE_ROLES, isEditable, getEditableDelegate, readEditableText, type EditableTarget };

package/src/errors.ts

@@ -0,0 +1,191 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import type { Container } from "./traversal.js";
+import type { ByRoleOptions, ByRoleValue, Matcher } from "./types.js";
+import { getConfig } from "./config.js";
+import { prettyWidget } from "./pretty-widget.js";
+import { formatRole, prettyRoles } from "./role-helpers.js";
+
+type QueryDescriptor =
+    | { queryType: "role"; role: Gtk.AccessibleRole; options?: ByRoleOptions | undefined } |
+    { queryType: "text"; text: Matcher } |
+    { queryType: "labelText"; text: Matcher } |
+    { queryType: "name"; name: Matcher } |
+    { queryType: "placeholderText"; text: Matcher } |
+    { queryType: "displayValue"; value: Matcher };
+
+const roleOptionFormatters: ((options: ByRoleOptions) => string | null)[] = [
+    (o) => (o.name ? `name ${formatTextMatcher(o.name)}` : null),
+    (o) => (o.checked === undefined ? null : `checked=${String(o.checked)}`),
+    (o) => (o.pressed === undefined ? null : `pressed=${String(o.pressed)}`),
+    (o) => (o.selected === undefined ? null : `selected=${String(o.selected)}`),
+    (o) => (o.expanded === undefined ? null : `expanded=${String(o.expanded)}`),
+    (o) => (o.level === undefined ? null : `level=${String(o.level)}`),
+    (o) => (o.busy === undefined ? null : `busy=${String(o.busy)}`),
+    (o) => (o.description ? `description ${formatTextMatcher(o.description)}` : null),
+    (o) => (o.value ? `value ${formatByRoleValue(o.value)}` : null),
+    (o) => (o.hidden === undefined ? null : `hidden=${String(o.hidden)}`),
+];
+
+const expensiveErrorDiagnostics = { isDisabled: false };
+
+const formatTextMatcher = (text: Matcher): string => {
+    if (typeof text === "function") {
+        return "custom function";
+    }
+
+    if (text instanceof RegExp) {
+        return text.toString();
+    }
+
+    return `'${String(text)}'`;
+};
+
+const formatByRoleValue = (value: ByRoleValue): string => {
+    const parts: string[] = [];
+
+    if (value.now !== undefined) {
+        parts.push(`now=${String(value.now)}`);
+    }
+
+    if (value.min !== undefined) {
+        parts.push(`min=${String(value.min)}`);
+    }
+
+    if (value.max !== undefined) {
+        parts.push(`max=${String(value.max)}`);
+    }
+
+    if (value.text !== undefined) {
+        parts.push(`text ${formatTextMatcher(value.text)}`);
+    }
+
+    return parts.join(", ");
+};
+
+const roleOptionParts = (options: ByRoleOptions): string[] => {
+    const parts: string[] = [];
+
+    for (const formatter of roleOptionFormatters) {
+        const part = formatter(options);
+
+        if (part !== null) {
+            parts.push(part);
+        }
+    }
+
+    return parts;
+};
+
+const formatByRoleDescription = (role: Gtk.AccessibleRole, options?: ByRoleOptions): string => {
+    const parts = [`role '${formatRole(role).toUpperCase()}'`];
+
+    if (options) {
+        parts.push(...roleOptionParts(options));
+    }
+
+    return parts.join(" and ");
+};
+
+const formatQueryDescription = (descriptor: QueryDescriptor): string => {
+    switch (descriptor.queryType) {
+        case "role": {
+            return formatByRoleDescription(descriptor.role, descriptor.options);
+        }
+        case "text": {
+            return `text ${formatTextMatcher(descriptor.text)}`;
+        }
+        case "labelText": {
+            return `label text ${formatTextMatcher(descriptor.text)}`;
+        }
+        case "name": {
+            return `name ${formatTextMatcher(descriptor.name)}`;
+        }
+        case "placeholderText": {
+            return `placeholder text ${formatTextMatcher(descriptor.text)}`;
+        }
+        case "displayValue": {
+            return `display value ${formatTextMatcher(descriptor.value)}`;
+        }
+    }
+};
+
+const runWithExpensiveErrorDiagnosticsDisabled = <T>(callback: () => T): T => {
+    const isPrevious = expensiveErrorDiagnostics.isDisabled;
+    expensiveErrorDiagnostics.isDisabled = true;
+
+    try {
+        return callback();
+    } finally {
+        expensiveErrorDiagnostics.isDisabled = isPrevious;
+    }
+};
+
+const buildElementError = (container: Container, headLines: string[]): Error => {
+    const config = getConfig();
+
+    const lines = expensiveErrorDiagnostics.isDisabled
+        ? headLines
+        : [...headLines, "", prettyWidget(container, { highlight: false })];
+
+    return config.getElementError(lines.join("\n"), container);
+};
+
+const notFoundError = (container: Container, descriptor: QueryDescriptor): Error => {
+    const description = formatQueryDescription(descriptor);
+    const headLines = [`Unable to find an element with ${description}`];
+
+    if (!expensiveErrorDiagnostics.isDisabled && descriptor.queryType === "role") {
+        headLines.push("", "Here are the accessible roles:", "", prettyRoles(container));
+    }
+
+    return buildElementError(container, headLines);
+};
+
+const allByVariantHint = (descriptor: QueryDescriptor): string => {
+    const variant = descriptor.queryType === "role" ? "getAllByRole" : "getAllBy*";
+
+    return (
+        "(If this is intentional, use the *AllBy* variant of the query, " +
+        `e.g. queryAllBy*/getAllBy*/findAllBy*, such as ${variant}.)`
+    );
+};
+
+const multipleFoundError = (container: Container, descriptor: QueryDescriptor, matches: Gtk.Widget[]): Error => {
+    const description = formatQueryDescription(descriptor);
+
+    const headLines = [
+        `Found ${String(matches.length)} elements with ${description}, but expected only one`,
+        "",
+        allByVariantHint(descriptor),
+    ];
+
+    if (!expensiveErrorDiagnostics.isDisabled) {
+        const renderedMatches = matches.map((widget) => prettyWidget(widget, { highlight: false }));
+        headLines.push("", "Here are the matching elements:", "", ...renderedMatches);
+    }
+
+    return buildElementError(container, headLines);
+};
+
+const suggestionError = (suggestion: string, container: Container): Error => {
+    const config = getConfig();
+    const message = `A better query is available, try this:\n${suggestion}\n`;
+
+    return config.getElementError(message, container);
+};
+
+const timeoutError = (timeout: number, lastError: Error | null): Error => {
+    const baseMessage = `Timed out after ${String(timeout)}ms`;
+    const message = lastError ? `${baseMessage}.\n\n${lastError.message}` : baseMessage;
+
+    return getConfig().getElementError(message);
+};
+
+export {
+    runWithExpensiveErrorDiagnosticsDisabled,
+    notFoundError,
+    multipleFoundError,
+    suggestionError,
+    timeoutError,
+    type QueryDescriptor,
+};

package/src/fire-event.ts

@@ -1,43 +1,18 @@
-import { type Object as GObject, signalEmitv, signalLookup, typeFromName, Value } from "@gtkx/ffi/gobject";
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { tick } from "./timing.js";
+import type * as GObject from "@gtkx/gi/gobject";
+import { runInAct } from "./act.js";
 
 /**
- * Emits a GTK signal on a widget or event controller.
+ * Emits a GObject signal on a widget or object inside React's act environment,
+ * so any resulting state updates are flushed before the promise resolves.
  *
- * Low-level utility for triggering signals directly. Prefer {@link userEvent}
- * for common interactions like clicking and typing.
- *
- * @param element - The widget or event controller to emit the signal on
- * @param signalName - GTK signal name (e.g., "clicked", "activate", "drag-begin")
- * @param args - Additional signal arguments as GValues
- *
- * @example
- * ```tsx
- * import { fireEvent } from "@gtkx/testing";
- * import { Value } from "@gtkx/ffi/gobject";
- *
- * // Emit signal on widget
- * await fireEvent(widget, "clicked");
- *
- * // Emit signal on gesture controller
- * const gesture = widget.observeControllers().getObject(0) as Gtk.GestureDrag;
- * await fireEvent(gesture, "drag-begin", Value.newFromDouble(100), Value.newFromDouble(100));
- * ```
- *
- * @see {@link userEvent} for high-level user interactions
+ * @param element The GObject instance to emit the signal on.
+ * @param signalName Name of the signal to emit.
+ * @param args Arguments passed to the signal handlers.
  */
-export const fireEvent = async (
-    element: Gtk.Widget | Gtk.EventController,
-    signalName: string,
-    ...args: Value[]
-): Promise<void> => {
-    const gtype = typeFromName((element.constructor as typeof GObject).glibTypeName);
-    const signalId = signalLookup(signalName, gtype);
-
-    const instanceValue = Value.newFromObject(element as GObject);
-
-    signalEmitv([instanceValue, ...args], signalId, 0);
-
-    await tick();
+const fireEvent = async (element: GObject.Object, signalName: string, ...args: unknown[]): Promise<void> => {
+    await runInAct(() => {
+        element.emit(signalName, ...args);
+    });
 };
+
+export { fireEvent };

package/src/frame-sync.ts

@@ -0,0 +1,51 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import * as GLib from "@gtkx/gi/glib";
+
+const CLOCK_STALL_FALLBACK_MS = 500;
+
+const once = (callback: () => void): (() => void) => {
+    let isCalled = false;
+
+    return () => {
+        if (isCalled) {
+            return;
+        }
+
+        isCalled = true;
+        callback();
+    };
+};
+
+const runWhenSized = (widget: Gtk.Widget, finish: () => void): void => {
+    let tickId = 0;
+
+    const fallback = setTimeout(() => {
+        widget.removeTickCallback(tickId);
+        finish();
+    }, CLOCK_STALL_FALLBACK_MS);
+
+    tickId = widget.addTickCallback(() => {
+        if (widget.getWidth() === 0) {
+            return GLib.SOURCE_CONTINUE;
+        }
+
+        clearTimeout(fallback);
+        finish();
+
+        return GLib.SOURCE_REMOVE;
+    });
+};
+
+const scheduleAfterLayout = (widget: Gtk.Widget | null, callback: () => void): void => {
+    const finish = once(callback);
+
+    if (widget?.getFrameClock() == null || widget.getWidth() > 0) {
+        queueMicrotask(finish);
+
+        return;
+    }
+
+    runWhenSized(widget, finish);
+};
+
+export { scheduleAfterLayout };

package/src/index.ts

@@ -1,51 +1,94 @@
-export type { Config } from "./config.js";
+import "./register-test-hooks.js";
+
+export { act } from "./act.js";
+export type { BoundQueries, RenderResult, Screen } from "./bound-queries.js";
+export type { Config, ConfigFn } from "./config.js";
 export { configure, getConfig } from "./config.js";
 export { fireEvent } from "./fire-event.js";
+export type { TextExpectation } from "./matchers.js";
+export { matchers, registerMatchers } from "./matchers.js";
 export type { PrettyWidgetOptions } from "./pretty-widget.js";
-export { prettyWidget } from "./pretty-widget.js";
+export { logWidget, prettyWidget } from "./pretty-widget.js";
 export {
+    findAllByDisplayValue,
     findAllByLabelText,
     findAllByName,
+    findAllByPlaceholderText,
     findAllByRole,
     findAllByText,
+    findByDisplayValue,
     findByLabelText,
     findByName,
+    findByPlaceholderText,
     findByRole,
     findByText,
+    getAllByDisplayValue,
+    getAllByLabelText,
+    getAllByName,
+    getAllByPlaceholderText,
+    getAllByRole,
+    getAllByText,
+    getByDisplayValue,
+    getByLabelText,
+    getByName,
+    getByPlaceholderText,
+    getByRole,
+    getByText,
+    getDefaultNormalizer,
+    queryAllByDisplayValue,
     queryAllByLabelText,
     queryAllByName,
+    queryAllByPlaceholderText,
     queryAllByRole,
     queryAllByText,
+    queryByDisplayValue,
     queryByLabelText,
     queryByName,
+    queryByPlaceholderText,
     queryByRole,
     queryByText,
 } from "./queries.js";
-export { cleanup, render } from "./render.js";
 export { renderHook } from "./render-hook.js";
-export type { RoleInfo } from "./role-helpers.js";
-export { getRoles, logRoles, prettyRoles } from "./role-helpers.js";
+export { cleanup, render } from "./render.js";
+export { formatRole, getRoles, logRoles, prettyRoles } from "./role-helpers.js";
 export { screen } from "./screen.js";
-export type { ScreenshotOptions } from "./screenshot.js";
-export { screenshot } from "./screenshot.js";
-export { tick } from "./timing.js";
+export { captureAndSaveScreenshot, logScreenshotPath, screenshot } from "./screenshot.js";
+export type { Method, Suggestion, Variant } from "./suggestions.js";
+export { getSuggestedQuery } from "./suggestions.js";
 export type { Container } from "./traversal.js";
 export type {
-    BoundQueries,
     ByRoleOptions,
+    ByRoleValue,
+    Matcher,
+    MatcherFunction,
+    MatcherOptions,
+    NormalizerFn,
     NormalizerOptions,
     RenderHookOptions,
     RenderHookResult,
     RenderOptions,
-    RenderResult,
+    ScreenshotOptions,
     ScreenshotResult,
-    TextMatch,
-    TextMatchFunction,
-    TextMatchOptions,
     WaitForOptions,
+    WindowSelector,
     WrapperComponent,
 } from "./types.js";
-export type { PointerInput, TabOptions } from "./user-event.js";
-export { userEvent } from "./user-event.js";
+export type {
+    DragOffset,
+    DragOptions,
+    DropContent,
+    DropOptions,
+    PointerInput,
+    ScrollDelta,
+    TabOptions,
+    TypeOptions,
+    UserEvent,
+} from "./user-event/index.js";
+export { userEvent } from "./user-event/index.js";
 export { waitFor, waitForElementToBeRemoved } from "./wait-for.js";
+export {
+    getWidgetErrorMessage,
+    getWidgetInvalidState,
+    getWidgetNodeText,
+} from "./widget-accessible-properties.js";
 export { within } from "./within.js";

package/src/matchers.ts

@@ -0,0 +1,251 @@
+/// <reference types="@vitest/expect" />
+import * as Gtk from "@gtkx/gi/gtk";
+import {
+    getWidgetAccessibleName,
+    getWidgetCheckedState,
+    getWidgetDisplayValue,
+    getWidgetExpandedState,
+    getWidgetNodeText,
+    getWidgetPlaceholderText,
+    getWidgetPressedState,
+    getWidgetSelectedState,
+    getWidgetValue,
+} from "./widget-accessible-properties.js";
+
+/** The expected value for a text matcher: an exact string or a regular expression. */
+type TextExpectation = string | RegExp;
+type MatcherResult = { pass: boolean; message: () => string };
+type TextMatcher = (received: unknown, expected?: TextExpectation) => MatcherResult;
+type StateMatcher = (received: unknown) => MatcherResult;
+type ValueMatcher = (received: unknown, expected: number) => MatcherResult;
+type TextMatcherContext = { matcherName: string; widget: Gtk.Widget; actual: string | null };
+
+type MatcherImplementations = {
+    toHaveDisplayValue: TextMatcher;
+    toHaveTextContent: TextMatcher;
+    toHaveAccessibleName: TextMatcher;
+    toHavePlaceholderText: TextMatcher;
+    toBeChecked: StateMatcher;
+    toBePressed: StateMatcher;
+    toBeExpanded: StateMatcher;
+    toBeSelected: StateMatcher;
+    toHaveValue: ValueMatcher;
+};
+
+type ExpectExtend = { extend: (m: MatcherImplementations) => void };
+
+const toHaveDisplayValue: TextMatcher = textMatcher("toHaveDisplayValue", getWidgetDisplayValue, "exact");
+
+const toHaveTextContent: TextMatcher = textMatcher(
+    "toHaveTextContent",
+    (widget) => getWidgetNodeText(widget) ?? getWidgetAccessibleName(widget),
+    "substring",
+);
+
+const toHaveAccessibleName: TextMatcher = textMatcher("toHaveAccessibleName", getWidgetAccessibleName, "exact");
+
+const toHavePlaceholderText: TextMatcher = textMatcher(
+    "toHavePlaceholderText",
+    getWidgetPlaceholderText,
+    "exact",
+);
+
+const toBeChecked: StateMatcher = booleanStateMatcher("toBeChecked", "checked", getWidgetCheckedState);
+const toBePressed: StateMatcher = booleanStateMatcher("toBePressed", "pressed", getWidgetPressedState);
+const toBeExpanded: StateMatcher = booleanStateMatcher("toBeExpanded", "expanded", getWidgetExpandedState);
+const toBeSelected: StateMatcher = booleanStateMatcher("toBeSelected", "selected", getWidgetSelectedState);
+
+/** The widget assertion matchers keyed by name, suitable for passing to `expect.extend`. */
+const matchers: MatcherImplementations = {
+    toHaveDisplayValue,
+    toHaveTextContent,
+    toHaveAccessibleName,
+    toHavePlaceholderText,
+    toBeChecked,
+    toBePressed,
+    toBeExpanded,
+    toBeSelected,
+    toHaveValue,
+};
+
+const registration = { isRegistered: false };
+
+const asWidget = (received: unknown, matcherName: string): Gtk.Widget => {
+    if (!(received instanceof Gtk.Widget)) {
+        throw new TypeError(`${matcherName}: received value must be a Gtk.Widget, got ${typeof received}`);
+    }
+
+    return received;
+};
+
+const describeWidget = (widget: Gtk.Widget): string => {
+    const role = Gtk.AccessibleRole[widget.getAccessibleRole()];
+    const name = getWidgetAccessibleName(widget);
+
+    return name === null ? `<${role}>` : `<${role} name=${JSON.stringify(name)}>`;
+};
+
+const isTextMatch = (actual: string, expected: TextExpectation, mode: "exact" | "substring"): boolean => {
+    if (expected instanceof RegExp) {
+        expected.lastIndex = 0;
+
+        return expected.test(actual);
+    }
+
+    return mode === "exact" ? actual === expected : actual.includes(expected);
+};
+
+const describeExpected = (expected: TextExpectation): string =>
+    expected instanceof RegExp ? String(expected) : JSON.stringify(expected);
+
+const negationPrefix = (isPass: boolean): string => (isPass ? "not " : "");
+
+const nonEmptyResult = ({ matcherName, widget, actual }: TextMatcherContext): MatcherResult => {
+    const isPass = actual !== null && actual !== "";
+
+    return {
+        pass: isPass,
+        message: () =>
+            `expected widget ${negationPrefix(isPass)}to have a non-empty value for ${matcherName}, ` +
+            `but got ${JSON.stringify(actual)}\n${describeWidget(widget)}`,
+    };
+};
+
+const matchedResult = (context: TextMatcherContext, expected: TextExpectation, isPass: boolean): MatcherResult => ({
+    pass: isPass,
+    message: () =>
+        `expected widget ${negationPrefix(isPass)}${context.matcherName} ${describeExpected(expected)}, ` +
+        `but received ${JSON.stringify(context.actual)}\n${describeWidget(context.widget)}`,
+});
+
+function textMatcher(
+    matcherName: string,
+    read: (widget: Gtk.Widget) => string | null,
+    mode: "exact" | "substring",
+): TextMatcher {
+    return (received: unknown, expected?: TextExpectation): MatcherResult => {
+        const widget = asWidget(received, matcherName);
+        const actual = read(widget);
+        const context: TextMatcherContext = { matcherName, widget, actual };
+
+        if (expected === undefined) {
+            return nonEmptyResult(context);
+        }
+
+        return matchedResult(context, expected, actual !== null && isTextMatch(actual, expected, mode));
+    };
+}
+
+function booleanStateMatcher(
+    matcherName: string,
+    stateName: string,
+    read: (widget: Gtk.Widget) => boolean | null,
+): StateMatcher {
+    return (received: unknown): MatcherResult => {
+        const widget = asWidget(received, matcherName);
+        const state = read(widget);
+
+        if (state === null) {
+            throw new Error(
+                `${matcherName}: widget does not expose a ${stateName} state ` +
+                `(role ${Gtk.AccessibleRole[widget.getAccessibleRole()]})\n${describeWidget(widget)}`,
+            );
+        }
+
+        return {
+            pass: state,
+            message: () =>
+                `expected widget ${negationPrefix(state)}to be ${stateName}\n${describeWidget(widget)}`,
+        };
+    };
+}
+
+function toHaveValue(received: unknown, expected: number): MatcherResult {
+    const widget = asWidget(received, "toHaveValue");
+    const actual = getWidgetValue(widget).now;
+
+    if (actual === null) {
+        throw new Error(
+            "toHaveValue: widget does not expose a numeric value " +
+            `(role ${Gtk.AccessibleRole[widget.getAccessibleRole()]})\n${describeWidget(widget)}`,
+        );
+    }
+
+    const isPass = actual === expected;
+
+    return {
+        pass: isPass,
+        message: () =>
+            `expected widget ${negationPrefix(isPass)}to have value ${String(expected)}, ` +
+            `but received ${String(actual)}\n${describeWidget(widget)}`,
+    };
+}
+
+const globalExpect = (): ExpectExtend | null => {
+    const candidate: unknown = Reflect.get(globalThis, "expect");
+
+    if (candidate && typeof (candidate as ExpectExtend).extend === "function") {
+        return candidate as ExpectExtend;
+    }
+
+    return null;
+};
+
+/** Registers the widget matchers on the global `expect`, when one is available. Safe to call more than once. */
+const registerMatchers = (): void => {
+    if (registration.isRegistered) {
+        return;
+    }
+
+    const expect = globalExpect();
+
+    if (!expect) {
+        return;
+    }
+
+    expect.extend(matchers);
+    registration.isRegistered = true;
+};
+
+declare module "@vitest/expect" {
+    /* eslint-disable @typescript-eslint/consistent-type-definitions -- declaration merging requires interfaces */
+    interface Assertion {
+        toHaveDisplayValue(expected?: TextExpectation): void;
+        toHaveTextContent(expected?: TextExpectation): void;
+        toHaveAccessibleName(expected?: TextExpectation): void;
+        toHavePlaceholderText(expected?: TextExpectation): void;
+        toBeChecked(): void;
+        toBePressed(): void;
+        toBeExpanded(): void;
+        toBeSelected(): void;
+        toHaveValue(expected: number): void;
+    }
+
+    interface AsymmetricMatchersContaining {
+        toHaveDisplayValue(expected?: TextExpectation): void;
+        toHaveTextContent(expected?: TextExpectation): void;
+        toHaveAccessibleName(expected?: TextExpectation): void;
+        toHavePlaceholderText(expected?: TextExpectation): void;
+        toBeChecked(): void;
+        toBePressed(): void;
+        toBeExpanded(): void;
+        toBeSelected(): void;
+        toHaveValue(expected: number): void;
+    }
+    /* eslint-enable @typescript-eslint/consistent-type-definitions */
+}
+
+export {
+    toHaveDisplayValue,
+    toHaveTextContent,
+    toHaveAccessibleName,
+    toHavePlaceholderText,
+    toBeChecked,
+    toBePressed,
+    toBeExpanded,
+    toBeSelected,
+    matchers,
+    toHaveValue,
+    registerMatchers,
+    type TextExpectation,
+};