#!/bin/bash
|
# Round01 session snapshot QA. It opens the Quick Switch session through the app
|
# entrypoint and verifies that the session froze a real Space/Window snapshot
|
# into a UI-facing report.
|
|
set -euo pipefail
|
|
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
OUTPUT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
|
# shellcheck source=build-output-paths.sh
|
source "$SCRIPT_DIR/build-output-paths.sh"
|
APP="$BUILD_CURRENT_APP"
|
REPORT="$BUILD_REPORT_ROOT/round01-quick-switch-session-report.json"
|
OPEN_WAIT="${ALIGNER_ROUND1_SESSION_SNAPSHOT_OPEN_WAIT:-1.2}"
|
REPORT_WAIT="${ALIGNER_ROUND1_SESSION_SNAPSHOT_REPORT_WAIT:-6.0}"
|
|
fail() {
|
echo "Round01 session snapshot QA failed: $*" >&2
|
exit 1
|
}
|
|
aligner_pids_for_current_app() {
|
ps -axo pid=,args= | while read -r pid command; do
|
case "$command" in
|
"$APP/Contents/MacOS/Aligner"*) echo "$pid" ;;
|
esac
|
done
|
}
|
|
stop_current_aligner() {
|
for pid in $(aligner_pids_for_current_app); do
|
kill "$pid" 2>/dev/null || true
|
done
|
|
for _ in {1..30}; do
|
[ -z "$(aligner_pids_for_current_app)" ] && return
|
sleep 0.1
|
done
|
|
fail "current Aligner app did not exit before QA"
|
}
|
|
assert_report() {
|
/usr/bin/python3 - "$REPORT" <<'PY'
|
import json
|
import sys
|
|
path = sys.argv[1]
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
|
def require(condition, message):
|
if not condition:
|
print(message, file=sys.stderr)
|
print(json.dumps(report, indent=2, ensure_ascii=False), file=sys.stderr)
|
sys.exit(1)
|
|
def near(lhs, rhs, tolerance=0.01):
|
return abs((lhs or 0) - (rhs or 0)) <= tolerance
|
|
def is_blue(color, min_alpha=0.30):
|
return (
|
isinstance(color, dict)
|
and color.get("blue", 0) >= 0.85
|
and color.get("green", 0) >= 0.35
|
and color.get("red", 1) <= 0.18
|
and color.get("alpha", 0) >= min_alpha
|
)
|
|
require(report.get("snapshotLoaded") is True, "snapshotLoaded must be true")
|
require(report.get("displayCount", 0) >= 1, "displayCount must be >= 1")
|
require(report.get("spaceCount", 0) >= 1, "spaceCount must be >= 1")
|
require(report.get("appCount", -1) == report.get("columnCount", -2), "appCount must equal columnCount")
|
require(report.get("windowCount", 0) >= 1, "windowCount must be >= 1 on the QA desktop")
|
require(report.get("initialSelectionWindowID") is not None, "initialSelectionWindowID must exist when windows exist")
|
require(len(report.get("spaceLabels", [])) == report.get("spaceCount"), "spaceLabels count must match spaceCount")
|
require(report.get("snapshotRanOnMainThread") is False, "snapshot must not run on the main thread")
|
require(report.get("rootView", {}).get("viewClass") == "QuickSwitchRootView", "root view must be QuickSwitchRootView")
|
require(report.get("rootView", {}).get("isLayerBacked") is True, "root view must be layer-backed AppKit")
|
require(report.get("rootView", {}).get("waterfallFrame", {}).get("width", 0) > 0, "waterfall frame must be laid out")
|
root_view = report.get("rootView", {})
|
space_labels = report.get("spaceLabels", [])
|
lane_labels = root_view.get("spaceLaneLabels", [])
|
lane_segments = root_view.get("spaceLaneSegments", [])
|
root_bounds = root_view.get("bounds", {})
|
glass_frame = root_view.get("glassFrame", {})
|
safe_area_top_inset = root_view.get("safeAreaTopInset", 0)
|
safe_area_fill_frame = root_view.get("safeAreaFillFrame", {})
|
lane_frame = root_view.get("spaceLaneFrame", {})
|
shelf_frame = root_view.get("appShelfFrame", {})
|
waterfall_frame = root_view.get("waterfallFrame", {})
|
require(near(glass_frame.get("x"), root_bounds.get("x")), "Quick Switch glass layer x must match root bounds")
|
require(near(glass_frame.get("y"), root_bounds.get("y")), "Quick Switch glass layer y must match root bounds")
|
require(near(glass_frame.get("width"), root_bounds.get("width")), "Quick Switch glass layer width must match root bounds")
|
require(near(glass_frame.get("height"), root_bounds.get("height")), "Quick Switch glass layer height must match root bounds")
|
require(root_view.get("glassCornerRadius") == 0, "Quick Switch glass layer must not draw an outer rounded frame")
|
require(root_view.get("glassBorderWidth") == 0, "Quick Switch glass layer must not draw an outer border")
|
require(root_view.get("glassShadowOpacity") == 0, "Quick Switch glass layer must not draw an outer shadow")
|
require(safe_area_top_inset >= 0, "safeAreaTopInset must be non-negative")
|
if safe_area_top_inset > 0.5:
|
require(near(safe_area_fill_frame.get("height"), safe_area_top_inset), "safe-area fill height must match safeAreaTopInset")
|
require(near(safe_area_fill_frame.get("y") + safe_area_fill_frame.get("height"), root_bounds.get("height")), "safe-area fill must sit at the top edge")
|
require(root_view.get("spaceLaneSegmentCount") == report.get("spaceCount"), "Space Lane segment count must match spaceCount")
|
require(lane_labels == space_labels, "Space Lane labels must match report spaceLabels exactly")
|
require(len(set(lane_labels)) == len(lane_labels), "Space Lane labels must be unique")
|
require(len(lane_segments) == report.get("spaceCount"), "Space Lane segment reports must match spaceCount")
|
require([segment.get("label") for segment in lane_segments] == space_labels, "Space Lane segment reports must follow spaceLabels order")
|
require(all(isinstance(segment.get("windowCount"), int) for segment in lane_segments), "Space Lane segments must expose window counts")
|
require(all(isinstance(segment.get("appCount"), int) for segment in lane_segments), "Space Lane segments must expose app counts")
|
require(all(isinstance(segment.get("appNames"), list) for segment in lane_segments), "Space Lane segments must expose app names")
|
require(all(isinstance(segment.get("frame"), dict) for segment in lane_segments), "Space Lane segments must expose content frames")
|
require(all(isinstance(segment.get("visibleFrame"), dict) for segment in lane_segments), "Space Lane segments must expose visible frames")
|
require(all(isinstance(segment.get("borderColor"), dict) for segment in lane_segments), "Space Lane segments must expose border colors")
|
require(all(isinstance(segment.get("windowBlockColors"), list) for segment in lane_segments), "Space Lane segments must expose window block colors")
|
occupied_segments = [segment for segment in lane_segments if segment.get("windowCount", 0) > 0]
|
empty_segments = [segment for segment in lane_segments if segment.get("windowCount", 0) == 0]
|
require(all(is_blue(segment.get("borderColor"), min_alpha=0.34) for segment in occupied_segments), "occupied Space segments must use blue borders")
|
require(all(not is_blue(segment.get("borderColor"), min_alpha=0.34) for segment in empty_segments), "empty Space segments must not use blue borders")
|
occupied_floating_segments = [segment for segment in occupied_segments if segment.get("type") != "fullscreen"]
|
require(all(segment.get("windowBlockCount", 0) > 0 for segment in occupied_floating_segments), "occupied non-fullscreen Spaces must expose window blocks")
|
for segment in occupied_floating_segments:
|
require(all(is_blue(color, min_alpha=0.50) for color in segment.get("windowBlockColors", [])), "occupied Space window blocks must be blue")
|
same_display_gaps = []
|
cross_display_gaps = []
|
for previous, current in zip(lane_segments, lane_segments[1:]):
|
previous_frame = previous.get("visibleFrame", {})
|
current_frame = current.get("visibleFrame", {})
|
gap = current_frame.get("x", 0) - (previous_frame.get("x", 0) + previous_frame.get("width", 0))
|
if previous.get("displayUUID") == current.get("displayUUID"):
|
same_display_gaps.append(gap)
|
else:
|
cross_display_gaps.append(gap)
|
if cross_display_gaps:
|
require(all(gap >= 24 for gap in cross_display_gaps), "Space Lane must leave a visible gap between displays")
|
if same_display_gaps:
|
require(min(cross_display_gaps) > max(same_display_gaps) + 8, "display gap must be clearly larger than same-display Space gaps")
|
current_labels = root_view.get("spaceLaneCurrentLabels", [])
|
fullscreen_labels = root_view.get("spaceLaneFullscreenLabels", [])
|
require(len(current_labels) >= 1, "Space Lane must mark at least one current Space")
|
require(set(current_labels).issubset(set(space_labels)), "current Space labels must be a subset of Space Lane labels")
|
require(set(fullscreen_labels).issubset(set(space_labels)), "fullscreen Space labels must be a subset of Space Lane labels")
|
require(len(fullscreen_labels) >= 1, "QA desktop must include at least one fullscreen Space in Space Lane")
|
fullscreen_segments = [segment for segment in lane_segments if segment.get("type") == "fullscreen"]
|
require([segment.get("label") for segment in fullscreen_segments] == fullscreen_labels, "fullscreen segment reports must match fullscreen labels")
|
require(all(segment.get("fullscreenMarkerVisible") is True for segment in fullscreen_segments), "fullscreen segments must expose fullscreen marker")
|
require(
|
all(segment.get("fullscreenMarkerKind") in {"cornerBracket", "splitViewPair"} for segment in fullscreen_segments),
|
"fullscreen segments must use a known fullscreen marker"
|
)
|
require(all(segment.get("windowBlockCount") == 0 for segment in fullscreen_segments), "fullscreen segments must not expose floating-window blocks")
|
non_fullscreen_segments = [segment for segment in lane_segments if segment.get("type") != "fullscreen"]
|
require(all(segment.get("fullscreenMarkerKind") == "none" for segment in non_fullscreen_segments), "non-fullscreen segments must not expose fullscreen marker")
|
for segment in fullscreen_segments:
|
require("fullscreen" in segment.get("visualStates", []), "fullscreen segments must expose fullscreen visual state")
|
marker_frame = segment.get("fullscreenMarkerFrame", {})
|
app_frame = segment.get("appFrame", {})
|
require(isinstance(marker_frame, dict), "fullscreen segments must expose marker frame")
|
marker_mid_y = marker_frame.get("y", 0) + marker_frame.get("height", 0) / 2
|
if segment.get("fullscreenMarkerKind") == "splitViewPair":
|
label_frames = segment.get("splitViewLabelFrames", [])
|
require(len(label_frames) == 2, "Split View fullscreen segments must expose two app label frames")
|
require(
|
segment.get("splitViewAppNames") and len(segment.get("splitViewAppNames")) == 2,
|
"Split View fullscreen segments must expose two ordered app names"
|
)
|
require(
|
label_frames[0].get("x", 0) + label_frames[0].get("width", 0) / 2
|
< marker_frame.get("x", 0) + marker_frame.get("width", 0) / 2
|
< label_frames[1].get("x", 0) + label_frames[1].get("width", 0) / 2,
|
"Split View app labels must occupy left and right marker halves"
|
)
|
for label_frame in label_frames:
|
app_mid_y = label_frame.get("y", 0) + label_frame.get("height", 0) / 2
|
require(abs(marker_mid_y - app_mid_y) <= 2, "Split View App labels must be vertically centered in marker")
|
else:
|
require(isinstance(app_frame, dict), "fullscreen segments must expose centered App label frame")
|
app_mid_y = app_frame.get("y", 0) + app_frame.get("height", 0) / 2
|
require(abs(marker_mid_y - app_mid_y) <= 2, "fullscreen App label must be vertically centered in marker")
|
for segment in lane_segments:
|
if segment.get("isCurrent") is True:
|
require("current" in segment.get("visualStates", []), "current segment must expose current visual state")
|
if set(current_labels).intersection(fullscreen_labels):
|
for segment in lane_segments:
|
if segment.get("label") in set(current_labels).intersection(fullscreen_labels):
|
states = set(segment.get("visualStates", []))
|
require({"current", "fullscreen"}.issubset(states), "current fullscreen segment must expose both visual states")
|
require(lane_frame.get("width", 0) > lane_frame.get("height", 0) * 4, "Space Lane must be a top horizontal region")
|
require(lane_frame.get("y", 0) > shelf_frame.get("y", 0), "Space Lane must be above App Shelf")
|
require(shelf_frame.get("y", 0) > waterfall_frame.get("y", 0), "App Shelf must be above Waterfall")
|
lane_visible_width = root_view.get("spaceLaneVisibleWidth", 0)
|
lane_content_width = root_view.get("spaceLaneContentWidth", 0)
|
lane_max_scroll_offset = root_view.get("spaceLaneMaxScrollOffset", 0)
|
require(lane_visible_width == lane_frame.get("width", 0), "Space Lane visible width must match frame width")
|
require(lane_content_width >= lane_visible_width, "Space Lane content width must cover visible width")
|
require(lane_max_scroll_offset == max(0, lane_content_width - lane_visible_width), "Space Lane max scroll offset must match content overflow")
|
if lane_content_width > lane_visible_width:
|
require(root_view.get("spaceLaneScrollable") is True, "overflowing Space Lane must be scrollable")
|
require(lane_max_scroll_offset > 0, "overflowing Space Lane must expose positive max scroll offset")
|
else:
|
require(root_view.get("spaceLaneScrollable") is False, "non-overflowing Space Lane should not report scrollable")
|
if lane_segments:
|
first_frame = lane_segments[0].get("visibleFrame", {})
|
last_frame = lane_segments[-1].get("visibleFrame", {})
|
left_blank = first_frame.get("x", 0)
|
right_blank = lane_visible_width - (last_frame.get("x", 0) + last_frame.get("width", 0))
|
require(abs(left_blank - right_blank) <= 2, "non-overflowing Space Lane segments must be centered")
|
app_shelf_items = root_view.get("appShelfItems", [])
|
app_shelf_names = root_view.get("appShelfNames", [])
|
require(root_view.get("appShelfItemCount") == report.get("appCount"), "App Shelf item count must match appCount")
|
require(app_shelf_names == report.get("appShelfNames", []), "App Shelf order must match report appShelfNames")
|
require(len(app_shelf_items) == report.get("appCount"), "App Shelf item reports must match appCount")
|
require([item.get("name") for item in app_shelf_items] == report.get("appShelfNames", []), "App Shelf item reports must follow appShelfNames order")
|
require(root_view.get("appShelfMaxRows") == 2, "App Shelf max rows must be 2")
|
require(1 <= root_view.get("appShelfRows", 0) <= 2, "App Shelf must use 1 or 2 rows when apps exist")
|
require(root_view.get("appShelfNormalIconSize") == 56, "App Shelf normal icon size must be 56pt")
|
require(root_view.get("appShelfHoverIconSize") == 68, "App Shelf hover icon size must be 68pt")
|
require(root_view.get("appShelfSelectedIconSize") == 68, "App Shelf selected icon size must be 68pt")
|
require(root_view.get("appShelfMinIconSize") == 36, "App Shelf min icon size must be 36pt")
|
icon_size = root_view.get("appShelfIconSize", 0)
|
require(36 <= icon_size <= 56, "App Shelf layout icon size must stay between 36pt and 56pt")
|
require(all(item.get("labelTruncationMode") == "middle" for item in app_shelf_items), "App Shelf labels must use middle truncation")
|
require(sum(1 for item in app_shelf_items if item.get("isSelected") is True) == 1, "App Shelf must expose one selected app")
|
require(all(isinstance(item.get("frame"), dict) for item in app_shelf_items), "App Shelf items must expose frames")
|
require(all(isinstance(item.get("iconFrame"), dict) for item in app_shelf_items), "App Shelf items must expose icon frames")
|
for item in app_shelf_items:
|
if item.get("isHovered") is True:
|
expected_icon_size = root_view.get("appShelfHoverIconSize")
|
else:
|
expected_icon_size = icon_size
|
if item.get("isSelected") is True and item.get("isHovered") is not True:
|
require("selectedVisualSuppressed" in item.get("visualStates", []), "non-hovered selected App Shelf item must suppress selected visual state")
|
require(abs(item.get("iconFrame", {}).get("width", -1) - expected_icon_size) < 0.01, "App Shelf icon frame width must match visual icon size")
|
require(abs(item.get("iconFrame", {}).get("height", -1) - expected_icon_size) < 0.01, "App Shelf icon frame height must match visual icon size")
|
row_y_values = {round(item.get("frame", {}).get("y", 0), 2) for item in app_shelf_items}
|
require(len(row_y_values) == root_view.get("appShelfRows"), "App Shelf reported row count must match visible row y positions")
|
app_visible_width = root_view.get("appShelfVisibleWidth", 0)
|
app_content_width = root_view.get("appShelfContentWidth", 0)
|
app_max_scroll_offset = root_view.get("appShelfMaxScrollOffset", 0)
|
require(app_visible_width == shelf_frame.get("width", 0), "App Shelf visible width must match frame width")
|
require(app_content_width >= app_visible_width, "App Shelf content width must cover visible width")
|
require(app_max_scroll_offset == max(0, app_content_width - app_visible_width), "App Shelf max scroll offset must match content overflow")
|
if app_content_width > app_visible_width:
|
require(root_view.get("appShelfScrollable") is True, "overflowing App Shelf must be scrollable")
|
else:
|
require(root_view.get("appShelfScrollable") is False, "non-overflowing App Shelf should not report scrollable")
|
waterfall_columns = root_view.get("waterfallColumns", [])
|
waterfall_names = root_view.get("waterfallColumnNames", [])
|
require(root_view.get("waterfallColumnCount") == report.get("columnCount"), "Waterfall column count must match report columnCount")
|
require(root_view.get("waterfallColumnCount") == report.get("appCount"), "Waterfall column count must match appCount")
|
require(waterfall_names == app_shelf_names, "Waterfall column order must match App Shelf order")
|
require(len(waterfall_columns) == report.get("columnCount"), "Waterfall column reports must match columnCount")
|
require(root_view.get("waterfallClipsToBounds") is True, "Waterfall viewport must clip overflowing columns")
|
waterfall_visible_width = root_view.get("waterfallVisibleWidth", 0)
|
waterfall_content_width = root_view.get("waterfallContentWidth", 0)
|
waterfall_max_scroll_offset = root_view.get("waterfallMaxScrollOffset", 0)
|
require(waterfall_visible_width == waterfall_frame.get("width", 0), "Waterfall visible width must match frame width")
|
require(waterfall_content_width >= waterfall_visible_width, "Waterfall content width must cover visible width")
|
require(waterfall_max_scroll_offset == max(0, waterfall_content_width - waterfall_visible_width), "Waterfall max scroll offset must match content overflow")
|
if waterfall_content_width > waterfall_visible_width:
|
require(root_view.get("waterfallScrollable") is True, "overflowing Waterfall must be scrollable")
|
else:
|
require(root_view.get("waterfallScrollable") is False, "non-overflowing Waterfall should not report scrollable")
|
waterfall_card_count = 0
|
global_indexes = []
|
window_ids = []
|
low_information_card_keys = []
|
valid_thumbnail_strategies = {
|
"skeleton",
|
"skeletonPreferred",
|
"pendingScreenshot",
|
"realScreenshot",
|
"skeletonFallback",
|
}
|
valid_screenshot_sources = {
|
"pending",
|
"notRequested",
|
"realScreenshot",
|
"skeletonFallback",
|
}
|
for expected_index, column in enumerate(waterfall_columns):
|
require(column.get("appGroupIndex") == expected_index, "Waterfall appGroupIndex must be sequential")
|
require(column.get("appName") == app_shelf_names[expected_index], "Waterfall column app name must match App Shelf order")
|
require(isinstance(column.get("frame"), dict), "Waterfall columns must expose frames")
|
require(isinstance(column.get("visibleFrame"), dict), "Waterfall columns must expose visible frames")
|
require(isinstance(column.get("maxVerticalScrollOffset"), (int, float)), "Waterfall columns must expose vertical scroll range")
|
require(isinstance(column.get("verticalScrollOffset"), (int, float)), "Waterfall columns must expose vertical scroll offset")
|
cards = column.get("cards", [])
|
require(len(cards) == column.get("windowCount"), "Waterfall card count must match column windowCount")
|
require([card.get("windowIndex") for card in cards] == list(range(len(cards))), "Waterfall card windowIndex must be sequential per column")
|
for card in cards:
|
require(card.get("appGroupIndex") == expected_index, "Waterfall card appGroupIndex must match its column")
|
require(isinstance(card.get("globalIndex"), int), "Waterfall cards must expose globalIndex")
|
require(isinstance(card.get("windowID"), int), "Waterfall cards must expose windowID")
|
window_ids.append(card.get("windowID"))
|
if card.get("identifierSource") == "cgWindow" and card.get("titleLength") == 0:
|
low_information_card_keys.append((
|
column.get("bundleIdentifier"),
|
card.get("titleHash"),
|
card.get("titleLength"),
|
card.get("primarySpaceID"),
|
card.get("identifierSource"),
|
))
|
require(isinstance(card.get("frame"), dict), "Waterfall cards must expose frames")
|
require(isinstance(card.get("visibleFrame"), dict), "Waterfall cards must expose visible frames")
|
require(card.get("thumbnailStrategy") in valid_thumbnail_strategies, "Waterfall cards must expose valid thumbnail strategy")
|
require(card.get("screenshotSource") in valid_screenshot_sources, "Waterfall cards must expose valid screenshot source")
|
if card.get("screenshotSource") == "skeletonFallback":
|
require(card.get("screenshotFallbackReason") is not None, "skeleton fallback cards must expose fallback reason")
|
if card.get("screenshotSource") == "notRequested":
|
require(card.get("screenshotNotRequestedReason") is not None, "not-requested screenshot cards must expose reason")
|
require(isinstance(card.get("thumbnailFrame"), dict), "Waterfall cards must expose thumbnail frames")
|
require(isinstance(card.get("titleBarFrame"), dict), "Waterfall cards must expose title bar frames")
|
require(card.get("titleBarBorderWidth") == 0, "Waterfall title area must not draw an enclosing rounded rectangle")
|
require(isinstance(card.get("titleFrame"), dict), "Waterfall cards must expose title frames")
|
card_frame = card.get("frame", {})
|
thumbnail_frame = card.get("thumbnailFrame", {})
|
title_bar_frame = card.get("titleBarFrame", {})
|
require(thumbnail_frame.get("width", 0) >= card_frame.get("width", 0) * 0.82, "Waterfall thumbnail must use most of the card width")
|
require(title_bar_frame.get("y", 0) > thumbnail_frame.get("y", 0) + thumbnail_frame.get("height", 0), "Waterfall title bar must sit above the thumbnail")
|
require(isinstance(card.get("appIconFrame"), dict), "Waterfall cards must expose App icon frames")
|
require(isinstance(card.get("visualStates"), list), "Waterfall cards must expose visual states")
|
require(card.get("titleTruncationMode") == "middle", "Waterfall card titles must use middle truncation")
|
global_indexes.append(card.get("globalIndex"))
|
waterfall_card_count += len(cards)
|
require(waterfall_card_count == report.get("windowCount"), "Waterfall cards must cover report windowCount")
|
require(len(window_ids) == len(set(window_ids)), "Waterfall windowIDs must be unique")
|
require(
|
len(low_information_card_keys) == len(set(low_information_card_keys)),
|
"Waterfall must not expose duplicate low-information CG window candidates"
|
)
|
require(isinstance(root_view.get("screenshotEligibleCount"), int), "root view must expose screenshotEligibleCount")
|
require(isinstance(root_view.get("screenshotResolvedCount"), int), "root view must expose screenshotResolvedCount")
|
require(isinstance(root_view.get("screenshotPendingCount"), int), "root view must expose screenshotPendingCount")
|
require(isinstance(root_view.get("screenshotNotRequestedCount"), int), "root view must expose screenshotNotRequestedCount")
|
require(root_view.get("screenshotResolvedCount") + root_view.get("screenshotPendingCount") == root_view.get("screenshotEligibleCount"), "resolved + pending screenshots must match eligible count")
|
require(root_view.get("screenshotEligibleCount") + root_view.get("screenshotNotRequestedCount") == waterfall_card_count, "eligible + not-requested screenshots must cover all cards")
|
require(global_indexes == sorted(global_indexes), "Waterfall global indexes must be monotonic across columns")
|
if root_view.get("activeSpaceFocusID") is None:
|
require(
|
all("spaceFocused" not in card.get("visualStates", []) for column in waterfall_columns for card in column.get("cards", [])),
|
"Waterfall cards must not expose spaceFocused when no Space Lane focus is active"
|
)
|
selected_cards = [
|
card
|
for column in waterfall_columns
|
for card in column.get("cards", [])
|
if card.get("isSelected") is True
|
]
|
require(len(selected_cards) == 1, "Waterfall must expose exactly one selected card")
|
require("selectedVisualSuppressed" in selected_cards[0].get("visualStates", []), "non-hovered selected Waterfall card must suppress selected visual state")
|
require(selected_cards[0].get("shineVisible") is False, "non-hovered selected Waterfall card must not expose shine layer")
|
require(selected_cards[0].get("zPosition", 0) == 0, "non-hovered selected Waterfall card must not float above normal cards")
|
require(isinstance(report.get("overlayOpenElapsedMilliseconds"), (int, float)), "overlay open timing must exist")
|
require(isinstance(report.get("snapshotStartElapsedMilliseconds"), (int, float)), "snapshot start timing must exist")
|
require(report["snapshotStartElapsedMilliseconds"] >= report["overlayOpenElapsedMilliseconds"], "snapshot must start after overlay open path")
|
require(isinstance(report.get("snapshotDurationMilliseconds"), (int, float)), "snapshot duration timing must exist")
|
|
print(json.dumps(report, indent=2, ensure_ascii=False))
|
PY
|
}
|
|
click_target_from_report() {
|
/usr/bin/python3 - "$REPORT" <<'PY'
|
import json
|
import sys
|
|
path = sys.argv[1]
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
|
root = report.get("rootView", {})
|
for column in root.get("waterfallColumns", []):
|
for card in column.get("cards", []):
|
if card.get("identifierSource") == "cgWindow" and card.get("isMinimized") is False:
|
print(f"{card.get('appGroupIndex')}:{card.get('windowIndex')}:{card.get('windowID')}")
|
sys.exit(0)
|
|
print("no non-minimized cgWindow card available for click activation QA", file=sys.stderr)
|
sys.exit(1)
|
PY
|
}
|
|
wait_for_click_report() {
|
/usr/bin/python3 - "$REPORT" "$REPORT_WAIT" <<'PY'
|
import json
|
import sys
|
import time
|
|
path = sys.argv[1]
|
timeout = float(sys.argv[2])
|
deadline = time.monotonic() + timeout
|
last_report = None
|
|
while time.monotonic() < deadline:
|
try:
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
last_report = report
|
if report.get("lastCommitSource") == "mouse" and report.get("lastActivationResult") is not None:
|
sys.exit(0)
|
except FileNotFoundError:
|
pass
|
except json.JSONDecodeError:
|
pass
|
time.sleep(0.2)
|
|
if last_report is not None:
|
print(json.dumps(last_report, indent=2, ensure_ascii=False), file=sys.stderr)
|
print(f"click activation report did not complete within {timeout:.1f}s", file=sys.stderr)
|
sys.exit(1)
|
PY
|
}
|
|
assert_click_report() {
|
/usr/bin/python3 - "$REPORT" "$1" <<'PY'
|
import json
|
import sys
|
|
path = sys.argv[1]
|
expected_window_id = int(sys.argv[2])
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
|
def require(condition, message):
|
if not condition:
|
print(message, file=sys.stderr)
|
print(json.dumps(report, indent=2, ensure_ascii=False), file=sys.stderr)
|
sys.exit(1)
|
|
require(report.get("lastCommitSource") == "mouse", "click activation source must be mouse")
|
require(report.get("lastActivationWindowID") == expected_window_id, "click activation must target the selected card windowID")
|
require(report.get("lastActivationResult") == "activated", "click activation must activate the target window")
|
print(json.dumps({
|
"lastCommitSource": report.get("lastCommitSource"),
|
"lastActivationWindowID": report.get("lastActivationWindowID"),
|
"lastActivationResult": report.get("lastActivationResult"),
|
}, indent=2, ensure_ascii=False))
|
PY
|
}
|
|
wait_for_loaded_report() {
|
/usr/bin/python3 - "$REPORT" "$REPORT_WAIT" <<'PY'
|
import json
|
import sys
|
import time
|
|
path = sys.argv[1]
|
timeout = float(sys.argv[2])
|
deadline = time.monotonic() + timeout
|
last_report = None
|
|
while time.monotonic() < deadline:
|
try:
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
last_report = report
|
if report.get("snapshotLoaded") is True:
|
sys.exit(0)
|
except FileNotFoundError:
|
pass
|
except json.JSONDecodeError:
|
pass
|
time.sleep(0.2)
|
|
if last_report is not None:
|
print(json.dumps(last_report, indent=2, ensure_ascii=False), file=sys.stderr)
|
print(f"snapshot report did not become loaded within {timeout:.1f}s", file=sys.stderr)
|
sys.exit(1)
|
PY
|
}
|
|
stop_current_aligner
|
"$SCRIPT_DIR/package-app.sh" >&2
|
rm -f "$REPORT"
|
|
"$APP/Contents/MacOS/Aligner" \
|
--round0-skip-permissions \
|
--round01-open-quick-switch \
|
--round01-quick-switch-report="$REPORT" &
|
|
APP_PID=$!
|
|
cleanup() {
|
if kill -0 "$APP_PID" 2>/dev/null; then
|
kill "$APP_PID" 2>/dev/null || true
|
wait "$APP_PID" 2>/dev/null || true
|
fi
|
}
|
trap cleanup EXIT
|
|
sleep "$OPEN_WAIT"
|
|
swift "$SCRIPT_DIR/window-logic-qa.swift" \
|
--expect-quick-switch \
|
--expect-single-aligner-overlay \
|
--expect-overlay-on-mouse-screen \
|
--expect-overlay-uses-screen-frame
|
|
wait_for_loaded_report
|
assert_report
|
CLICK_TARGET="$(click_target_from_report)"
|
|
cleanup
|
trap - EXIT
|
|
rm -f "$REPORT"
|
IFS=: read -r CLICK_APP_INDEX CLICK_WINDOW_INDEX CLICK_WINDOW_ID <<<"$CLICK_TARGET"
|
"$APP/Contents/MacOS/Aligner" \
|
--round0-skip-permissions \
|
--round01-open-quick-switch \
|
--round01-disable-screenshot-refresh \
|
--round01-debug-mouse-sequence="click-card:$CLICK_APP_INDEX:$CLICK_WINDOW_INDEX" \
|
--round01-quick-switch-report="$REPORT" &
|
|
APP_PID=$!
|
trap cleanup EXIT
|
wait_for_click_report
|
assert_click_report "$CLICK_WINDOW_ID"
|
cleanup
|
trap - EXIT
|
|
swift "$SCRIPT_DIR/window-logic-qa.swift" --expect-no-quick-switch
|
