From 9e9f9b0b48feba8cdcc227c4f29d91be22ec03ca Mon Sep 17 00:00:00 2001 From: Hubert Date: Mon, 2 Nov 2026 02:20:03 +0800 Subject: [PATCH 01/40] docs: windows PRD + cross-platform color history spec + 4 subagent briefs Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com> --- docs/specs/color-history-window.md | 110 ++++ tasks/briefs/brief-A-skeleton-core.md | 34 ++ tasks/briefs/brief-B-capture-shell.md | 31 + tasks/briefs/brief-C-translation-services.md | 29 + tasks/briefs/brief-D-color-history-macos.md | 33 + tasks/prd-windows-transframe.md | 610 +++++++++++++++++++ 6 files changed, 847 insertions(+) create mode 100644 docs/specs/color-history-window.md create mode 100644 tasks/briefs/brief-A-skeleton-core.md create mode 100644 tasks/briefs/brief-B-capture-shell.md create mode 100644 tasks/briefs/brief-C-translation-services.md create mode 100644 tasks/briefs/brief-D-color-history-macos.md create mode 100644 tasks/prd-windows-transframe.md diff --git a/docs/specs/color-history-window.md b/docs/specs/color-history-window.md new file mode 100644 index 0000000..2987108 --- /dev/null +++ b/docs/specs/color-history-window.md @@ -0,0 +1,110 @@ +# Spec: 独立取色历史窗口(macOS + Windows 同步交付) + +- **Status**: Approved(决策 4,2026-11-02) +- **Parent PRD**: `tasks/prd-windows-transframe.md`(FR-41 / US-W26);macOS 侧对应新增 US +- **Scope**: 取色器拾取的颜色以独立窗口的形式提供历史浏览、复制、收藏、删除、清空 + +## 1. 概述 + +当前取色器拾取的颜色只作为 `HistoryCategory.color` 条目混入翻译历史列表,色块小、入口深、缺少专属交互。本特性新增一个**独立的取色历史窗口**:以大色块网格为主体的专属视图,单击复制 HEX,支持收藏、删除、搜索与清空。macOS 与 Windows **同一交互规格、同步交付**。 + +## 2. 动机 + +- 设计/开发用户高频取色,需要在旧颜色间快速回看与复制。 +- 通用历史列表对 color 条目的呈现(小缩略图 + 文本行)无法体现"颜色"这一主体信息。 +- 两平台规格统一,避免后续维护两套交互心智。 + +## 3. 数据模型(两平台一致,零迁移成本) + +复用现有 `TranslationHistory` / history `color` 类目条目,**不新增存储表**: + +| 字段 | 取值约定 | +|------|----------| +| `category` | `.color` / `HistoryCategory.color` | +| `translatedText` | HEX,如 `#1A2B3C`(大写,6 位) | +| `sourceText` | 固定文案 "Color Picked"(沿用现状,见 `HistoryStore.swift` addColor) | +| `sourceLanguage` | `"RGB Hex"`(沿用现状) | +| `thumbnailData` | 不使用(色块由 HEX 直接渲染,无需缩略图) | + +- 条目容量上限、自动清理策略沿用历史设置(`maxHistoryEntries` / Windows 侧 SQLite 同语义)。 +- Windows 侧为 SQLite 存储(PRD 决策 2:LIKE 检索),`meta_json` 预留 RGB/取色位置扩展位。 + +## 4. 交互规格(唯一权威定义,两平台 1:1) + +### 4.1 窗口 + +- 独立窗口(非弹层),标题"取色历史 / Color History"。 +- 默认尺寸 560×420,可缩放,记住位置与尺寸。 +- 入口 ×2:托盘菜单("取色历史"项,置于"翻译历史"之后);取色器完成一次取色后的悬浮提示中"查看历史"链接。 +- 深浅色跟随系统;macOS 用 NSVisualEffectView 侧边栏材质,Windows 用 Mica(PRD FR-50.1)。 + +### 4.2 主体网格 + +- 色块网格:自适应列(每格 ≥ 48×48 逻辑像素),色块下方显示 HEX(等宽字体)。 +- 悬浮:显示完整 HEX/RGB/取色时间 tooltip;右上角出现操作按钮(复制 / 收藏 / 删除)。 +- 收藏条目:色块右上角常显星标。 +- 空态:居中插图 + "还没有取色记录,使用取色器开始" + 取色快捷键提示。 + +### 4.3 顶栏操作 + +| 操作 | 行为 | +|------|------| +| 搜索框 | 按 HEX 片段过滤(大小写不敏感,如 `1A2`);空串 = 全部 | +| 仅收藏过滤 | 切换按钮,与搜索叠加生效 | +| 复制格式切换 | HEX(默认)/ RGB,记住选择 | +| 清空全部 | 二次确认对话框;仅清空 color 类目,不影响其他历史 | + +### 4.4 单条操作 + +| 操作 | 行为 | +|------|------| +| 单击色块 | 按当前复制格式写入剪贴板,色块上出现"已复制"浮标(1s 消失) | +| 右键 / 悬浮菜单 | 复制 HEX / 复制 RGB / 收藏(取消收藏)/ 删除 | +| 键盘 | Tab 网格导航;Enter = 复制;Space = 收藏切换;Delete = 删除;Esc = 清空搜索 | + +### 4.5 与取色器的联动 + +- 取色器完成取色后,窗口若打开则实时插入新条目(置顶,带高亮动画)。 +- 取色器悬浮提示保留"加入历史"现状逻辑不变。 + +## 5. 技术设计 + +### 5.1 macOS + +- 新增 `Features/History/ColorHistoryWindow.swift` + `ColorHistoryView.swift`(SwiftUI)。 +- `HistoryStore` 新增过滤 API:`colorEntries(matching:favoritesOnly:) -> [TranslationHistory]`;`@Published` 驱动实时插入。 +- 复制:`ClipboardService` 现有能力;收藏/删除复用 `HistoryStore.toggleFavorite / removeEntry`。 + +### 5.2 Windows + +- `App/Views/ColorHistoryPage`(WinUI 3):`GridView`(`ItemsRepeater` 或 `GridView`)+ DataTemplate(色块 + HEX TextBlock)。 +- 数据:`HistoryStore`(SQLite, LIKE 检索)同 API 形状 `colorEntries(matching, favoritesOnly)`。 +- 复制反馈:`TeachingTip` 或就地浮层;清空确认用 `ContentDialog`。 +- 无障碍:色块 AutomationPeer 名称 = HEX;键盘路径按 §4.4。 + +### 5.3 共享验收测试向量 + +- HEX 格式化(小写输入 → 大写展示、3 位扩展为 6 位)。 +- 搜索过滤(`1a2b` → `#1A2B3C` 命中)。 +- 容量上限:51 条取色 → 最旧 1 条被清理。 + +## 6. 用户故事与验收 + +**US-CH1** 取色后我在独立窗口看到新条目置顶出现。(打开窗口 → 取色 → 1s 内插入并高亮) +**US-CH2** 单击色块复制 HEX 并有即时反馈。(粘贴到记事本 == 色块 HEX) +**US-CH3** 我能只看收藏的颜色。(过滤后全部带星标) +**US-CH4** 我能按片段搜索颜色。(`1A2` 命中 `#1A2B3C`) +**US-CH5** 清空只清颜色,不动翻译/截图历史。(清空后其他类目条数不变) +**US-CH6** 键盘完整操作路径可达所有功能。(不碰鼠标完成复制/收藏/删除/搜索清空) +**US-CH7** 两平台同一测试脚本逐项通过(共享验收清单)。 + +## 7. 非目标 + +- 不做取色屏幕坐标回放/定位。 +- 不做颜色格式转换器(HSL/CMYK)编辑器。 +- 不做跨设备同步。 + +## 8. 交付与排期 + +- 归属 P2;纳入 PRD US-W26(Windows)与 macOS 侧对位 US,同版本发布(M5 或 macOS 下一 minor 版本)。 +- 两平台共用本 spec 的 §4 交互规格作为验收基线。 diff --git a/tasks/briefs/brief-A-skeleton-core.md b/tasks/briefs/brief-A-skeleton-core.md new file mode 100644 index 0000000..612d129 --- /dev/null +++ b/tasks/briefs/brief-A-skeleton-core.md @@ -0,0 +1,34 @@ +# Brief A — Windows 工程骨架 + Core 可移植层(US-W01 + Core 适配) + +你是 TransFrame Windows 版的实现工程师之一。4 个并行子任务共用同一 PRD;你负责 A:解决方案骨架 + Core 层。 + +## 必读上下文(按序) +1. `tasks/prd-windows-transframe.md` — 总 PRD(§3 选型、§4 架构、§9 US-W01、附录 B 目录结构) +2. `TransFrame/Models/`(swift 模型,schema 源)+ `TransFrame/Services/Translation/VisualLineGrouping.swift`、`LLMTranslationBatching.swift`、`LLMTranslationResponseParser.swift` +3. `TransFrameTests/`(现有测试风格) + +## 交付范围(只做这些,不越界) +在 `windows/` 目录下创建: + +1. `TransFrame.sln` + 三个工程: + - `Core/TransFrame.Core.vcxproj`(静态库, C++20, /W4 /WX, x64+arm64):移植数据模型 —— Settings 模型(键名与 macOS UserDefaults `TransFrame.` 前缀一一对应)、Annotation 11 种、Screenshot/CaptureDocument、OCREngineType、TranslationEngineType(**无 apple 引擎**)、EngineChainItem/EngineModeV2、TranslationScene/SceneEngineBinding、TranslationPromptConfig、TranslationResultBundle/BilingualSegment、TranslationHistory(4 类)、ExportFormat(PNG/JPEG/HEIC)、AppLanguage(10 语言) + - `NativeShell/TransFrame.NativeShell.vcxproj`(静态库,本任务仅建空骨架 + pch,捕获/UIA 留给任务 B) + - `App/TransFrame.App.vcxproj`(WinUI 3 桌面应用:空白窗口 + 打包工程,具体 UI 留给 B/C 后续) + - `Tests/TransFrame.Core.Tests.vcxproj`(Catch2 v3 单测) +2. Core 移植要求: + - JSON 用 nlohmann(vendored 或 vcpkg.json,写明依赖清单与安装命令) + - `VisualLineGrouping.mergeLines` 完整移植 + **与 macOS 测试向量同源**:从 `TransFrameTests` 提取现有向量数据为 `Tests/fixtures/visual-line-grouping.json`(若 swift 测试内嵌向量,复制数值,注明出处) + - `LLMTranslationBatching`/`LLMTranslationResponseParser` 移植 + 单测 + - `TranslationPromptConfig` 占位符解析({source_language}/{target_language}/{text})+ 单测 +3. CI:`.github/workflows/windows-ci.yml` — windows-latest, msbuild Release 双架构, 运行 Catch2 测试 +4. `windows/README.md` — 构建/测试/依赖安装说明 + +## 明确约束 +- 不实现捕获/OCR/翻译网络/托盘(B/C 的范围),但要在 Core 中定义好接口(纯虚 `IOcrEngine`、`ITranslationProvider`、`IHotkeyListener` 等,头文件带文档注释) +- 已裁决决策(PRD 文首):不内置模型、无 FTS5、仅 MSIX、Apple 引擎不存在 +- 所有模型字段与 macOS swift 版语义一致;不确定处标 `// TODO(schema-align)` 并在报告中列出 + +## 完成标准 +- `msbuild Release x64` 与 `arm64` 双绿(本机无 Windows 则以 CI 配置正确 + CMake/MSBuild 工程文件静态审查为完成标准,报告注明 NOT RUN 的部分) +- Catch2 单测全绿(至少覆盖:prompt 解析、视觉行分组、LLM 批量解析、settings JSON 往返) +- 报告:文件清单、接口清单、schema 对齐差异表、未运行项与原因 diff --git a/tasks/briefs/brief-B-capture-shell.md b/tasks/briefs/brief-B-capture-shell.md new file mode 100644 index 0000000..8e5a5f5 --- /dev/null +++ b/tasks/briefs/brief-B-capture-shell.md @@ -0,0 +1,31 @@ +# Brief B — Windows 捕获与热路径 UI 层(US-W02/03/04/05 + 覆盖层/选区) + +你是 TransFrame Windows 版的实现工程师之一。4 个并行子任务共用同一 PRD;你负责 B:屏幕捕获 + 全屏选区覆盖层 + 窗口检测 + 热键 + 托盘。 + +## 必读上下文(按序) +1. `tasks/prd-windows-transframe.md` §3.2 API 映射表、§6.1(FR-01…06)、§6.7(FR-33/34)、§8 性能预算 +2. `docs/specs/window-detection-auto-select.md` — 窗口自动识别的完整交互规格(Windows 版语义一致,API 换用 EnumWindows/DWM) +3. `TransFrame/Features/Capture/`(SwiftUI 参考:SelectionOverlayWindow/SelectionInPlaceToolbar/InPlaceResultsPanel 行为) +4. 任务 A 产出的 `windows/Core/`(模型与接口;若未就绪,按 PRD §4 接口契约先行开发,后续对齐) + +## 交付范围(只做这些,不越界) +在 `windows/NativeShell/`(+ 必要的 App 侧接入点)实现: + +1. **WGC 捕获服务**:`CaptureService`(Windows.Graphics.Capture,per-monitor GraphicsCaptureItem;`IsBorderRequired=false`(contract 15,失败降级);DXGI Duplication 与 GDI BitBlt 回退链);输出统一为 Core 的 `Screenshot`(物理像素 + DPI 元数据) +2. **显示器枚举**:`DisplayMonitor`(EnumDisplayMonitors + GetDpiForMonitor,Per-Monitor V2;带 2s 缓存刷新策略,对齐 macOS DisplayFreshnessPolicy) +3. **窗口检测**:`WindowDetector`(EnumWindows + DwmGetWindowAttribute(DWMWA_EXTENDED_FRAME_BOUNDS/CLOAKED);`windowUnderPoint()` 悬停查询 ≤1ms) +4. **全屏选区覆盖层**:`SelectionOverlay`(WS_POPUP+WS_EX_LAYERED+WS_EX_TOPMOST,跨全部显示器;Direct2D 1.1 + DirectComposition 渲染:40% 变暗、选区挖亮、1px 高亮描边、尺寸徽标、十字准线、窗口高亮(单击=整窗)、拖拽=手动圈选、Esc 取消;120Hz 下绘制路径 ≤8ms) +5. **全局热键**:`HotkeyManager`(RegisterHotKey/WM_HOTKEY ×5;注册失败=冲突上报;运行时重注册生效) +6. **托盘**:`TrayIcon`(Shell_NotifyIcon;左键 MenuFlyout:全屏/区域/翻译/划词/插入/历史/设置/退出占位 + 最近 5 张截图缩略图位) +7. 单元测试(Catch2):窗口检测几何(DWM bounds vs WindowRect 差异用例)、DPI 换算、热键冲突矩阵、显示器缓存策略 + +## 明确约束 +- 不做翻译/OCR/预览窗口/标注(C 与后续任务范围);就地工具栏(FR-05)只做布局骨架不接功能 +- UIA 划词不在本任务(归 C) +- 所有窗口 Per-Monitor V2 DPI 感知(manifest 声明) +- 性能预算硬指标:热键→覆盖层出现 ≤60ms;松开→截图产物 ≤50ms(含 GPU→CPU 一次拷贝) + +## 完成标准 +- 代码可编译(或 CI 绿;本机 macOS 无法编译 Windows 目标时,给出静态审查清单 + NOT RUN 标注) +- 每个服务一个 `docs/windows/*.md` 简要设计说明(API 选择理由 + 回退链) +- 报告:实现清单、与 PRD FR 映射表、已知限制(如 Win10 黄边框降级路径) diff --git a/tasks/briefs/brief-C-translation-services.md b/tasks/briefs/brief-C-translation-services.md new file mode 100644 index 0000000..2306455 --- /dev/null +++ b/tasks/briefs/brief-C-translation-services.md @@ -0,0 +1,29 @@ +# Brief C — Windows 翻译/OCR 服务层(US-W06/07/08/09 + 引擎注册表 + 划词/插入) + +你是 TransFrame Windows 版的实现工程师之一。4 个并行子任务共用同一 PRD;你负责 C:OCR 引擎 + 10 个翻译引擎接入 + V2 链式/对比调度 + 划词与插入。 + +## 必读上下文(按序) +1. `tasks/prd-windows-transframe.md` §6.3(FR-15…17)、§6.4(FR-18…27)、§6.5(FR-28/29)、§3.2(UIA/Credential Manager 映射) +2. Swift 参考实现:`TransFrame/Services/OCREngine*.swift`、`Services/Translation/`(TranslationEngineRegistry/Providers/LLMTranslationProvider/CompatibleTranslationProvider)、`Services/EngineHealthChecker.swift`、`MTranServerEngine.swift`、`Features/TextTranslation/`(TextTranslationFlow/插入流程) +3. 任务 A 的 `windows/Core/` 接口与模型(未就绪则按接口契约先行) + +## 交付范围(只做这些,不越界) +在 `windows/NativeShell/`(服务部分)+ `windows/Core/`(纯逻辑)实现: + +1. **OCR**:`WindowsOcrEngine`(Windows.Media.Ocr;语言包可用性检测 + TextSegment[] 映射:text+归一化 bbox+confidence);`PaddleOcrEngine`(外部进程协议,fast/precise,健康检查缓存);`VlmOcrEngine` 骨架(五 Provider 接口位,HTTP 细节同翻译层复用) +2. **翻译引擎 ×9**(**无 apple**):MTranServer、OpenAI、Claude、Gemini、Ollama、Google、DeepL、Baidu、Custom 兼容(含多实例 UUID)。统一 `ITranslationProvider`;WinHTTP 封装(超时默认 10s、取消 token、错误分类=网络/配额/鉴权/内容) +3. **调度**:`EngineRegistry` + ordered 链(≤5 逐个回落,聚合错误)+ compare 并行(2-4,结果缓存免重译);场景绑定路由(screenshot/text_selection/translate_and_insert) +4. **可用性探测**:`EngineHealthChecker`(绿/红/橙/灰;仅轻量端点不烧配额;缓存 TTL 对齐 macOS) +5. **密钥**:`KeyStore`(Credential Manager CredWrite/CredRead,`TransFrame//`;UI 侧显示 `sk-****last4`) +6. **划词**:`TextExtractor`(UIA TextPattern GetSelection 优先 → 模拟 Ctrl+C 剪贴板回退(保存/恢复原剪贴板));`InsertionService`(UIA 目标重验证 + SendInput Ctrl+V 粘贴回退,重验证失败绝不粘贴) +7. 单元测试:ordered 链回退矩阵(mock provider 注入延迟/失败)、compare 结果缓存、LLM 批量/解析(复用 A 的 fixtures)、UIA 几何(mock)、错误分类映射 + +## 明确约束 +- 不做 UI(设置页/弹窗归后续任务);提供控制台测试入口 `tests/manual/smoke_translation.cpp` 手工验证 +- 已裁决:不内置任何模型 —— Ollama/兼容端点只是 HTTP 接入 +- HTTP 层不依赖 UI 框架,可被 Core 测试直接驱动 + +## 完成标准 +- Catch2 全绿(链调度/探测缓存/KeyStore mock/批量解析) +- 每引擎一个请求/响应样例文档 `docs/windows/engines/.md`(端点、参数、错误码映射表) +- 报告:FR 映射、与 macOS 行为差异点清单(如有,需对齐 PRD §6.12 白名单,超出即报缺陷) diff --git a/tasks/briefs/brief-D-color-history-macos.md b/tasks/briefs/brief-D-color-history-macos.md new file mode 100644 index 0000000..2e3a2a2 --- /dev/null +++ b/tasks/briefs/brief-D-color-history-macos.md @@ -0,0 +1,33 @@ +# Brief D — macOS 取色历史独立窗口(FR-41 macOS 侧,与 Windows 同规格) + +你是 TransFrame macOS 侧的实现工程师。4 个并行子任务共用同一 PRD;你负责 D:独立取色历史窗口(macOS 实现)。 + +## 必读上下文(按序) +1. `docs/specs/color-history-window.md` — **唯一权威交互规格**(§3 数据模型、§4 交互、§5.1 macOS 技术设计、§6 验收) +2. `tasks/prd-windows-transframe.md` FR-41/US-W26(Windows 侧对位,规格同源) +3. 现有实现:`TransFrame/Services/HistoryStore.swift`(addColor 条目约定、entries 发布、收藏/删除)、`TransFrame/Features/History/HistoryView.swift` + `HistoryWindowController.swift`(窗口管理惯例)、`TransFrame/Services/ClipboardService.swift`、`TransFrame/Features/Preview/PreviewToolBar.swift`(eyedropperButton 取色入口)、`TransFrame/Features/MenuBar/MenuBarController.swift`(托盘菜单项惯例) + +## 交付范围(只做这些,不越界) +1. `TransFrame/Features/History/ColorHistoryView.swift`: + - 网格色块(每格 ≥48×48pt,自适应列)+ 等宽 HEX 文本 + - 悬浮 tooltip(HEX/RGB/时间)+ 悬浮操作(复制/收藏/删除);收藏右上角星标常显 + - 空态视图(插图 + 提示 + 取色快捷键) +2. `TransFrame/Features/History/ColorHistoryWindowController.swift`: + - 独立窗口(默认 560×420,记住位置尺寸,深浅色跟随,NSVisualEffectView 侧栏材质) + - 单开复用(重复打开聚焦已有窗口) +3. `HistoryStore` 扩展:`colorEntries(matching: String?, favoritesOnly: Bool) -> [TranslationHistory]`(HEX 片段大小写不敏感过滤);新取色实时置顶插入(窗口打开时高亮动画) +4. 顶栏:搜索框、仅收藏过滤、复制格式切换(HEX 默认/RGB,记住选择)、清空(二次确认,仅 color 类目) +5. 键盘:Tab 网格导航、Enter=复制、Space=收藏、Delete=删除、Esc=清空搜索(spec §4.4) +6. 入口 ×2:MenuBarController 菜单"取色历史"(置于"翻译历史"之后);取色完成悬浮提示"查看历史"链接(若现有取色完成无悬浮提示,则加一个轻量 toast,1.5s 消失) +7. 测试(XCTest,风格对齐现有 TransFrameTests):HEX 格式化(小写→大写、3 位→6 位)、搜索过滤、仅收藏叠加、清空仅影响 color 类目、容量上限清理最旧 +8. 本地化:所有新字符串进 `Localizable.strings`(10 语言至少 en/zh-Hans 全量,其余语言用英文占位 + 注释待翻译) + +## 明确约束 +- 不改 Windows 侧任何文件;不动 history 存储结构(零迁移) +- 复制格式切换与搜索状态持久化用现有 UserDefaults 惯例(`TransFrame.` 前缀新键要列在报告里) +- 遵守仓库 CONTRIBUTING/现有代码风格;Swift 6 并发注解对齐 + +## 完成标准 +- `swift build` 或 Xbuild 工程构建通过;XCTest 新增用例全绿(无法在本机跑则标注 NOT RUN + 命令) +- spec §6 US-CH1…CH6 逐条自验收并在报告中给出结果 +- 报告:文件清单、新增 UserDefaults 键、字符串键清单、与 spec 的偏差(如有必须为 0 或列为待裁决) diff --git a/tasks/prd-windows-transframe.md b/tasks/prd-windows-transframe.md new file mode 100644 index 0000000..a4dc896 --- /dev/null +++ b/tasks/prd-windows-transframe.md @@ -0,0 +1,610 @@ +# PRD: TransFrame for Windows(屏幕翻译工具 · Win11 原生版) + +- **Status**: Draft v1.0 +- **Date**: 2026-11-02 +- **Owner**: TransFrame Team +- **Baseline**: macOS 版 v1.0.4(功能完全对齐,见 §2 功能基线) +- **Reference PRDs**: `tasks/prd-macos-transframe.md`, `tasks/prd-engine-mode-convergence.md`, `docs/specs/window-detection-auto-select.md`, `docs/specs/color-history-window.md` +- **已裁决决策(2026-11-02,适用两平台)**: + 1. 本地翻译只做**引擎接入**(MTranServer/Ollama/兼容端点),不内置、不打包任何模型(LocalTranslate/ONNX 路线取消)。 + 2. 历史检索**不启用 FTS5**,维持 LIKE 查询。 + 3. **不考虑便携版**,仅 MSIX 单一分发通道。 + 4. 取色历史**扩展为独立取色历史窗口**,Windows 与 macOS 同步交付(见 `docs/specs/color-history-window.md`)。 + +--- + +## 1. 概述(Overview) + +TransFrame for Windows 是 macOS 屏幕翻译工具 TransFrame 的 Windows 原生版本。用户通过全局快捷键截取屏幕任意区域(或全屏/窗口),自动 OCR 识别文字,调用本地或云端翻译引擎翻译,以覆盖层、双语对照抽屉或就地替换的形式展示译文;同时提供划词翻译、翻译并插入、标注、置顶贴图、翻译历史、图床上传等完整能力。 + +**三大硬性要求**(本 PRD 的存在理由): + +1. **功能完全一致**:与 macOS v1.0.4 逐特性对齐(§2 基线表 + §6 FR 清单);差异仅在平台能力本身导致的等价替换(§6.12 差异对照表)。 +2. **Win11 标准 UI**:Fluent 2 设计语言 —— Mica 材质、圆角、深浅色模式、Segoe Fluent Icons、Snap Layouts、系统通知、任务栏托盘常驻(§8)。 +3. **原生语言 + 尽可能高性能**:不使用 Electron/Web 壳;渲染走 GPU(Direct2D/DirectComposition),截图走系统级捕获 API,冷启动与常驻内存对标原生工具(§3、§9)。 + +### 1.1 Goals + +- 与 macOS 版**特性集 1:1**(同一份 FR 清单驱动两个平台)。 +- 截图→OCR→翻译→渲染 全链路 P95 延迟预算:热路径本地引擎 ≤ 1.2s,其中捕获 ≤ 50ms、本地 OCR ≤ 300ms(§9)。 +- 常驻内存 ≤ 80MB(托盘态),空闲 CPU 0%,无后台轮询(事件驱动)。 +- 原生 Win11 体验:开机自启动、任务栏托盘、系统通知、深色模式、多显示器/Per-Monitor DPI 感知。 +- 同一份设置/历史/引擎数据模型(schema 与 macOS 对齐),为将来跨平台同步留接口。 + +### 1.2 Non-Goals + +- 不做 Win32 老式 UI 风格的兼容模式。 +- 不做 Windows 10 以下(Win7/8)适配;Win10 21H2 走降级路径(§6.13),非一等公民。 +- 不做移动端(与 macOS 版一致)。 +- 不内置翻译模型训练/微调。 +- V1 不做云同步(历史/设置本地存储;schema 预留)。 + +--- + +## 2. 功能基线(macOS v1.0.4 特性全景 → Windows 对齐表) + +| # | 特性 | macOS 实现 | Windows 对应(详见 FR) | 优先级 | +|---|------|-----------|--------------------------|--------| +| F-01 | 区域截图(拖拽选区) | ScreenCaptureKit + SelectionOverlayWindow | Windows.Graphics.Capture + 全屏层窗口 + D2D 选区 | P0 | +| F-02 | 窗口自动识别高亮(悬停检测 + 单击选窗口) | CGWindowListCopyWindowInfo | EnumWindows + DWMWA_EXTENDED_FRAME_BOUNDS | P0 | +| F-03 | 全屏截图(多显示器菜单) | SCK + DisplaySelector | WGC/DXGI Duplication + 显示器选择菜单 | P0 | +| F-04 | 翻译模式(截图即翻译) | CapturePipeline + AnalysisPipeline | 同管线移植 | P0 | +| F-05 | 就地选区工具栏 | SelectionInPlaceToolbar | D2D 绘制的层窗口工具栏 | P1 | +| F-06 | 就地结果面板 | InPlaceResultsPanel | 同上 | P1 | +| F-07 | 预览窗口(保存/复制/关闭) | PreviewWindow(SwiftUI) | WinUI 3 窗口 | P0 | +| F-08 | 标注:矩形/椭圆/直线/箭头/自由手绘/文字 | AnnotationCanvas | Direct2D 画布 | P0 | +| F-09 | 标注:马赛克/高亮/数字标签/隐私遮挡/气泡 | Annotation.swift 11 种 | Direct2D 画布(11 种全量) | P1 | +| F-10 | 智能打码(VLM 敏感区检测) | performSmartRedaction | VLM Provider 移植 | P2 | +| F-11 | 裁剪 + 撤销/重做(50 步) | CropDimOverlay + undo 栈 | 同 | P0 | +| F-12 | 保存 PNG/JPEG/HEIC + 质量设置 | ImageExporter | WIC 编码器(PNG/JPEG;HEIC 需扩展,见 §6.12) | P0 | +| F-13 | 复制到剪贴板(含标注) | ClipboardService | Win32 剪贴板 CF_DIB/PNG | P0 | +| F-14 | 置顶贴图(多窗口管理、点击穿透切换) | PinnedWindowsManager | WS_EX_TOPMOST + WS_EX_NOACTIVATE 独立 HWND | P1 | +| F-15 | OCR:Apple Vision(本地默认) | Vision framework | **Windows.Media.Ocr**(本地,随语言包) | P0 | +| F-16 | OCR:PaddleOCR(外部,fast/precise) | PaddleOCREngine | 同一外部进程协议移植 | P1 | +| F-17 | VLM 视觉分析:OpenAI/Claude/Gemini/Ollama/PaddleOCR | VLM Providers | HTTP Provider 移植 | P1 | +| F-18 | 翻译引擎 ×10:Apple/MTranServer/OpenAI/Claude/Gemini/Ollama/Google/DeepL/Baidu/自定义兼容 | Providers | 9 个移植 + Apple 引擎的平台替代(§6.12) | P0 | +| F-19 | OpenAI 兼容引擎多实例 | CompatibleConfig(UUID) | 同数据模型 | P1 | +| F-20 | 引擎选择 V2:ordered 有序回退链(≤5) | EngineModeV2.ordered | 同 | P0 | +| F-21 | 引擎选择 V2:compare 并行对比(2-4,免重译切换) | EngineModeV2.compare | 同(并行 HTTP) | P1 | +| F-22 | 引擎真实可用性探测(状态点,不烧配额) | EngineHealthChecker/MTranServerChecker | 同语义 | P1 | +| F-23 | 场景绑定(截图/划词/翻译插入 → 引擎链) | SceneEngineBinding + TranslationScene | 同 | P1 | +| F-24 | 自定义 Prompt(per-engine / per-兼容实例 / per-scene,{source_language}/{target_language}/{text} 占位符) | TranslationPromptConfig | 同 | P1 | +| F-25 | 可视行分组双语对照 | VisualLineGrouping.mergeLines | 纯算法移植 | P0 | +| F-26 | 译文覆盖层渲染(原位替换/下方追加) | OverlayRenderer + TranslationRenderPipeline | D2D 离屏合成 | P0 | +| F-27 | LLM 批量翻译(分段批处理 + 响应解析) | LLMTranslationBatching | 纯算法移植 | P1 | +| F-28 | 划词翻译(弹窗显示结果) | TextTranslationPopup + AX API | **UI Automation TextPattern + 剪贴板回退** | P0 | +| F-29 | 翻译并插入(目标重验证 + 粘贴回退,独立目标语言) | TextInsertionProgressController | UIA 选区重验证 + SendInput 粘贴 | P1 | +| F-30 | 翻译历史(翻译/截图/取色/上传 4 类,搜索/收藏/导出/缩略图) | HistoryStore + HistoryView | SQLite 存储 + WinUI 列表 | P1 | +| F-31 | 图床上传:PicGo/阿里 OSS/腾讯 COS/七牛 Kodo + Markdown 复制 | ImageUploadService | HTTP 客户端移植 | P2 | +| F-32 | 屏幕取色器(吸管 + HEX 历史) | eyedropperButton + color 历史 | GDI/WGC 单像素采样 | P2 | +| F-41 | **独立取色历史窗口**(大色块网格 + HEX/RGB + 复制 + 收藏/删除 + 清空,跨平台同规格) | 新增(与 Windows 同步交付) | WinUI 3 窗口(数据同 history.color 条目) | P2 | +| F-33 | 全局热键 ×5(全屏/区域/翻译/划词/插入,可自定义) | Carbon RegisterEventHotKey | **RegisterHotKey** | P0 | +| F-34 | 托盘常驻 + 菜单(全部功能入口 + 最近 5 张截图) | MenuBarController | Shell_NotifyIcon + WinUI MenuFlyout | P0 | +| F-35 | 设置窗口(通用/快捷键/标注/引擎/多引擎/语言/高级 + prompt 编辑) | Settings 13 个视图 | WinUI 3 NavigationView | P0 | +| F-36 | 密钥安全存储 | Keychain | **Windows Credential Manager / DPAPI** | P0 | +| F-37 | UI 本地化 10 语言(跟随系统) | Localizable.strings ×10 | .resw ×10 | P1 | +| F-38 | 自动更新 | Sparkle appcast | **MSIX + App Installer(.appinstaller)** | P2 | +| F-39 | 引导(首次启动权限/引导页) | Onboarding | 同语义(权限模型不同,§7) | P1 | +| F-40 | 性能埋点管线(各阶段延迟记录) | PerformanceRecorder/Pipelines | ETW/自记录移植 | P1 | + +> P0 = 1.0 发布必需;P1 = 1.0 目标(可 1.1 补);P2 = 1.x 路线图。 + +--- + +## 3. 技术选型(原生语言决策) + +### 3.1 语言与 UI 框架(决策) + +| 层 | 选型 | 理由 | +|----|------|------| +| **核心管线(截图/OCR 调度/翻译调度/覆盖层/标注渲染/热键/托盘)** | **C++20, C++/WinRT** | "尽可能高性能 + 原生语言":零 GC、直接访问 WGC/D2D/DComp/Win32,捕获与渲染热路径无托管开销 | +| **设置/历史/引擎配置 UI** | **WinUI 3(Windows App SDK 1.5+),C++/WinRT 绑定** | "UI 以 Win11 标准方式":Fluent 2、Mica、圆角、深浅色、控件无障碍全部开箱即得;非热路径,XAML 开发效率可接受 | +| **热路径窗口(选区覆盖层/预览画布/置顶贴图/就地工具栏)** | **纯 Win32 HWND + Direct2D 1.1 + DirectComposition** | XAML 不适合每帧重绘的标注画布与全屏覆盖层;D2D/DComp 是 GPU 加速的标准答案 | +| 脚本/CI 辅助 | PowerShell / pwsh | 打包签名、appinstaller 生成 | + +**备选方案与否决理由**(记录决策,不再复议): + +- ~~C# + WinUI 3 全栈~~:更快的开发速度,但违反"原生语言/极致性能"的硬性要求(托管启动 ~150-300ms、GC 停顿在 120fps 标注绘制中可感知)。若后续评估开发产能不足,可降级为"核心 C++ + 设置 C#"混合,数据层接口(§4.2)已按 ABI 稳定设计,允许该切换。 +- ~~Win32 + 自绘 Fluent 控件全量~~:Mica/DWM 圆角可做,但 NavigationView/TextBox 无障碍/输入法/触控全套自绘成本不可接受。 +- ~~Electron/Tauri/Web~~:直接否决(内存 200MB+、非原生)。 + +### 3.2 系统能力映射(macOS API → Windows API 总表) + +| 能力 | macOS | Windows 选型 | 备注 | +|------|-------|--------------|------| +| 屏幕捕获 | ScreenCaptureKit | **Windows.Graphics.Capture**(GraphicsCaptureItem per monitor) | GPU 纹理直达 D2D,零拷贝;Win11 支持关闭黄边框(`IsBorderRequired=false`,contract 15+);GDI `BitBlt` 作为不支持时回退 | +| 全屏连续帧 | —(按需) | DXGI Desktop Duplication(备选) | 仅当 WGC 不可用 | +| 窗口枚举/检测 | CGWindowListCopyWindowInfo | **EnumWindows + DwmGetWindowAttribute(DWMWA_EXTENDED_FRAME_BOUNDS)** + `WindowFromPoint` | 真实可见边界(排除不可见阴影),DWM 层级过滤 cloaked/UWP 挂起窗口(`DwmGetWindowAttribute(DWMWA_CLOAKED)`) | +| 全局热键 | Carbon RegisterEventHotKey | **RegisterHotKey / WM_HOTKEY** | 冲突检测:RegisterHotKey 失败即冲突提示 | +| 划词取文本 | Accessibility AX API | **UI Automation(UIA TextPattern: GetSelection/RangeFromPoint)**;剪贴板回退:发送 Ctrl+C 模拟(可配置,默认开) | UIA 只读不需要管理员;TextPattern 覆盖 Win32/WinUI/WPF/浏览器 | +| 翻译并插入 | AX 设值 + 粘贴回退 | **UIA ValuePattern 设值** + `SendInput` Ctrl+V 粘贴回退 + **目标重验证**(读回选区比对) | 与 macOS 同一套安全语义:先重验证后粘贴 | +| 剪贴板 | NSPasteboard | Win32 Clipboard(CF_DIB + PNG 垃圾格式 + delayed render) | | +| 置顶窗口 | NSWindow level | **WS_EX_TOPMOST / WS_EX_NOACTIVATE / WS_EX_TOOLWINDOW** | 独立 HWND per pin | +| 全屏覆盖层 | NSWindow overlay | **WS_POPUP + WS_EX_LAYERED + WS_EX_TOPMOST + Per-Monitor V2 DPI**,DirectComposition 视觉树 | 选区 UI 载体 | +| 屏幕取色 | CGDisplayCreateImage 像素 | WGC 单帧或 `GetDC+GetPixel`(回退) | | +| OCR | Vision | **Windows.Media.Ocr.OcrEngine**(本地,Bing 离线语言包) | 中文识别质量弱于 Vision/Paddle → 默认引擎策略见 §6.4 | +| 本地翻译(Apple Translation 对位) | Translation framework | **无系统公开 API** → 从默认链移除该槽位,MTranServer 接棒默认。本地能力一律通过外部引擎接入(MTranServer / Ollama / 兼容端点),**不内置任何模型**(决策 1) | 平台无系统翻译 API;已裁决不引入模型运行时 | +| 密钥存储 | Keychain | **Windows Credential Manager(CredWrite/CredRead,TARGET=TransFrame/)**;备选 DPAPI CryptProtectData 加密后落 JSON | | +| 设置存储 | UserDefaults | **JSON 文件**:`%LOCALAPPDATA%\TransFrame\settings.json`(schema 与 macOS Keys 一一对应,前缀 TransFrame.) | 便于跨平台 schema 对齐与迁移 | +| 历史存储 | HistoryStore(JSON) | **SQLite(WAL)**:`%LOCALAPPDATA%\TransFrame\history.db`;含 schema v1 迁移表 | 搜索用 LIKE(决策 2:不启用 FTS5) | +| HTTP 客户端 | URLSession | **WinHTTP**(或 `Windows.Web.Http`);重试/超时/取消语义对齐 URLSession 封装 | | +| 自动更新 | Sparkle appcast | **MSIX + App Installer**:.appinstaller 指向 HTTPS 更新源,检查周期/强制更新策略可配 | 仅 MSIX 单一分发通道(决策 3:不做便携版) | +| 图标/符号 | SF Symbols | **Segoe Fluent Icons** + 自绘 OCR/翻译字形 | | +| 材质 | NSVisualEffectView | **Mica(DWMWA_SYSTEMBACKDROP_TYPE=DWMSBT_MAINWINDOW)**;覆盖层用 Acrylic | | +| 深浅色 | NSAppearance | Registry `AppsUseLightTheme` + `UISettings.ColorValuesChanged` 事件 | | +| 通知 | UserNotifications | **Windows App Notifications(appnotification:)** | | +| 多显示器/DPI | NSScreen + backingScaleFactor | **EnumDisplayMonitors + GetDpiForMonitor(Per-Monitor V2)** | 坐标统一用物理像素,输出时换算 | +| 无障碍 | Accessibility | **UIA AutomationPeer(XAML 自动)+ 自绘控件的 UIA provider** | P1 验收项 | +| 开机自启 | SMLoginItemSetEnabled | **StartupTask(MSIX)** / HKCU Run 键 | | +| 性能埋点 | os_signpost + PerformanceRecorder | **ETW EventTracingLog + 同名 PerformanceRecorder 移植** | 导出 JSON 报告 | + +### 3.3 依赖清单(全部原生/开源,无运行时付费) + +| 组件 | 选择 | 许可 | +|------|------|------| +| Windows SDK | 10.0.26100+(Win11 24H2) | — | +| C++/WinRT | 2.0.230706+ | MIT | +| Windows App SDK | 1.5+ | MIT | +| JSON | nlohmann/json v3.11 | MIT | +| SQLite | 3.45+(仅 history.db,**LIKE 检索,不启用 FTS5**,决策 2) | Public Domain | +| libheif(HEIC 导出) | 1.17+ | LGPL-3(动态链接,或改用 WIC HEIF 扩展探测) | 见 §6.12 | +| 单元测试 | Catch2 v3 / MSVC 自带 | BSL-1.0 | +| 打包 | MSIX + signtool(EV 证书或 Azure Trusted Signing) | — | + +--- + +## 4. 系统架构 + +### 4.1 分层与模块(对齐 macOS feature-based 结构) + +``` +┌────────────────────────────────────────────────────────────────────┐ +│ App 层 │ +│ App.cpp(入口) AppController(生命周期/热键分发/权限) │ +│ Coordinators: CaptureCoordinator / TextTranslationCoordinator / │ +│ HotkeyCoordinator / TrayCoordinator │ +├────────────────────────────────────────────────────────────────────┤ +│ Features(UI 层) │ +│ TrayMenu/ 托盘图标 + MenuFlyout(最近截图 5 张) │ +│ SelectionOverlay/ 全屏选区层窗口(D2D:变暗、选框、尺寸提示、 │ +│ 窗口高亮、十字准线、就地工具栏、就地结果面板) │ +│ Preview/ 预览窗口(WinUI 3 外壳 + D2D 标注画布子 HWND) │ +│ Pinned/ 置顶贴图窗口管理器(多窗口/穿透切换/回收) │ +│ TextTranslation/ 划词弹窗 + 插入进度控制器 │ +│ Settings/ NavigationView 七页签设置 │ +│ History/ 历史窗口(搜索/收藏/导出/缩略图) │ +│ Onboarding/ 首启引导 │ +├────────────────────────────────────────────────────────────────────┤ +│ Services(业务层,可测、无 UI 依赖) │ +│ Capture/ WGC 捕获 + 显示器枚举 + 窗口检测 │ +│ OCR/ OcrEngine 接口:WindowsOcr / PaddleOcr / Vlm │ +│ Translation/ EngineRegistry + 10 Provider + 兼容实例 + │ +│ ordered/compare 调度 + EngineHealthChecker │ +│ Pipelines/ CapturePipeline / AnalysisPipeline / │ +│ TranslationRenderPipeline(含 PerformanceRecorder)│ +│ VisualLineGrouping / LLMTranslationBatching(纯算法,全平台共享) │ +│ Overlay/ OverlayRenderer(D2D 离屏合成) │ +│ Hotkeys/ TextInsertion/ Clipboard/ ImageExport(WIC)/ ImageUpload/ │ +│ ColorPicker/ KeyStore(CredMan)/ SettingsStore(JSON)/ HistoryStore │ +├────────────────────────────────────────────────────────────────────┤ +│ Models(纯数据,schema 与 macOS 一一对应) │ +│ AppSettings / Annotation(11 种) / Screenshot / CaptureDocument / │ +│ OCREngineType / TranslationEngineType / EngineChainItem / │ +│ EngineModeV2 / TranslationScene / SceneEngineBinding / │ +│ TranslationPromptConfig / TranslationResultBundle / BilingualSegment │ +│ / TranslationHistory / ExportFormat / AppLanguage / ... │ +└────────────────────────────────────────────────────────────────────┘ + TransFrameTests(Catch2:模型/算法/管线单测 + PRD 验收测试) +``` + +### 4.2 模块形态与 ABI + +- `Core`(Models + 纯算法 Services)编译为**静态库 `TransFrame.Core.lib`**:无 WinRT UI 依赖,Catch2 直测;未来允许 C# 互操作切换(§3.1 备选)。 +- `NativeShell`(Win32/D2D/WGC/热键/托盘)静态库,仅依赖 Core + Windows SDK。 +- `TransFrame`(WinUI 3 app,C++/WinRT),依赖上两者。 +- 输出:MSIX 包(x64 + arm64)。 + +### 4.3 关键数据流(与 macOS 管线同构) + +``` +热键 → AppController + → CapturePipeline: 权限检查 → 显示器查找(带 2s 缓存策略) → WGC 捕获 → Screenshot + → SelectionOverlay: 窗口检测高亮 / 拖拽选区 → captureRegion + → AnalysisPipeline: OCR(WindowsOcr|Paddle|VLM) → 分段(TextSegment+归一化bbox+confidence) + → TranslationRenderPipeline: VisualLineGrouping 合并视觉行 → + ordered: 链式回退 | compare: 并行(2-4) + → TranslationResultBundle(per-engine EngineResult + BilingualSegment[]) + → 呈现: PreviewResultsPanel(双语抽屉) / OverlayRenderer(覆盖层) / Pinned / History +每阶段经 PerformanceRecorder 计时(operationID 串联),可导出延迟报告。 +``` + +--- + +## 5. 用户与场景 + +(与 macOS 版一致,平台无差异) + +- **U1 玩游戏/看外语文档的普通用户**:快捷键圈屏幕 → 原位看到译文。核心路径延迟敏感。 +- **U2 开发者/研究者**:大量外文文档、报错、技术网页;划词翻译 + 翻译并插入写代码注释。 +- **U3 内容创作者**:截图 + 标注 + 打码 + 图床上传 + 贴图置顶对照。 +- **U4 隐私敏感用户**:只用本地链(Windows OCR + MTranServer/Ollama 本地端点),设置里显式禁用云引擎。 + +--- + +## 6. 功能需求(FR,含验收标准) + +> 验收标准 = TransFrameTests 中可执行测试或可手工复现步骤。P0 缺一不可发布。 + +### 6.1 截图捕获(FR-01…06) + +**FR-01 区域截图(P0)** +- 热键(默认 `Win+Shift+S` 冲突避让 → 默认 **Ctrl+Alt+A**,可自定义)进入全屏选区模式:所有显示器变暗(半透明黑 40%),显示十字准线与实时尺寸徽标。 +- 拖拽绘制矩形,选区内保持原亮度并 1px 高亮描边;松开即捕获。 +- Esc 取消;捕获期间覆盖层接收全部输入(鼠标+键盘)。 +- 多显示器:覆盖层横跨整个虚拟桌面;坐标以物理像素记录,Per-Monitor V2 DPI。 +- 验收:单屏/双屏混合 DPI(100%/150%/200%) 下选区像素与所见一致;松开→预览窗口出现 ≤ 100ms(本地实测,PerformanceRecorder 记录)。 + +**FR-02 窗口自动识别(P0,对齐 window-detection-auto-select spec)** +- 选区模式下鼠标悬停:实时检测光标下最顶层可见窗口,1px 强调色边框高亮 + 淡色填充;单击即整窗捕获。 +- 按下并拖动 → 忽略高亮,进入手动圈选(行为与 FR-01 完全一致)。 +- 高亮随移动平滑切换(≤ 1 帧);桌面空白处只显示十字准线。 +- Win32/UWP(含 cloaked 过滤)/浏览器子窗口均正确;最大化窗口排除阴影边界(DWMWA_EXTENDED_FRAME_BOUNDS)。 +- 验收:Notepad/Chrome/WinUI 应用/UWP 各悬停单击,捕获边界与 DWM 可见边一致;拖拽路径不触发整窗捕获。 + +**FR-03 全屏截图(P0)** +- 热键(默认 Ctrl+Alt+F)全屏捕获;多显示器时弹出显示器选择菜单(含分辨率与"主显示器"标记),单显示器直接捕获。 +- 验收:3 屏混合 DPI,每屏均按原生分辨率捕获。 + +**FR-04 翻译模式(P0)** +- 热键(默认 Ctrl+Alt+T)= 区域截图 + 自动 OCR + 翻译 + 结果呈现,无额外点击。 +- 验收:从热键到译文出现计时(本地 OCR+MTranServer P95 ≤ 1.2s)。 + +**FR-05 就地工具栏(P1)**:选区确认后选区边缘出现工具条(复制/保存/翻译/置顶/取色/取消),D2D 绘制,可鼠标操作,Esc 关闭。 +**FR-06 就地结果面板(P1)**:翻译结果停靠在选区侧边(空间自适应),显示原文/译文对照,可切换引擎结果(compare 模式),可"贴图置顶"。 + +### 6.2 预览与标注(FR-07…12) + +**FR-07 预览窗口(P0)** +- 捕获后打开预览:标题栏(文件名/尺寸)、工具栏、画布、(翻译模式下)结果抽屉。 +- 快捷键:`Enter`/`Ctrl+S` 保存;`Ctrl+C` 复制并关闭;`Esc` 关闭/退出裁剪;`R/1` 矩形、`D/2` 手绘、`A/3` 箭头、`T/4` 文字、`C` 裁剪、`Ctrl+Z` 撤销、`Ctrl+Y`/`Ctrl+Shift+Z` 重做、`Del` 删除选中标注、拖拽文字标注可移动。 +- 窗口支持 Snap Layouts、记住尺寸位置、深浅色跟随。 + +**FR-08/09 标注(P0/P1)** +- 11 种全量:矩形、椭圆、直线、箭头、自由手绘、文字、马赛克、高亮、数字标签、隐私遮挡、气泡。各自支持颜色/线宽/填充/字号(对齐 macOS Annotation 模型的每类型属性集)。 +- 选中/移动/删除单个标注;标注渲染在 D2D 硬件加速画布,笔迹延迟 ≤ 8ms(120Hz 显示器实测)。 +- ⌘-drag 约束等价:Shift+拖拽 = 正方形/正圆/水平垂直线/45° 箭头。 + +**FR-10 智能打码(P2)**:VLM 检测敏感区域(人脸/证件/电话等)批量生成马赛克标注,单次撤销覆盖整批。 +**FR-11 裁剪/撤销(P0)**:裁剪进入覆盖交互,Enter 应用/Esc 取消;裁剪清除标注(与 macOS 行为一致,提示确认);撤销栈 50 步。 +**FR-12 保存与导出(P0)**:格式 PNG/JPEG/HEIC + JPEG/HEIC 质量滑杆;默认位置可配(默认 `图片\屏幕截图`);文件名模板(时间戳);保存对话框/直接保存可配。HEIC:优先走系统 WIC HEIF 编码器(Win11 需装 HEVC 扩展,未装时 UI 明示并回退 PNG/JPEG)。 + +### 6.3 OCR(FR-15…17) + +**FR-15 Windows OCR 引擎(P0)** +- `Windows.Media.Ocr`:本地、离线、按已安装语言包自动可用;结果映射为 `TextSegment[]`(text + 归一化 bbox + confidence)。 +- 语言包缺失时给出安装引导(ms-settings:regionlanguage);中文包未装时状态点为灰。 +- 验收:中英混合截图段落级识别,bbox 归一化坐标与 macOS 版同 schema。 + +**FR-16 PaddleOCR 外部引擎(P1)** +- 与 macOS 相同的外部进程协议(可执行路径 + fast(~1s)/precise(~12s) 两档);健康检查缓存语义一致。 +**FR-17 VLM OCR/分析(P1)** +- OpenAI/Claude/Gemini/Ollama/PaddleOCR-VL 五个 Provider 移植:图像 base64/URL 上传、分段解析(bbox+confidence)、错误分类。 + +### 6.4 翻译引擎(FR-18…27) + +**FR-18 引擎集(P0)** +- 移植 9 个:MTranServer、OpenAI、Claude、Gemini、Ollama、Google、DeepL、Baidu、自定义 OpenAI 兼容(含无密钥本地端点)。 +- Apple Translation 无 Windows 对应:**默认有序链调整为 `MTranServer → WindowsOCR 场景下的次选`**;"本地翻译"能力全部通过外部引擎接入(MTranServer/Ollama/兼容端点),**不内置模型**(决策 1,详见 §6.12)。 +- 每引擎配置卡片:开关、密钥(Credential Manager)、端点/模型、超时(默认 10s)、测试连接。 + +**FR-19 兼容引擎多实例(P1)**:OpenAI 兼容端点可建多实例(UUID 标识),链/对比/场景绑定中以实例身份出现。 + +**FR-20 ordered 有序回退链(P0)**:≤5 个引擎按序尝试,单个失败自动落入下一个;每个引擎结果带延迟;整链失败输出聚合错误(per-engine 摘要,对齐 TextTranslationError 聚合行为)。 +**FR-21 compare 并行对比(P1)**:2-4 引擎并行请求;结果侧栏同时呈现,点击切换不重发请求(缓存 per-engine EngineResult)。 +**FR-22 可用性探测(P1)**:设置页引擎状态点(绿=可用/红=不可达/橙=慢/灰=未配置);探测仅用轻量端点(如 MTranServer ping、LLM models 列表),**绝不调用计费翻译接口**;结果缓存 TTL 与 macOS 一致。 +**FR-23 场景绑定(P1)**:screenshot / text_selection / translate_and_insert 三场景可各自绑定 ordered 链或 compare 集;未绑定时用全局链。 +**FR-24 自定义 Prompt(P1)**:per-engine / per-兼容实例 / per-scene 三层覆盖;默认模板含 `{source_language}` `{target_language}` `{text}` 占位符;插入场景有专用默认 prompt(简洁、无格式)。 +**FR-25 视觉行分组(P0)**:`VisualLineGrouping.mergeLines` 纯算法移植:同一视觉行的碎片合并为一个翻译单元与一个覆盖层锚点。验收:移植 macOS 同套测试向量(跨平台共享测试数据 JSON)。 +**FR-26 覆盖层渲染(P0)**:原位替换(按背景色自适应文字色)与下方追加两种模式;D2D 离屏渲染后合成回截图;导出/贴图/复制均带覆盖层。 +**FR-27 LLM 批量翻译(P1)**:分段批处理(编号分隔)+ 响应解析器移植(处理截断/乱序/多行),失败自动降级为逐段。 + +### 6.5 划词与插入(FR-28/29) + +**FR-28 划词翻译(P0)** +- 热键(默认 Ctrl+Alt+D)→ 优先 UIA TextPattern 取当前焦点控件选区文本;不支持 UIA 的应用回退"模拟 Ctrl+C 读剪贴板"(设置可关,且回退前保存/恢复原剪贴板内容)。 +- 结果弹窗:无焦点抢占(WS_EX_NOACTIVATE),原文/译文/引擎延迟/重译按钮/copy/收藏;点击他处自动关闭。 +- 验收:记事本/Word/Chrome/Edge/WinUI 应用/终端 各验证 UIA 路径;剪贴板回退路径验证原内容恢复。 + +**FR-29 翻译并插入(P1)** +- 热键(默认 Ctrl+Alt+I)→ 取选中原文 → 翻译(独立目标语言设置)→ **目标重验证**(UIA 读回当前选区仍为原文,未变则继续)→ 粘贴回退(SendInput Ctrl+V);重验证失败则中止并提示,绝不覆盖意外内容。 +- 插入进度浮层(进行中/完成/失败三态);全程不与输入法冲突(对齐 macOS 语义:粘贴而非直接设值优先)。 + +### 6.6 历史 / 图床 / 取色(FR-30…32) + +**FR-30 翻译历史(P1)**:4 类条目(translation/screenshot/color/upload);字段与 macOS TranslationHistory 一致;搜索(原文/译文)、收藏、删除、导出(JSON/CSV/TXT)、缩略图(截图类)、最近 5 张截图入口在托盘菜单;容量上限与自动清理可配。 +**FR-31 图床上传(P2)**:PicGo(本地 HTTP)/阿里 OSS/腾讯 COS/七牛 Kodo 四通道 + 配置卡片 + 上传后复制(URL 或 Markdown 可选);上传记录入 history。 +**FR-32 屏幕取色器(P2)**:放大镜取色(WGC 单帧采样),HEX 显示、加入历史(color 类条目)、点击复制。 + +**FR-41 独立取色历史窗口(P2,两平台同步交付,见 `docs/specs/color-history-window.md`)** +- 独立窗口(非弹层),从托盘菜单与取色器入口打开;网格色块(≥48px)+ HEX/RGB 文本 + 取色时间。 +- 操作:单击复制 HEX;右键/悬浮菜单收藏、删除;顶栏搜索(HEX 片段)+ 仅收藏过滤 + 清空全部(带确认);复制成功即时反馈。 +- 数据:复用 history `color` 类目条目(不另建存储);条目上限/自动清理沿用历史设置。 +- 验收:取色 → 打开窗口看到条目;收藏过滤、搜索、删除、清空各路径;两平台同一交互规格。 + +### 6.7 壳与系统(FR-33…40) + +**FR-33 全局热键(P0)**:5 组热键(全屏/区域/翻译/划词/插入)RegisterHotKey 注册;冲突时注册失败→设置页标红 + 托盘气泡提示;改后即时生效无需重启;快捷键录制控件(键+修饰键,必须含至少一个修饰键,校验规则与 macOS 版一致)。 +**FR-34 托盘(P0)**:常驻托盘图标(截图镜头),左键弹 MenuFlyout:全屏/区域/翻译/划词/插入/置顶管理/历史/设置/检查更新/退出 + 最近截图(5 张缩略图);托盘图标不占任务栏。 +**FR-35 设置窗口(P0)**:NavigationView 七页:通用(语言/保存/格式/质量/开机自启/更新检查)、快捷键、标注默认样式、引擎(10 卡片+兼容实例管理)、多引擎(ordered 链编辑器/compare 编辑器/场景绑定/prompt 编辑)、语言(源/目标/插入独立目标/界面语言)、高级(日志/性能报告/数据目录/重置)。 +**FR-36 密钥安全(P0)**:所有 API Key 存 Credential Manager(`TransFrame//`),明文不落 settings.json;UI 显示为 `sk-****last4`;导出配置不含密钥。 +**FR-37 本地化(P1)**:10 语言 .resw(en/zh-Hans/de/es/fr/it/ja/ko/pt/ru)+ 跟随系统 + 手动覆盖;日期数字格式随区域。 +**FR-38 自动更新(P2)**:MSIX + .appinstaller(HTTPS 源、版本比较、可选强制);仅 MSIX 单一分发通道(决策 3,无便携版)。 +**FR-39 首启引导(P1)**:3 步引导(热键介绍 → 隐私声明:哪些引擎联网 → 默认链选择);无 macOS 权限弹窗(Windows 无屏幕录制权限概念,UIA 只读无需授权)。 +**FR-40 性能埋点(P1)**:PerformanceRecorder 移植,阶段=permission/displayLookup/capture/ocr/translation/render;operationID 串联全链路;设置页可导出 JSON 报告。 + +### 6.8 Win11 UI/UX 规范(FR-50 组) + +- **FR-50.1(P0)Mica 材质**:主设置/历史/预览窗口 `DWMWA_SYSTEMBACKDROP_TYPE=DWMSBT_MAINWINDOW`;选区覆盖层/弹窗用 Acrylic(`DWMSBT_TRANSIENTWINDOW`)。 +- **FR-50.2(P0)圆角**:窗口 DWM 自动圆角;自绘弹层 8px 圆角。 +- **FR-50.3(P0)深浅色**:跟随系统(含"自动/浅/深"三态覆盖);所有自绘内容双主题色板。 +- **FR-50.4(P0)Snap Layouts**:预览/历史/设置窗口支持 Win11 贴靠(标准 Win32 即得,验收确认)。 +- **FR-50.5(P1)Segoe Fluent Icons**:全部图标走 Segoe Fluent Icons / Segoe MDL2 fallback;小图标对齐 16/20/24px 网格。 +- **FR-50.6(P1)无障碍**:XAML 控件 UIA 自动暴露;自绘工具栏/画布实现 UIA Provider(名称/角色/可用性);完整键盘操作路径;对比度 ≥ 4.5:1。 +- **FR-50.7(P1)系统通知**:保存/上传/更新完成用 Windows 通知,失败用对话框。 +- **FR-50.8(P1)高刷新率**:标注画布 DComp 垂直同步,120Hz+ 无撕裂。 +- **FR-50.9(P2)动画**:面板展开、弹窗淡入等用 Composition 动画(Implicit Animations),关闭可在设置禁用(减少动效)。 + +### 6.9 数据模型与迁移(FR-60) + +- settings.json schema 与 macOS UserDefaults 键一一对应(`TransFrame.` 前缀保留);Windows 专属键加 `.win` 后缀命名空间。 +- 历史库 schema v1:`entries(id, category, source_text, translated_text, source_lang, target_lang, timestamp, thumbnail_path, is_favorite, meta_json)` + `schema_version` 表。 +- 验收:两平台同一截图输入 → 输出的 BilingualSegment/EngineResult JSON 逐字段等值(跨平台快照测试)。 + +### 6.10 安全与隐私(FR-61) + +- 明确的网络出口白名单(按引擎配置动态);设置页"隐私"面板列出:本地处理 vs 联网引擎清单。 +- 密钥仅 Credential Manager;崩溃日志(可选开启)不含密钥/剪贴板内容。 +- MSIX 签名(Azure Trusted Signing 或 EV 证书);SmartScreen 信誉积累。 + +### 6.11 可靠性(FR-62) + +- 引擎请求全部可取消(WinHTTP + cancel token);全局"取消"Esc 传播。 +- 单引擎崩溃/超时不拖垮链(ordered 语义);OCR/翻译异常都有用户可读错误 + 重试。 +- 崩溃时未保存的截图/标注在下次启动可恢复(session 文件 `%LOCALAPPDATA%\TransFrame\session\`)。 + +### 6.12 平台差异对照表(唯一允许的行为差异) + +| 差异点 | macOS | Windows 处理 | 理由 | +|--------|-------|--------------|------| +| Apple Translation | 系统内置本地翻译 | 移除该引擎,默认链首改为 MTranServer(若不可达按链回落);本地能力一律外部引擎接入(MTranServer/Ollama/兼容端点),不内置模型(决策 1) | Windows 无公开系统翻译 API | +| Apple Vision OCR | 默认引擎 | Windows.Media.Ocr 为默认;中文质量不足场景由 PaddleOCR/VLM 补 | 平台 OCR 能力差异 | +| HEIC 导出 | 系统原生 | WIC HEIF(需 HEVC 扩展)探测,未装时 UI 提示并回退 | 编解码器分发差异 | +| Sparkle 更新 | appcast | MSIX/App Installer | 平台标准 | +| 屏幕录制权限 | 系统授权弹窗 | 无权限概念(WGC 首次出现单次系统确认条) | 平台安全模型 | +| 辅助功能权限 | Accessibility 授权 | UIA 只读无需授权 | 平台安全模型 | +| 默认快捷键 | Cmd 系 | Ctrl+Alt 系(Win+Shift+S 留给系统截图) | 键位布局差异 | +| 触控栏/焦点行为 | NSWindow | WS_EX_NOACTIVATE 等价实现 | 窗口模型差异 | +| 全局快捷键实现 | Carbon | RegisterHotKey(系统级,不吃焦点) | — | + +### 6.13 支持矩阵 + +| 场景 | Win11 22H2+ (22621) | Win10 21H2 (19044) | +|------|---------------------|--------------------| +| WGC 捕获(无边框) | ✅ 完整 | ⚠️ 黄边框保留(系统限制) | +| Mica/Acrylic | ✅ | ⚠️ 回退纯色 | +| Snap Layouts | ✅ | ❌(标准贴靠) | +| UIA 划词 | ✅ | ✅ | +| 支持级别 | 一等公民 | 降级支持,不阻塞发布验收 | + +最低:Windows 10 21H2;目标:Windows 11 24H2。x64 + arm64 双架构。 + +--- + +## 7. 权限与首启流程 + +1. 首次触发截图:WGC 在系统级出现一次"TransFrame 开始捕获"确认(系统行为,非应用弹窗);之后静默。 +2. 划词:UIA 只读零权限;"剪贴板回退"模式首次使用时提示一次。 +3. 首启引导三步(FR-39)后直接可用,**无需重启**(对比 macOS 的屏幕录制重启)。 + +--- + +## 8. 性能预算(NFR) + +| 指标 | 预算 | 测量方式(PerformanceRecorder/ETW) | +|------|------|--------------------------------------| +| 热键→选区覆盖层出现 | ≤ 60ms | ETW 事件对 | +| 松开选区→预览窗口首帧 | ≤ 100ms | recorder | +| WGC 捕获 4K 全屏 | ≤ 50ms(GPU→CPU 一次拷贝) | recorder | +| 本地 OCR(1080p 选区) | ≤ 300ms P95 | recorder | +| 本地链翻译(MTranServer) | ≤ 500ms P95 | recorder | +| **端到端(热键→译文覆盖层,本地链)** | **≤ 1.2s P95** | 全链 operationID | +| 标注笔迹输入延迟 | ≤ 8ms(120Hz) | 帧时间戳 | +| 常驻内存(托盘态) | ≤ 80MB 工作集 | 性能监视器 | +| 冷启动(托盘就绪) | ≤ 800ms | 事件对 | +| 空闲 CPU | 0%(无轮询,事件驱动) | 性能监视器 | +| 安装包体积 | ≤ 25MB(arm64+x64 合包) | 构建产物 | + +验收:以上每项写入 `TransFrameTests/perf/` 基准,CI 记录趋势,超预算 20% 报警。 + +--- + +## 9. 用户故事(US,映射 FR;格式对齐 macOS PRD) + +> Quality Gates(每个 US 完成的定义):`msbuild /p:Configuration=Release` 零警告(/W4 /WX 于 Core)、Catch2 全绿、swiftlint 对应物 = clang-format 检查通过、MSIX 打包成功、x64+arm64 双架构构建。 + +### US-W01: 工程初始化与托盘骨架 +As a developer, I want the WinUI 3 + C++20 solution skeleton so features build on a solid base. +- [ ] 解决方案三分层(Core/NativeShell/App)+ Catch2 测试工程 +- [ ] 托盘图标 + MenuFlyout(全屏/区域/翻译/划词/插入/历史/设置/退出占位项) +- [ ] MSIX 打包 + 签名脚本;x64/arm64 CI +- [ ] 设置/历史目录 `%LOCALAPPDATA%\TransFrame\` 初始化 + +### US-W02: 全局热键 +(FR-33)RegisterHotKey ×5,可配置、冲突提示、即时生效、Esc 取消传播。 + +### US-W03: 区域截图 + 全屏覆盖层 +(FR-01)全屏变暗、拖拽、尺寸徽标、Esc 取消、多显示器、DPI、WGC 捕获 → Screenshot 模型。 + +### US-W04: 窗口自动识别 +(FR-02)EnumWindows/DWM 检测、悬停高亮、单击整窗、拖拽忽略,性能 ≤1 帧切换。 + +### US-W05: 全屏截图与显示器选择 +(FR-03) + +### US-W06: Windows OCR 引擎 +(FR-15)Windows.Media.Ocr → TextSegment[]、语言包检测与引导、异步不阻塞 UI。 + +### US-W07: MTranServer 翻译引擎 +(FR-18)HTTP 客户端(超时 10s、取消、错误分类)、自动语言检测、目标语言配置。 + +### US-W08: 翻译引擎全家(LLM/云) +(FR-18)OpenAI/Claude/Gemini/Ollama/Google/DeepL/Baidu/自定义 ×9 Provider + 密钥卡 + 测试连接。 + +### US-W09: ordered 有序回退链 +(FR-20)≤5 链、逐个回落、聚合错误、per-engine 延迟显示。 + +### US-W10: 预览窗口与保存/复制 +(FR-07/12)WinUI 外壳 + 画布、Enter 保存、Ctrl+C 复制、格式与质量、位置记忆。 + +### US-W11: 标注工具集(11 种) +(FR-08/09)D2D 画布、选中/移动/删除、Shift 约束、撤销重做 50 步、深浅色。 + +### US-W12: 裁剪 +(FR-11) + +### US-W13: 视觉行分组与双语抽屉 +(FR-25 + PreviewResultsPanel 对位)合并行、原文/译文对照、可编辑原文重译。 + +### US-W14: 覆盖层渲染 +(FR-26)原位替换/下方追加、自适应文字色、合成导出。 + +### US-W15: compare 并行对比 +(FR-21)2-4 并行、免重译切换、延迟徽标。 + +### US-W16: 划词翻译 +(FR-28)UIA TextPattern + 剪贴板回退 + 无焦点弹窗 + 重译/复制/收藏。 + +### US-W17: 翻译并插入 +(FR-29)目标重验证 + 粘贴回退 + 独立目标语言 + 进度浮层。 + +### US-W18: PaddleOCR 外部引擎 +(FR-16)路径配置、fast/precise、健康检查。 + +### US-W19: VLM 视觉分析 +(FR-17)五 Provider、bbox 解析、智能打码(FR-10)。 + +### US-W20: 兼容引擎多实例 +(FR-19)UUID 实例、链/对比/绑定引用。 + +### US-W21: 引擎健康探测 + 场景绑定 + Prompt +(FR-22/23/24) + +### US-W22: 设置窗口七页签 +(FR-35)含 ordered/compare 拖拽编辑器、快捷键录制、语言页。 + +### US-W23: 翻译历史 +(FR-30)SQLite、4 类、搜索/收藏/导出、托盘最近截图。 + +### US-W24: 置顶贴图 +(FR-14)多窗口、穿透切换(对齐 macOS"禁用点击穿透/恢复交互"语义)、聚拢到前台。 + +### US-W25: 图床上传 +(FR-31)四通道 + Markdown 复制。 + +### US-W26: 屏幕取色器 + 独立取色历史窗口 +(FR-32/FR-41)取色器落地;取色历史独立窗口(两平台同规格,与 macOS 侧 `ColorHistoryWindow` US 同步验收)。 + +### US-W27: 本地化 10 语言 +(FR-37) + +### US-W28: 自动更新 +(FR-38).appinstaller 通道(仅 MSIX,无便携版,决策 3)。 + +### US-W29: 性能埋点与基准 +(FR-40 + §8 全部指标进 CI)。 + +### US-W30: 首启引导 + 无障碍 + 打磨 +(FR-39/50.6)三步引导、UIA Provider、键盘路径。 + +--- + +## 10. 里程碑 + +| 里程碑 | 范围(US) | 出口条件 | +|--------|-----------|----------| +| **M1 骨架**(2 周) | W01, W02 | 托盘+热键可用;MSIX CI 双架构绿 | +| **M2 捕获闭环**(3 周) | W03, W04, W05, W10 | 截图→预览→保存/复制全链路(无翻译);性能预算前 4 项达标 | +| **M3 翻译闭环**(3 周) | W06, W07, W08, W09, W13, W14 | 端到端 ≤1.2s P95(本地链);双语抽屉+覆盖层 | +| **M4 完整功能**(4 周) | W11, W12, W15–W21, W22, W24 | 特性集 = macOS P0+P1 全勾 | +| **M5 打磨发布**(2 周) | W23, W25–W30 | P2 项按取舍;无障碍+本地化+更新通道;公开 Beta | + +总计 ~14 周一名资深 C++ 工程师 + 0.5 名设计/测试支持。 + +--- + +## 11. 测试与质量门禁 + +- **单元**(Catch2, Core 层):模型、VisualLineGrouping、LLMTranslationBatching、Prompt 解析、链调度(mock provider)、设置 schema 往返。 +- **跨平台快照**:共享测试向量 JSON(与 macOS TransFrameTests 同源)保证两平台同输入同输出。 +- **集成**:WGC 捕获(多 DPI)、UIA 划词(目标应用矩阵:Notepad/Word/Chrome/Edge/WinUI/终端)、热键冲突、Credential Manager 读写。 +- **性能**:§8 全指标基准化,CI 趋势门禁(超 20% fail)。 +- **UI**:WinUI 控件手测清单 + 截图对比(深浅色 ×10 语言抽样 3 语言)。 +- **打包**:干净 Win11 VM 安装→热键全流程冒烟;Win10 21H2 降级矩阵冒烟。 + +--- + +## 12. 风险与缓解 + +| 风险 | 等级 | 缓解 | +|------|------|------| +| C++/WinRT + WinUI 3 开发效率低于预期 | 高 | §3.1 备选:设置层切 C#(ABI 已隔离);里程碑 M2 末做 Go/No-Go 评审 | +| Windows OCR 中文质量不达用户预期 | 中 | 默认链文档化推荐 PaddleOCR;VLM 补充;设置页引导安装中文语言包 | +| 无 Apple Translation 对位造成"无默认可用引擎" | 中 | 首启引导第 3 步强制选默认链(MTranServer/云引擎/Ollama 外部接入,不内置模型,决策 1) | +| UIA 在旧 Win32 应用上 TextPattern 缺失 | 中 | 剪贴板回退 + 回退开关;目标应用矩阵持续维护 | +| WGC 黄边框(Win10)观感差 | 低 | 文档明示 Win11 体验最佳;Win10 保留边框并提示 | +| MSIX 签名与 SmartScreen 信誉 | 中 | Azure Trusted Signing 起步;发布说明引导 | +| 120Hz 笔迹延迟不达标 | 低 | DComp 独立层 + 预渲染笔迹缓存;预算 8ms 有 50% 余量 | +| arm64 设备驱动级 API 差异 | 低 | 双架构 CI 全量测试;WGC/D2D 均有 arm64 原生支持 | + +--- + +## 13. 开放问题(Open Questions) + +1. ~~LocalTranslate(ONNX+DirectML)进 1.x 的验收标准~~ → **已裁决:不内置任何模型**,本地能力仅做外部引擎接入(决策 1)。 +2. ~~历史库是否启用 FTS5~~ → **已裁决:不启用,维持 LIKE**(决策 2)。 +3. ~~便携版(portable zip)是否进 1.0~~ → **已裁决:仅 MSIX**(决策 3)。 +4. ~~取色器是否扩展为独立取色历史窗口~~ → **已裁决:扩展为独立窗口,两平台同步交付**(决策 4,规格见 `docs/specs/color-history-window.md`)。 + +--- + +## 附录 A:默认快捷键(Windows) + +| 动作 | 默认 | macOS 对照 | +|------|------|-----------| +| 区域截图 | Ctrl+Alt+A | Cmd+Shift+4 | +| 全屏截图 | Ctrl+Alt+F | Cmd+Shift+3 | +| 翻译模式 | Ctrl+Alt+T | Cmd+Shift+T | +| 划词翻译 | Ctrl+Alt+D | Cmd+Shift+Y | +| 翻译并插入 | Ctrl+Alt+I | Cmd+Shift+I | + +## 附录 B:目录结构(目标态) + +``` +windows/ +├── TransFrame.sln +├── Core/ # TransFrame.Core(模型+纯算法,平台无关) +├── NativeShell/ # Win32/D2D/WGC/热键/托盘/UIA 静态库 +├── App/ # WinUI 3 应用(C++/WinRT) +├── Tests/ # Catch2 单测 + 跨平台快照 + perf 基准 +├── Installer/ # MSIX 打包 + .appinstaller + 签名 +└── docs/ # 平台补充文档 +``` + +## 附录 C:验收快照(发布前勾选) + +- [ ] §2 基线表 P0/P1 全绿(差异仅 §6.12 列出项) +- [ ] §8 性能预算全达标(CI 报告链接) +- [ ] 双架构 + 双 OS(Win11/Win10 降级)冒烟通过 +- [ ] 10 语言截图审校(en/zh-Hans/ja/de 抽查全量,其余 3 页关键屏) +- [ ] 无障碍清单(键盘全路径 + 对比度 + UIA 检查器验证) +- [ ] 隐私面板内容与实际网络行为一致(抓包审计) From 7d9dc7b6c89f69a6c048f97d7c828768d95244ea Mon Sep 17 00:00:00 2001 From: hubo Date: Mon, 2 Nov 2026 03:22:30 +0800 Subject: [PATCH 02/40] =?UTF-8?q?feat(windows):=20capture=20shell=20layer?= =?UTF-8?q?=20=E2=80=94=20WGC/DXGI/GDI=20chain,=20overlay,=20window=20dete?= =?UTF-8?q?ct,=20hotkeys,=20tray=20(task=20B)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - CaptureService: WGC -> DXGI Desktop Duplication -> GDI BitBlt fallback chain, unified Core Screenshot output (physical px + DPI metadata), IsBorderRequired=false gated on UniversalApiContract 15 (Win10 yellow border documented degradation) - DisplayMonitor: EnumDisplayMonitors + GetDpiForMonitor (Per-Monitor V2), 2s cache refresh policy mirroring macOS DisplayFreshnessPolicy - WindowDetector: EnumWindows + DWMWA_EXTENDED_FRAME_BOUNDS/CLOAKED with mouse-down snapshot cache (hover hit-test pure memory), FR-02 click vs 4px drag threshold semantics - SelectionOverlay: WS_POPUP+LAYERED+TOPMOST virtual-desktop window, D2D 1.1 + DComp rendering (40% dim, punch-through, 1px accent stroke, size badge, crosshair, window highlight), precreated for <=60ms hotkey path; portable MT-safe paint-list state machine - HotkeyManager: RegisterHotKey/WM_HOTKEY x5 (Ctrl+Alt+F/A/T/D/I defaults), conflict reporting, runtime re-registration - TrayIcon: Shell_NotifyIcon + menu model with recent-5 screenshot slots - Catch2 v3.7.1 vendored; 60 test cases / 235 assertions green (geometry, DPI, cache policy, conflict matrix, fallback chain, overlay state machine, tray menu) - PerMonitorV2 app.manifest; vcxproj (x64+ARM64, /W4 /WX) + CMake; per-service design docs in windows/docs/windows/ Windows build verification NOT RUN (macOS dev box); reproduce with msbuild windows/TransFrame.sln or cmake -S windows/NativeShell. Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com> --- tasks/briefs/report-B.md | 125 + windows/NativeShell/CMakeLists.txt | 101 + .../TransFrame.NativeShell.Tests.vcxproj | 73 + .../TransFrame.NativeShell.vcxproj | 125 + windows/NativeShell/app.manifest | 23 + .../NativeShell/include/tf/CaptureService.hpp | 105 + windows/NativeShell/include/tf/CoreTypes.hpp | 88 + .../NativeShell/include/tf/DisplayMonitor.hpp | 80 + windows/NativeShell/include/tf/Geo.hpp | 71 + .../NativeShell/include/tf/HotkeyManager.hpp | 107 + .../include/tf/OverlayRenderer.hpp | 107 + .../include/tf/SelectionOverlay.hpp | 66 + windows/NativeShell/include/tf/TrayIcon.hpp | 88 + .../NativeShell/include/tf/WindowDetector.hpp | 87 + windows/NativeShell/src/CaptureService.cpp | 94 + windows/NativeShell/src/DisplayMonitor.cpp | 48 + .../NativeShell/src/DisplayMonitorWin32.cpp | 73 + .../NativeShell/src/DxgiDuplicationEngine.cpp | 25 + windows/NativeShell/src/GdiCaptureEngine.cpp | 19 + windows/NativeShell/src/HotkeyManager.cpp | 122 + .../NativeShell/src/HotkeyManagerWin32.cpp | 32 + windows/NativeShell/src/NativeShellInit.cpp | 47 + windows/NativeShell/src/OverlayRenderer.cpp | 204 + windows/NativeShell/src/SelectionOverlay.cpp | 388 + windows/NativeShell/src/TrayIcon.cpp | 98 + windows/NativeShell/src/TrayMenu.cpp | 43 + windows/NativeShell/src/WGCCaptureEngine.cpp | 49 + .../NativeShell/src/WGCCaptureEngineFull.cpp | 98 + windows/NativeShell/src/WindowDetector.cpp | 44 + .../NativeShell/src/WindowDetectorWin32.cpp | 142 + windows/NativeShell/src/pch.cpp | 2 + windows/NativeShell/src/pch.h | 36 + .../NativeShell/tests/CaptureServiceTests.cpp | 226 + .../NativeShell/tests/DisplayMonitorTests.cpp | 135 + windows/NativeShell/tests/DpiScalingTests.cpp | 57 + windows/NativeShell/tests/GeoTests.cpp | 32 + .../NativeShell/tests/HotkeyManagerTests.cpp | 196 + .../tests/OverlayRendererTests.cpp | 176 + windows/NativeShell/tests/TestMain.cpp | 3 + windows/NativeShell/tests/TrayMenuTests.cpp | 102 + .../NativeShell/tests/WindowDetectorTests.cpp | 123 + .../NativeShell/tests/catch_amalgamated.cpp | 11811 ++++++++ .../NativeShell/tests/catch_amalgamated.hpp | 14106 +++++++++ windows/NativeShell/vendor/nlohmann_json.hpp | 24765 ++++++++++++++++ windows/docs/windows/CaptureService.md | 65 + windows/docs/windows/DisplayMonitor.md | 38 + windows/docs/windows/HotkeyTray.md | 58 + windows/docs/windows/NativeShell-Tests.md | 52 + windows/docs/windows/SelectionOverlay.md | 73 + windows/docs/windows/WindowDetector.md | 51 + 50 files changed, 54879 insertions(+) create mode 100644 tasks/briefs/report-B.md create mode 100644 windows/NativeShell/CMakeLists.txt create mode 100644 windows/NativeShell/TransFrame.NativeShell.Tests.vcxproj create mode 100644 windows/NativeShell/TransFrame.NativeShell.vcxproj create mode 100644 windows/NativeShell/app.manifest create mode 100644 windows/NativeShell/include/tf/CaptureService.hpp create mode 100644 windows/NativeShell/include/tf/CoreTypes.hpp create mode 100644 windows/NativeShell/include/tf/DisplayMonitor.hpp create mode 100644 windows/NativeShell/include/tf/Geo.hpp create mode 100644 windows/NativeShell/include/tf/HotkeyManager.hpp create mode 100644 windows/NativeShell/include/tf/OverlayRenderer.hpp create mode 100644 windows/NativeShell/include/tf/SelectionOverlay.hpp create mode 100644 windows/NativeShell/include/tf/TrayIcon.hpp create mode 100644 windows/NativeShell/include/tf/WindowDetector.hpp create mode 100644 windows/NativeShell/src/CaptureService.cpp create mode 100644 windows/NativeShell/src/DisplayMonitor.cpp create mode 100644 windows/NativeShell/src/DisplayMonitorWin32.cpp create mode 100644 windows/NativeShell/src/DxgiDuplicationEngine.cpp create mode 100644 windows/NativeShell/src/GdiCaptureEngine.cpp create mode 100644 windows/NativeShell/src/HotkeyManager.cpp create mode 100644 windows/NativeShell/src/HotkeyManagerWin32.cpp create mode 100644 windows/NativeShell/src/NativeShellInit.cpp create mode 100644 windows/NativeShell/src/OverlayRenderer.cpp create mode 100644 windows/NativeShell/src/SelectionOverlay.cpp create mode 100644 windows/NativeShell/src/TrayIcon.cpp create mode 100644 windows/NativeShell/src/TrayMenu.cpp create mode 100644 windows/NativeShell/src/WGCCaptureEngine.cpp create mode 100644 windows/NativeShell/src/WGCCaptureEngineFull.cpp create mode 100644 windows/NativeShell/src/WindowDetector.cpp create mode 100644 windows/NativeShell/src/WindowDetectorWin32.cpp create mode 100644 windows/NativeShell/src/pch.cpp create mode 100644 windows/NativeShell/src/pch.h create mode 100644 windows/NativeShell/tests/CaptureServiceTests.cpp create mode 100644 windows/NativeShell/tests/DisplayMonitorTests.cpp create mode 100644 windows/NativeShell/tests/DpiScalingTests.cpp create mode 100644 windows/NativeShell/tests/GeoTests.cpp create mode 100644 windows/NativeShell/tests/HotkeyManagerTests.cpp create mode 100644 windows/NativeShell/tests/OverlayRendererTests.cpp create mode 100644 windows/NativeShell/tests/TestMain.cpp create mode 100644 windows/NativeShell/tests/TrayMenuTests.cpp create mode 100644 windows/NativeShell/tests/WindowDetectorTests.cpp create mode 100644 windows/NativeShell/tests/catch_amalgamated.cpp create mode 100644 windows/NativeShell/tests/catch_amalgamated.hpp create mode 100644 windows/NativeShell/vendor/nlohmann_json.hpp create mode 100644 windows/docs/windows/CaptureService.md create mode 100644 windows/docs/windows/DisplayMonitor.md create mode 100644 windows/docs/windows/HotkeyTray.md create mode 100644 windows/docs/windows/NativeShell-Tests.md create mode 100644 windows/docs/windows/SelectionOverlay.md create mode 100644 windows/docs/windows/WindowDetector.md diff --git a/tasks/briefs/report-B.md b/tasks/briefs/report-B.md new file mode 100644 index 0000000..8f7d2fe --- /dev/null +++ b/tasks/briefs/report-B.md @@ -0,0 +1,125 @@ +# Report B — Windows 捕获壳层(Win-Capture-Shell) + +- 分支:`hubo/win-capture-shell`(基于 `hubo/feat-windows` @ 9e9f9b0) +- 交付目录:`windows/NativeShell/`(+ `windows/docs/windows/*.md`) +- 验证:**Catch2 v3.7.1 · 60 用例 / 235 断言 全绿**(macOS arm64 clang 21 实测运行) +- Windows 侧编译:**NOT RUN**(本机 macOS;复现命令见 §6) + +--- + +## 1. 实现清单 + +### 1.1 头文件(`windows/NativeShell/include/tf/`) + +| 文件 | 内容 | +|---|---| +| `Geo.hpp` | Point/Size/Rect(int64 物理像素,半开区间,纯头文件) | +| `CoreTypes.hpp` | 对任务 A 的最小依赖自声明:PixelBuffer(BGRA8+stride+DPI)、DisplayInfo(物理 frame+DPI+scale)、Screenshot(物理像素+DPI 元数据+CaptureTrigger)、HotkeyAction ×5 | +| `DisplayMonitor.hpp` | DisplayMonitorService + DisplayFreshness 三态(Cached/AlwaysRefresh/RefreshIfOlderThanMs)+ IDisplayEnumerator/IClock 注入口 | +| `WindowDetector.hpp` | WindowInfo(DWM frame/cloaked/alpha/zOrder)+ filterVisibleWindows/windowUnderPoint 纯函数 + 快照缓存服务 | +| `CaptureService.hpp` | CaptureEngine 枚举(WGC→DXGI→GDI)、CaptureRequest/Result、ICaptureEngine、回退链服务、`wgcSupportsBorderless(contract)` | +| `HotkeyManager.hpp` | HotkeySpec/Conflict/RegistrationReport、isHotkeySpecValid、findDuplicateSpec、applySpecs 生命周期、默认键位、格式化 | +| `OverlayRenderer.hpp` | OverlayMode 状态机(Idle/HoverWindow/Dragging/Confirmed)、PaintList、OverlayVisuals(40% 变暗/4px 阈值/accent)、layoutInPlaceToolbar | +| `SelectionOverlay.hpp` | Win32 控制器:precreate/beginSession/cancelSession + SelectionOverlayResult(wholeWindow 标记 FR-02) | +| `TrayIcon.hpp` | TrayCommand ×11、buildTrayMenu(最近 5 截图条目)、RecentShot、TrayIconService | + +### 1.2 实现(`src/`,Win32 TU 与策略 TU 分离) + +**策略 TU(可移植,无 Win32 包含,任何平台可编译/测试)** + +| 文件 | 要点 | +|---|---| +| `DisplayMonitor.cpp` | 2s 缓存三态策略实现(互斥锁保护) | +| `WindowDetector.cpp` | cloaked/透明/零尺寸过滤 + topmost-first hit-test + mouse-down 快照缓存 | +| `HotkeyManager.cpp` | 注册生命周期(先全卸再注册=运行时即时生效)、冲突报告、MOD 位校验、Ctrl+Alt+F/A/T/D/I 默认 | +| `CaptureService.cpp` | 回退链遍历(available→capture→observer 上报)、区域与显示器求交裁剪、空交集快失败 | +| `OverlayRenderer.cpp` | 完整交互状态机:4px 点击/拖拽阈值、方向归一化、拖拽清除窗口高亮(FR-02)、Esc 取消、徽标/十字准线/工具栏骨架 paint list、双线程安全 | +| `TrayMenu.cpp` | 菜单模型纯函数(FR-34:5 动作+最近5+5占位+退出) | + +**Win32 TU(`pch.h` 预编译,仅 Windows 编译)** + +| 文件 | 要点 | +|---|---| +| `DisplayMonitorWin32.cpp` | EnumDisplayMonitors + GetMonitorInfoW(物理 rcMonitor) + GetDpiForMonitor(PMv2);主显示器优先排序;工厂 makeWin32DisplayEnumerator/makeSteadyClock | +| `WindowDetectorWin32.cpp` | EnumWindows(Z 序天然 topmost-first)+ DWMWA_CLOAKED(UWP 挂起过滤)+ DWMWA_EXTENDED_FRAME_BOUNDS(可见边界,失败回退 GetWindowRect)+ 分层窗口 alpha + 进程映像名;排除自身(NOACTIVATE/TOOLWINDOW) | +| `HotkeyManagerWin32.cpp` | RegisterHotKey(MOD_NOREPEAT)/UnregisterHotKey + WM_HOTKEY 泵函数 | +| `WGCCaptureEngine.cpp` + `WGCCaptureEngineFull.cpp` | WGC 引擎:契约探测(UniversalApiContract 12)、GraphicsCaptureSession::IsSupported、IsBorderRequired=false 契约门(contract 15);设备注入点留给 App 装配(见已知限制 §4.1) | +| `DxgiDuplicationEngine.cpp` | DXGI 回退:CreateDXGIFactory1 可用性探针 | +| `GdiCaptureEngine.cpp` | GDI 兜底:GetDC 可用性探针 | +| `SelectionOverlay.cpp` | WS_POPUP+WS_EX_LAYERED+WS_EX_TOPMOST+WS_EX_NOACTIVATE+WS_EX_TOOLWINDOW 跨虚拟桌面窗口;D3D11→D2D1.1(Factory2/Device/DeviceContext)→CreateSwapChainForComposition(flip,2 缓冲,premultiplied)→DComp(TargetForHwnd/Visual);完整消息处理(MOUSEMOVE/LBUTTONDOWN/UP、Esc、KILLFOCUS),mouse-up 区分拖拽选区 vs 窗口单击(wholeWindow) | +| `TrayIcon.cpp` | Shell_NotifyIcon(NIM_ADD/NIM_DELETE) + TrackPopupMenuEx(TPM_RETURNCMD) + SetForegroundWindow 契约 | +| `NativeShellInit.cpp` | 组装根:makeCaptureService(链序 WGC→DXGI→GDI)、显示器/窗口/热键工厂 | +| `pch.h`/`pch.cpp` | Win32/WinRT/D2D/DComp/DXGI/D3D11 基线 + lib 链接注释 | + +### 1.3 工程文件 + +- `CMakeLists.txt`:策略 TU 全平台 + Win32 TU `if(WIN32)` 门控 + Catch2 测试目标 +- `TransFrame.NativeShell.vcxproj`:静态库(x64+ARM64,/W4 /WX Release,pch,策略 TU 显式 NotUsing pch) +- `TransFrame.NativeShell.Tests.vcxproj`:测试工程(引用 NativeShell) +- `app.manifest`:**PerMonitorV2** dpiAwareness + UTF-8 codepage + Win10/11 supportedOS +- `tests/`:Catch2 v3.7.1 amalgamated vendored + 8 个测试文件 + +### 1.4 文档(`windows/docs/windows/`) + +每服务一份设计说明(API 选择理由+回退链):`CaptureService.md`、`DisplayMonitor.md`、`WindowDetector.md`、`SelectionOverlay.md`、`HotkeyTray.md`、`NativeShell-Tests.md`。 + +--- + +## 2. FR 映射表 + +| FR | 要求 | 实现 | 状态 | +|---|---|---|---| +| **FR-01 区域截图** | 40% 变暗、拖拽、尺寸徽标、Esc、多显示器物理像素 | OverlayState(dimAlpha 0.40、4px 阈值、归一化拖拽、cancel)+ SelectionOverlay(跨虚拟桌面、D2D 绘制变暗/挖亮/1px 描边/徽标/十字准线)+ CaptureService.captureRegion(物理像素、显示器求交) | ✅ 壳层完成(预览窗口=任务 C 后续) | +| **FR-02 窗口自动识别** | 悬停检测、单击整窗、拖拽忽略、≤1 帧切换、cloaked 过滤、DWM 可见边界 | WindowDetector(EnumWindows+DWMWA_CLOAKED+EXTENDED_FRAME_BOUNDS,快照缓存 hit-test)+ OverlayState(hover 高亮 25% 填充+1px 描边,拖拽阈值后清除)+ SelectionOverlay mouse-up wholeWindow 分支 | ✅ 测试覆盖 DWM bounds vs GetWindowRect 差异 | +| **FR-03 全屏截图** | 多显示器选择、原生分辨率 | CaptureService.captureDisplay(per-display)+ DisplayMonitorService.isMultiMonitor(选择菜单判定) | ✅ 捕获壳层(菜单 UI 属 App 层) | +| **FR-04 翻译模式** | 热键=截图+OCR+翻译 | HotkeyAction::Translate 注册 + overlay 完成回调链(OCR/翻译=任务 C) | ✅ 热键与捕获路径 | +| **FR-05 就地工具栏** | 选区边缘工具条 | layoutInPlaceToolbar:8 槽位(36px 按钮/4px 间距/下缘翻转/桌面钳制)+ Confirmed 态 paint list | ✅ 布局骨架(按要求不接功能) | +| **FR-33 全局热键** | ×5、冲突上报、即时生效 | HotkeyManager:RegisterHotKey×5、失败→conflicts 报告(含用户可读 message)、applySpecs 先卸后注(即时生效)、MOD 校验 | ✅ 12 测试用例 | +| **FR-34 托盘** | 常驻图标、左键菜单、最近 5 截图 | TrayIconService(Shell_NotifyIcon)+ buildTrayMenu(10 命令+最近 5 条 recentIndex/thumbnailHint) | ✅ 缩略图数据待历史任务 | + +**PRD §8 性能预算对策**:热键→覆盖层 ≤60ms(窗口+设备启动期预创建,热路径只 ShowWindow)|松开→截图 ≤50ms(WGC frame pool 常驻+一次 staging 拷贝,GDI 30-80ms 仅兜底)|120Hz 绘制 ≤8ms(纯 GPU fill/stroke,无文本无 GDI,paintList 纯内存)|悬停查询 ≤1ms(快照内存 hit-test)|空闲 CPU 0%(事件驱动无轮询)。 + +--- + +## 3. 测试证据(macOS arm64 · clang 21 · 实测) + +``` +$ clang++ -std=c++20 -Wall -Wextra -Werror -Iinclude -c src/*.cpp # 策略 TU 零警告 +$ # (编译 tests/*.cpp + 链接) +$ ./native_shell_tests +All tests passed (235 assertions in 60 test cases) +``` + +Windows 复现(等价 CMake 路径):`cmake -S windows/NativeShell -B build && cmake --build build && ctest --test-dir build`(MSVC 时 Win32 TU 一并编译)。 + +--- + +## 4. 已知限制 + +1. **Win10 黄边框降级**:`IsBorderRequired=false` 需 UniversalApiContract 15(Win11 21H2);Win10 21H2 属性不存在,系统黄边框保留(PRD §6.13 既定降级,`wgcSupportsBorderless()` 已封装门控并有测试)。 +2. **WGC 设备接线**:`WGCCaptureEngineFull.cpp` 的 captureOnce 留设备注入点(App 层 D3D 设备单例组装后接通);契约探测、链序、几何、回退、观察者全部完成并有测试。DXGI/GDI 引擎 TU 当前为可用性探针 + 骨架(链行为由 StubEngine 全覆盖测试)。 +3. **Esc 键盘接管**:WS_EX_NOACTIVATE 窗口不收键盘,选择会话内显式 SetFocus/SetForegroundWindow(会话结束隐藏归还);焦点策略需 Windows 实机验证。 +4. **托盘图标资产**:暂用系统占位图标;相机镜头图标属打包任务。缩略图渲染待历史数据层。 +5. **尺寸徽标文本 / FR-06 结果面板**:徽标底板绘制就绪,DWrite 文本与结果面板属后续任务(本任务边界外)。 +6. **Windows 编译未运行**:本机 macOS;vcxproj/CMake 为静态正确交付,MSVC 编译验证 NOT RUN(命令见 §3/§6)。 + +--- + +## 5. 与并行任务的接口 + +- **任务 A(Core)**:`CoreTypes.hpp` 按 PRD §4 自声明最小模型(PixelBuffer/DisplayInfo/Screenshot/HotkeyAction),字段名与 macOS Models 对齐;A 的 `windows/Core` 就绪后合并(删除自声明改 include 即可,无逻辑耦合)。 +- **任务 C(翻译/OCR/预览)**:overlay 完成回调 `SelectionOverlayResult{regionPhysical, wholeWindow, windowHwnd}` + `CaptureService.captureRegion/captureDisplay` 是其输入;FR-05 工具栏 8 槽位布局已留。 +- **任务 D(取色历史)**:托盘 `RecentShot.thumbnailPath` 供给位已留。 + +## 6. Windows 复现命令 + +```powershell +# 完整层(MSVC,x64 与 ARM64 各一次) +msbuild windows\TransFrame.sln /p:Configuration=Release /p:Platform=x64 /t:TransFrame_NativeShell;TransFrame_NativeShell_Tests +build\x64\Release\TransFrame.NativeShell.Tests\native_shell_tests.exe # (路径以 OutDir 为准) + +# 或 CMake +cmake -S windows\NativeShell -B build -G "Visual Studio 17 2022" -A x64 +cmake --build build --config Release +ctest --test-dir build -C Release +``` diff --git a/windows/NativeShell/CMakeLists.txt b/windows/NativeShell/CMakeLists.txt new file mode 100644 index 0000000..5e07acf --- /dev/null +++ b/windows/NativeShell/CMakeLists.txt @@ -0,0 +1,101 @@ +# NativeShell — Win32/D2D/WGC/热键/托盘 静态库(任务 B:捕获壳层) +# Portable policy core compiles everywhere; Windows-only TUs are gated. +cmake_minimum_required(VERSION 3.20) +project(TransFrameNativeShell CXX) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +if (NOT MSVC) + # Keep the portable TUs warning-clean under clang/gcc too so the policy + # code can be CI-checked on non-Windows runners. + add_compile_options(-Wall -Wextra -Werror) +endif() + +# --------------------------------------------------------------------------- +# Portable sources (policy core: no Win32/WinRT includes) +# --------------------------------------------------------------------------- +set(PORTABLE_SOURCES + src/DisplayMonitor.cpp + src/WindowDetector.cpp + src/HotkeyManager.cpp + src/CaptureService.cpp + src/OverlayRenderer.cpp + src/TrayMenu.cpp +) + +set(PORTABLE_HEADERS + include/tf/Geo.hpp + include/tf/CoreTypes.hpp + include/tf/DisplayMonitor.hpp + include/tf/WindowDetector.hpp + include/tf/CaptureService.hpp + include/tf/HotkeyManager.hpp + include/tf/OverlayRenderer.hpp + include/tf/TrayIcon.hpp +) + +# --------------------------------------------------------------------------- +# Windows-only sources (Win32 / WinRT / D2D / DComp) +# --------------------------------------------------------------------------- +if (WIN32) + list(APPEND PORTABLE_SOURCES + src/DisplayMonitorWin32.cpp + src/WindowDetectorWin32.cpp + src/HotkeyManagerWin32.cpp + src/WGCCaptureEngine.cpp + src/WGCCaptureEngineFull.cpp + src/DxgiDuplicationEngine.cpp + src/GdiCaptureEngine.cpp + src/SelectionOverlay.cpp + src/TrayIcon.cpp + src/NativeShellInit.cpp + ) +endif() + +add_library(native_shell STATIC ${PORTABLE_SOURCES}) +target_include_directories(native_shell PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) +target_compile_features(native_shell PUBLIC cxx_std_20) + +if (MSVC) + target_compile_options(native_shell PRIVATE /W4 /WX /permissive-) + if (NOT CMAKE_CXX_FLAGS MATCHES "/Zc:__cplusplus") + target_compile_options(native_shell PRIVATE /Zc:__cplusplus) + endif() + target_precompile_headers(native_shell PRIVATE src/pch.h) +endif() + +if (WIN32) + # WinRT + Win32 linkage (task A sln adds the .vcxproj equivalents). + target_link_libraries(native_shell PUBLIC + dwmapi shcore dxgi d2d1 dcomp d3d11 windowsapp) +endif() + +# --------------------------------------------------------------------------- +# Tests (Catch2 v3 amalgamated — vendored, no package manager needed). +# Portable by design: the same suite runs on Windows CI and on dev machines. +# --------------------------------------------------------------------------- +enable_testing() + +add_executable(native_shell_tests + tests/TestMain.cpp + tests/catch_amalgamated.cpp + tests/GeoTests.cpp + tests/DisplayMonitorTests.cpp + tests/DpiScalingTests.cpp + tests/WindowDetectorTests.cpp + tests/HotkeyManagerTests.cpp + tests/CaptureServiceTests.cpp + tests/OverlayRendererTests.cpp + tests/TrayMenuTests.cpp +) +target_include_directories(native_shell_tests PRIVATE tests) +target_link_libraries(native_shell_tests PRIVATE native_shell) +if (MSVC) + target_compile_options(native_shell_tests PRIVATE /W4) + # Amalgamated Catch2 + /W4 is noisy; tests are not /WX (policy TUs are). + target_compile_options(native_shell_tests PRIVATE /wd4996 /wd26819) +endif() + +add_test(NAME native_shell_tests COMMAND native_shell_tests) diff --git a/windows/NativeShell/TransFrame.NativeShell.Tests.vcxproj b/windows/NativeShell/TransFrame.NativeShell.Tests.vcxproj new file mode 100644 index 0000000..68c9370 --- /dev/null +++ b/windows/NativeShell/TransFrame.NativeShell.Tests.vcxproj @@ -0,0 +1,73 @@ + + + + + + Debugx64 + + + Releasex64 + + + DebugARM64 + + + ReleaseARM64 + + + + + {B0000000-0000-0000-0000-00000000000C} + Win32Proj + TransFrame + 10.0.26100.0 + + + + + + Application + v143 + Unicode + + + + + + $(SolutionDir)build\$(Platform)\$(Configuration)\$(ProjectName)\ + $(SolutionDir)build\obj\$(Platform)\$(Configuration)\$(ProjectName)\ + $(ProjectDir)tests;$(ProjectDir)include;$(IncludePath) + stdcpp20 + + + + + Level4 + true + _UNICODE;UNICODE;%(PreprocessorDefinitions) + + + + + + + + + + + + + + + + + + + {B0000000-0000-0000-0000-00000000000B} + + + + + diff --git a/windows/NativeShell/TransFrame.NativeShell.vcxproj b/windows/NativeShell/TransFrame.NativeShell.vcxproj new file mode 100644 index 0000000..45ceed7 --- /dev/null +++ b/windows/NativeShell/TransFrame.NativeShell.vcxproj @@ -0,0 +1,125 @@ + + + + + + Debugx64 + + + Releasex64 + + + DebugARM64 + + + ReleaseARM64 + + + + + {B0000000-0000-0000-0000-00000000000B} + Win32Proj + TransFrame + 10.0.26100.0 + true + + + + + + StaticLibrary + true + v143 + Unicode + false + + + + + + $(SolutionDir)build\$(Platform)\$(Configuration)\$(ProjectName)\ + $(SolutionDir)build\obj\$(Platform)\$(Configuration)\$(ProjectName)\ + $(ProjectDir)include;$(IncludePath) + stdcpp20 + + + + + Level4 + true + Use + pch.h + $(IntDir)$(TargetName).pch + true + true + /Zc:__cplusplus %(AdditionalOptions) + _UNICODE;UNICODE;WIN32;_WINDOWS;NOMINMAX;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions) + + + dwmapi.lib;shcore.lib;dxgi.lib;d2d1.lib;dcomp.lib;d3d11.lib;windowsapp.lib + + + + + + + NotUsing + + + NotUsing + + + NotUsing + + + NotUsing + + + NotUsing + + + NotUsing + + + + + + + Create + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/windows/NativeShell/app.manifest b/windows/NativeShell/app.manifest new file mode 100644 index 0000000..809215a --- /dev/null +++ b/windows/NativeShell/app.manifest @@ -0,0 +1,23 @@ + + + + + TransFrame screen translation tool + + + + + PerMonitorV2 + UTF-8 + + + + + + + + + + + diff --git a/windows/NativeShell/include/tf/CaptureService.hpp b/windows/NativeShell/include/tf/CaptureService.hpp new file mode 100644 index 0000000..b1144ef --- /dev/null +++ b/windows/NativeShell/include/tf/CaptureService.hpp @@ -0,0 +1,105 @@ +// tf/CaptureService.hpp +// Screen capture with fallback chain (PRD §3.2): +// 1. Windows.Graphics.Capture - GraphicsCaptureItem per monitor, +// IsBorderRequired=false on contract 15+ (yellow border removed on Win11) +// 2. DXGI Desktop Duplication - when WGC unavailable / API contract failure +// 3. GDI BitBlt (SRCCOPY|CAPTUREBLT) - last-resort, always available +// Output: Core Screenshot (physical pixels + DPI metadata) - identical shape +// whichever engine ran, so OCR/translation layers never care. +#ifndef TF_CAPTURE_SERVICE_HPP +#define TF_CAPTURE_SERVICE_HPP + +#include "CoreTypes.hpp" +#include "DisplayMonitor.hpp" +#include "Geo.hpp" + +#include +#include +#include +#include + +namespace tf { + +enum class CaptureEngine : std::uint8_t { + WindowsGraphicsCapture, // preferred + DxgiDesktopDuplication, // fallback 1 + GdiBitBlt, // fallback 2 + None, // all engines failed +}; + +struct CaptureRequest { + Rect regionPhysical; // physical px in virtual-desktop coordinates + std::optional sourceDisplay; // display containing region origin + CaptureTrigger trigger = CaptureTrigger::ManualRegion; +}; + +struct CaptureResult { + bool ok = false; + Screenshot screenshot; // valid when ok + CaptureEngine engine = CaptureEngine::None; + std::wstring error; // UTF-16 error description when !ok +}; + +/// Observer for the one-time WGC system consent banner (informational only). +class ICaptureObserver { +public: + virtual ~ICaptureObserver() = default; + virtual void onEngineSelected(CaptureEngine engine) = 0; + virtual void onFallback(CaptureEngine failed, CaptureEngine next, const std::wstring& reason) = 0; +}; + +class ICaptureEngine { +public: + virtual ~ICaptureEngine() = default; + virtual CaptureEngine kind() const = 0; + virtual bool isAvailable() = 0; + /// Capture region (physical px, virtual-desktop coords) into BGRA8 buffer. + virtual CaptureResult capture(const CaptureRequest& request) = 0; +}; + +/// Assembled fallback chain. Owns engines in priority order. +class CaptureService { +public: + CaptureService(); + + /// Dependency-injected variant for tests. + explicit CaptureService(std::vector> engines); + + ~CaptureService(); + + CaptureService(CaptureService&&) noexcept; + CaptureService& operator=(CaptureService&&) noexcept; + CaptureService(const CaptureService&) = delete; + CaptureService& operator=(const CaptureService&) = delete; + + /// Full-display capture (FR-03). Multi-monitor: caller passes the display. + CaptureResult captureDisplay(const DisplayInfo& display, CaptureTrigger trigger); + + /// Region capture (FR-01/02): manual drag rect or whole-window DWM frame. + /// Region is clipped to the source display's frame. + CaptureResult captureRegion(const Rect& regionPhysical, + const DisplayInfo& sourceDisplay, + CaptureTrigger trigger); + + void setObserver(ICaptureObserver* observer) { observer_ = observer; } + + /// Engine that served the last successful capture (diagnostics). + CaptureEngine lastEngine() const { return lastEngine_; } + +private: + CaptureResult runChain(const CaptureRequest& request); + static Rect clampRegionToDisplay(const Rect& region, const DisplayInfo& display); + + std::vector> engines_; + ICaptureObserver* observer_ = nullptr; + CaptureEngine lastEngine_ = CaptureEngine::None; +}; + +/// Detect WGC borderless support: GraphicsCaptureSession.IsBorderRequired +/// requires API contract 15 (Windows 11 21H2 / SDK 10.0.22000). Exported for +/// tests via injection; production reads Windows.Foundation.UniversalApiContract. +bool wgcSupportsBorderless(std::uint32_t universalApiContractVersion); + +} // namespace tf + +#endif // TF_CAPTURE_SERVICE_HPP diff --git a/windows/NativeShell/include/tf/CoreTypes.hpp b/windows/NativeShell/include/tf/CoreTypes.hpp new file mode 100644 index 0000000..76c49ac --- /dev/null +++ b/windows/NativeShell/include/tf/CoreTypes.hpp @@ -0,0 +1,88 @@ +// tf/CoreTypes.hpp +// Minimal Core-model surface this task depends on (PRD §4 interface contract). +// Task A owns windows/Core; the real Screenshot/DisplayInfo land there. +// This header declares only what NativeShell needs, self-contained, so B does +// not block on A. Fields mirror macOS Models/Screenshot.swift + DisplayInfo.swift. +// On MSVC these resolve via transitive includes (see src/pch.h); +// the header itself stays platform-clean for Catch2 tests. +#ifndef TF_CORE_TYPES_HPP +#define TF_CORE_TYPES_HPP + +#include "Geo.hpp" + +#include +#include +#include +#include +#include + +namespace tf { + +/// Raw BGRA8 bitmap in physical pixels. Ownership shared so the same pixels can +/// flow into OCR, preview and history without extra copies. +struct PixelBuffer { + std::int32_t width = 0; // physical px + std::int32_t height = 0; // physical px + std::int32_t stride = 0; // bytes per row (>= width*4, D3D requires multiples of 256 on staging) + std::uint32_t dpiX = 96; // horizontal DPI of the source display + std::uint32_t dpiY = 96; // vertical DPI + std::shared_ptr data; // BGRA byte order, row-major, top-down + + bool valid() const { + return data && width > 0 && height > 0 && stride >= width * 4; + } + std::size_t byteSize() const { return static_cast(stride) * height; } +}; + +enum class ExportFormat : std::uint8_t { Png, Jpeg, Heic }; + +enum class CaptureTrigger : std::uint8_t { + HotkeyRegion, + HotkeyFullScreen, + HotkeyTranslate, + TrayRegion, + TrayFullScreen, + WindowClick, // FR-02: click on auto-detected window + ManualRegion, // FR-01: drag selection +}; + +/// Core DisplayInfo (subset used by NativeShell). Physical pixel frame; +/// scale = dpi / 96 per PRD §3.2 (Per-Monitor V2). +struct DisplayInfo { + std::wstring id; // device name from EnumDisplayMonitors (\\.\DISPLAY1) + std::wstring name; // user-visible name (GetMonitorInfo szDevice fallback) + Rect framePhysical; // virtual-desktop coordinates, physical pixels + std::uint32_t dpiX = 96; + std::uint32_t dpiY = 96; + bool isPrimary = false; + + double scale() const { return dpiX / 96.0; } +}; + +/// Core Screenshot (subset). Physical pixels + DPI metadata per PRD §4.3. +struct Screenshot { + std::uint64_t id = 0; // GUID bits, filled by Core + PixelBuffer pixels; // BGRA8, physical px, top-down + DisplayInfo sourceDisplay; // display that contains the capture origin + std::chrono::system_clock::time_point capturedAt{}; + CaptureTrigger trigger = CaptureTrigger::ManualRegion; + + std::int64_t width() const { return pixels.width; } + std::int64_t height() const { return pixels.height; } +}; + +enum class HotkeyAction : std::uint8_t { + FullScreen, // Ctrl+Alt+F + Region, // Ctrl+Alt+A + Translate, // Ctrl+Alt+T + TextSelection, // Ctrl+Alt+D + TranslateInsert, // Ctrl+Alt+I +}; + +inline constexpr int kHotkeyActionCount = 5; + +enum class HotkeyEventKind : std::uint8_t { Pressed }; + +} // namespace tf + +#endif // TF_CORE_TYPES_HPP diff --git a/windows/NativeShell/include/tf/DisplayMonitor.hpp b/windows/NativeShell/include/tf/DisplayMonitor.hpp new file mode 100644 index 0000000..7120d53 --- /dev/null +++ b/windows/NativeShell/include/tf/DisplayMonitor.hpp @@ -0,0 +1,80 @@ +// tf/DisplayMonitor.hpp +// Display enumeration: EnumDisplayMonitors + GetDpiForMonitor (Per-Monitor V2). +// Mirrors macOS DisplayFreshnessPolicy (CapturePipeline.swift): a 2s cache so +// hot paths (hotkey -> overlay) never pay the ~1-3ms enumeration cost, while +// repeated invocations still pick up display changes within the PRD budget. +// +// Windows API surface is isolated behind an injectable provider so the cache +// policy itself is unit-testable on any platform (see tests/). +#ifndef TF_DISPLAY_MONITOR_HPP +#define TF_DISPLAY_MONITOR_HPP + +#include "CoreTypes.hpp" + +#include +#include +#include + +namespace tf { + +enum class DisplayFreshness : std::uint8_t { + Cached, // return cached list, never enumerate + AlwaysRefresh, // enumerate now + RefreshIfOlderThanMs, // enumerate when cache older than threshold +}; + +struct DisplayQuery { + DisplayFreshness freshness = DisplayFreshness::RefreshIfOlderThanMs; + std::chrono::milliseconds maxAge{2000}; // aligns macOS refreshIfOlderThan(2) +}; + +/// Platform hook. Production implementation lives in +/// src/DisplayMonitor.cpp (Win32); tests substitute a fake clock + fake list. +class IDisplayEnumerator { +public: + virtual ~IDisplayEnumerator() = default; + /// Returns physical-pixel frames in virtual-desktop coordinates. + virtual std::vector enumerate() = 0; +}; + +/// Abstract clock for testable cache expiry. +class IClock { +public: + virtual ~IClock() = default; + virtual std::chrono::steady_clock::time_point now() = 0; +}; + +class DisplayMonitorService { +public: + explicit DisplayMonitorService(IDisplayEnumerator& enumerator, IClock& clock) + : enumerator_(&enumerator), clock_(&clock) {} + + /// Primary entry for capture pipelines. Thread-safe. + std::vector displays(const DisplayQuery& query = {}); + + /// Display whose frame contains the point (physical virtual-desktop px). + /// Empty result when the point sits outside any monitor. + std::optional displayAt(Point p, const DisplayQuery& query = {}); + + /// Drop cache; next query enumerates (call on WM_DISPLAYCHANGE). + void invalidate(); + + /// True when at least 2 displays are connected (FR-03 picker rule). + bool isMultiMonitor(const DisplayQuery& query = {}); + + static std::chrono::milliseconds defaultMaxAge() { return std::chrono::milliseconds(2000); } + +private: + bool needsRefresh(const DisplayQuery& q, bool haveCache) const; + + IDisplayEnumerator* enumerator_; + IClock* clock_; + mutable std::mutex mutex_; + std::vector cache_; + std::chrono::steady_clock::time_point cachedAt{}; + bool hasCache_ = false; +}; + +} // namespace tf + +#endif // TF_DISPLAY_MONITOR_HPP diff --git a/windows/NativeShell/include/tf/Geo.hpp b/windows/NativeShell/include/tf/Geo.hpp new file mode 100644 index 0000000..2269c36 --- /dev/null +++ b/windows/NativeShell/include/tf/Geo.hpp @@ -0,0 +1,71 @@ +// tf/Geo.hpp +// Geometry primitives shared by NativeShell services. Physical-pixel space +// (Per-Monitor V2 aware), origin = virtual-desktop top-left, Y grows down. +// Pure header: no Win32 / WinRT includes, unit-testable on any platform. +#ifndef TF_GEO_HPP +#define TF_GEO_HPP + +#include +#include + +namespace tf { + +struct Point { + std::int64_t x = 0; + std::int64_t y = 0; + bool operator==(const Point& o) const = default; +}; + +struct Size { + std::int64_t width = 0; + std::int64_t height = 0; + bool operator==(const Size& o) const = default; + bool empty() const { return width <= 0 || height <= 0; } +}; + +struct Rect { + std::int64_t x = 0, y = 0, width = 0, height = 0; + bool operator==(const Rect& o) const = default; + + std::int64_t left() const { return x; } + std::int64_t top() const { return y; } + std::int64_t right() const { return x + width; } + std::int64_t bottom() const { return y + height; } + + bool empty() const { return width <= 0 || height <= 0; } + bool contains(Point p) const { + return p.x >= x && p.x < right() && p.y >= y && p.y < bottom(); + } + + Point origin() const { return {x, y}; } + Size size() const { return {width, height}; } + + Rect intersection(const Rect& o) const { + const std::int64_t l = std::max(left(), o.left()); + const std::int64_t t = std::max(top(), o.top()); + const std::int64_t r = std::min(right(), o.right()); + const std::int64_t b = std::min(bottom(), o.bottom()); + if (r <= l || b <= t) return {}; + return {l, t, r - l, b - t}; + } + + Rect normalized() const { + Rect r{*this}; + if (r.width < 0) { r.x += r.width + 1; r.width = -r.width; } + if (r.height < 0) { r.y += r.height + 1; r.height = -r.height; } + return r; + } + + /// Expand by d on all sides (clamped at 0). + Rect inflated(std::int64_t d) const { + Rect r{*this}; + r.x -= d; r.y -= d; r.width += 2 * d; r.height += 2 * d; + if (r.width < 0) r.width = 0; + if (r.height < 0) r.height = 0; + return r; + } +}; + +} // namespace tf + +#endif // TF_GEO_HPP diff --git a/windows/NativeShell/include/tf/HotkeyManager.hpp b/windows/NativeShell/include/tf/HotkeyManager.hpp new file mode 100644 index 0000000..5fbd6c4 --- /dev/null +++ b/windows/NativeShell/include/tf/HotkeyManager.hpp @@ -0,0 +1,107 @@ +// tf/HotkeyManager.hpp +// Global hotkeys (FR-33): RegisterHotKey / WM_HOTKEY x5 +// (full-screen / region / translate / text-selection / translate-insert). +// Registration failure = conflict report (no silent ignore). Re-registration +// at runtime applies immediately (settings change -> unregister -> register). +// +// The Win32 RegisterHotKey call is isolated behind IHotkeyRegistrar so the +// conflict matrix, dedup and re-registration state machine are unit-testable. +#ifndef TF_HOTKEY_MANAGER_HPP +#define TF_HOTKEY_MANAGER_HPP + +#include "CoreTypes.hpp" + +#include +#include +#include +#include +#include + +namespace tf { + +/// Virtual-key codes live in the Core KeyboardShortcut model (task A). +/// NativeShell consumes (vk, modifiers) pairs with Win32 MOD_* bit values. +struct HotkeySpec { + HotkeyAction action = HotkeyAction::Region; + std::uint32_t vk = 0; // VK_* code + std::uint32_t modifiers = 0; // MOD_ALT|MOD_CONTROL|MOD_SHIFT|MOD_WIN + bool enabled = true; +}; + +struct HotkeyConflict { + HotkeyAction action = HotkeyAction::Region; + std::uint32_t vk = 0; + std::uint32_t modifiers = 0; + std::wstring message; // user-facing reason (registration failure text) +}; + +struct HotkeyRegistrationReport { + bool allRegistered = false; + std::vector registered; // actions now live + std::vector conflicts; // failed actions with reason +}; + +using HotkeyHandler = std::function; + +/// Platform hook over RegisterHotKey/UnregisterHotKey. Returns false when the +/// OS rejects the combination (conflict with another app or invalid spec). +class IHotkeyRegistrar { +public: + virtual ~IHotkeyRegistrar() = default; + virtual bool registerHotkey(int id, std::uint32_t vk, std::uint32_t modifiers) = 0; + virtual bool unregisterHotkey(int id) = 0; +}; + +/// Win32 MOD_* modifier bit helpers (used by the App settings layer too). +enum ModBits : std::uint32_t { + kModNone = 0, + kModAlt = 0x0001, + kModControl= 0x0002, + kModShift = 0x0004, + kModWin = 0x0008, +}; + +/// Pure validation: a spec is registerable when it has a non-zero VK and at +/// least one modifier (matches macOS validation rule, PRD FR-33). +bool isHotkeySpecValid(const HotkeySpec& spec); + +/// Pure conflict detection within a spec set: same (vk, modifiers) twice. +std::optional findDuplicateSpec(const std::vector& specs); + +class HotkeyManager { +public: + explicit HotkeyManager(IHotkeyRegistrar& registrar) : registrar_(®istrar) {} + + /// Register all enabled specs; unregisters previous set first so runtime + /// re-registration takes effect immediately. Idempotent. + HotkeyRegistrationReport applySpecs(const std::vector& specs); + + /// Dispatch WM_HOTKEY id -> action -> handler. Returns true when handled. + bool dispatchWmHotkey(int id); + + void setHandler(HotkeyHandler handler) { handler_ = std::move(handler); } + + /// Stop everything (app teardown / suspend). + void unregisterAll(); + + bool isRegistered(HotkeyAction action) const; + + /// Stable hotkey ids: index over HotkeyAction (0..4). + static int idForAction(HotkeyAction action); + +private: + IHotkeyRegistrar* registrar_; + HotkeyHandler handler_; + std::unordered_map idToAction_; + std::vector active_; +}; + +/// Default specs (PRD Appendix A): Ctrl+Alt+F/A/T/D/I. +std::vector defaultHotkeySpecs(); + +/// Map a HotkeySpec to a short display string like "Ctrl+Alt+A" (settings UI). +std::wstring formatHotkeySpec(const HotkeySpec& spec); + +} // namespace tf + +#endif // TF_HOTKEY_MANAGER_HPP diff --git a/windows/NativeShell/include/tf/OverlayRenderer.hpp b/windows/NativeShell/include/tf/OverlayRenderer.hpp new file mode 100644 index 0000000..ac17a46 --- /dev/null +++ b/windows/NativeShell/include/tf/OverlayRenderer.hpp @@ -0,0 +1,107 @@ +// tf/OverlayRenderer.hpp +// Selection-overlay rendering model (FR-01/02, FR-05 layout skeleton). +// Pure state + paint-list computation; the D2D1.1/DComp device plumbing is in +// src/SelectionOverlay.cpp. Keeping the state machine here makes the +// 120Hz repaint path unit-testable (<= 8ms budget) and MT-safe by construction: +// - UI thread mutates state under std::mutex +// - render thread snapshots and builds a paint list without Win32 calls +// +// Rendering contract (visual spec, macOS SelectionOverlayWindow parity): +// whole virtual desktop darkened 40% black; +// selection rect "punched through" (undimmed) + 1px accent stroke; +// size badge near selection edge; crosshair lines when idle; +// hovered-window highlight (accent fill 25% + 1px stroke) until drag starts. +#ifndef TF_OVERLAY_RENDERER_HPP +#define TF_OVERLAY_RENDERER_HPP + +#include "CoreTypes.hpp" +#include "Geo.hpp" + +#include +#include +#include + +namespace tf { + +enum class OverlayMode : std::uint8_t { + Idle, // crosshair only, no selection yet + HoverWindow, // window under cursor highlighted (FR-02) + Dragging, // manual rect selection in progress (FR-01) + Confirmed, // selection done; in-place toolbar shown (layout skeleton only) +}; + +struct OverlayVisuals { + float dimAlpha = 0.40f; // 40% black over whole desktop (FR-01) + float accentR = 0.00f, accentG = 0.47f, accentB = 0.94f; // system accent blue + float windowFillAlpha = 0.25f; // hovered-window tint + std::int64_t dragThresholdPx = 4; // click vs drag discriminator (spec 2.2) +}; + +struct SizeBadge { + std::int64_t w = 0, h = 0; + Rect anchor; // badge rect in physical px (D2D draws text inside) +}; + +struct PaintList { + Rect desktop; // virtual desktop bounds (physical px) + Rect dimRegion = {}; // = desktop; kept explicit for the punch-out pass + std::optional punchThrough; // undimmed selection + std::optional selectionStroke; // 1px accent outline + std::optional windowHighlight; // hovered window (fill+stroke) + bool crosshair = false; + Point crosshairAt{}; + std::optional badge; + // FR-05: layout skeleton only (rects for toolbar buttons; no handlers). + std::vector toolbarSlots; +}; + +/// Thread-safe overlay state machine. +class OverlayState { +public: + explicit OverlayState(OverlayVisuals visuals = {}) : visuals_(visuals) {} + + void setDesktop(Rect desktop); + void setMode(OverlayMode mode); + OverlayMode mode() const; + + void setHoverWindow(std::optional frame); + void beginTracking(Point anchor); + void moveTracking(Point current); // hover + crosshair position; drag when active + /// Returns true when movement crossed the drag threshold (drag engaged). + bool isDragEngaged() const; + void endTracking(); // mouse-up: freeze selection + void cancel(); // Esc: back to idle, selection cleared + + std::optional selection() const; + std::optional hoverWindow() const; + Point anchor() const { return anchor_; } + Point current() const { return current_; } + + /// Compute the paint list (called by the render thread each frame). + PaintList paintList() const; + + const OverlayVisuals& visuals() const { return visuals_; } + +private: + Rect normalizedSelection() const; + + mutable std::mutex mutex_; + OverlayVisuals visuals_; + OverlayMode mode_ = OverlayMode::Idle; + Rect desktop_{}; + std::optional hover_; + std::optional selection_; + Point anchor_{}; + Point current_{}; + bool dragEngaged_ = false; + std::optional downPoint_; +}; + +/// FR-05 layout skeleton: toolbar button rects below/above selection edge, +/// clamped to desktop. Pure geometry, ready for later task to attach commands. +std::vector layoutInPlaceToolbar(const Rect& selection, const Rect& desktop, + std::size_t buttonCount); + +} // namespace tf + +#endif // TF_OVERLAY_RENDERER_HPP diff --git a/windows/NativeShell/include/tf/SelectionOverlay.hpp b/windows/NativeShell/include/tf/SelectionOverlay.hpp new file mode 100644 index 0000000..2303b19 --- /dev/null +++ b/windows/NativeShell/include/tf/SelectionOverlay.hpp @@ -0,0 +1,66 @@ +// tf/SelectionOverlay.hpp +// Full-screen selection overlay window (FR-01/02): one WS_POPUP + +// WS_EX_LAYERED + WS_EX_TOPMOST window spanning the entire virtual desktop, +// rendered with Direct2D 1.1 + DirectComposition. +// +// This header is the Win32-side controller; it compiles only on Windows. +// The rendering state machine it drives is OverlayRenderer.hpp (portable). +// +// Performance contract (PRD §8): +// hotkey -> overlay visible <= 60ms (window pre-created at app start; show = 1 DWM frame) +// frame paint at 120Hz <= 8ms (D2D1.1 command list + DComp visual; no GDI) +#ifndef TF_SELECTION_OVERLAY_HPP +#define TF_SELECTION_OVERLAY_HPP + +#include "OverlayRenderer.hpp" + +#include +#include +#include + +namespace tf { + +struct SelectionOverlayResult { + bool confirmed = false; + Rect regionPhysical; // confirmed selection (physical px, virtual-desktop coords) + bool wholeWindow = false; // FR-02: region came from a window click + std::uint64_t windowHwnd = 0; +}; + +using OverlayCompletion = std::function; + +/// D2D/DComp device plumbing (implemented in src/SelectionOverlay.cpp). +class OverlayRendererDevice; + +class SelectionOverlayController { +public: + SelectionOverlayController(); + ~SelectionOverlayController(); + + SelectionOverlayController(const SelectionOverlayController&) = delete; + SelectionOverlayController& operator=(const SelectionOverlayController&) = delete; + + /// Create the (hidden) overlay window + D2D/DComp device at app start so + /// the hotkey path only has to ShowWindow. Returns false on device failure. + bool precreate(); + + /// Hotkey path: show overlay, begin tracking. completion fires exactly once + /// per session with confirmed=true (selection made) or confirmed=false (Esc). + bool beginSession(OverlayCompletion completion); + + /// Cancel programmatically (e.g. focus loss). + void cancelSession(); + + bool isActive() const; + + /// Inject render state (tests). Production uses internal message pump. + OverlayState& state(); + +private: + struct Impl; + std::unique_ptr impl_; +}; + +} // namespace tf + +#endif // TF_SELECTION_OVERLAY_HPP diff --git a/windows/NativeShell/include/tf/TrayIcon.hpp b/windows/NativeShell/include/tf/TrayIcon.hpp new file mode 100644 index 0000000..931ae43 --- /dev/null +++ b/windows/NativeShell/include/tf/TrayIcon.hpp @@ -0,0 +1,88 @@ +// tf/TrayIcon.hpp +// Tray icon (FR-34): Shell_NotifyIcon, left-click menu with capture actions + +// placeholders + recent-5-screenshot thumbnail strip. +// +// Menu model is pure (testable); the Shell_NotifyIcon / Win32 menu plumbing +// lives in src/TrayIcon.cpp and is exercised on Windows only. +#ifndef TF_TRAY_ICON_HPP +#define TF_TRAY_ICON_HPP + +#include "CoreTypes.hpp" + +#include +#include +#include +#include + +namespace tf { + +enum class TrayCommand : std::uint8_t { + None = 0, + FullScreen, // 全屏 + Region, // 区域 + Translate, // 翻译 + TextSelection, // 划词 + TranslateInsert, // 插入 + PinnedManager, // 置顶管理 (placeholder, task D) + History, // 历史 (placeholder) + Settings, // 设置 (placeholder) + CheckUpdates, // 检查更新 (placeholder) + Exit, // 退出 + RecentShot, // recent screenshot #n (index in payload) +}; + +struct TrayMenuItem { + std::wstring label; + TrayCommand command = TrayCommand::None; + bool enabled = true; + bool separatorAfter = false; + /// For RecentShot entries: index into the recent-shots list (0-based). + int recentIndex = -1; + /// Thumbnail bitmap path/HBITMAP placeholder (task C/history integration). + std::wstring thumbnailHint; +}; + +struct RecentShot { + std::uint64_t screenshotId = 0; + std::wstring thumbnailPath; // small cached JPEG/PNG (history store supplies) + std::wstring label; // e.g. "14:32 1920x1080" +}; + +using TrayCommandHandler = std::function; + +/// Pure menu construction: actions + placeholders + recent strip (<= 5). +std::vector buildTrayMenu(const std::vector& recentShots); + +class TrayIconService { +public: + explicit TrayIconService(TrayCommandHandler handler); + ~TrayIconService(); + + TrayIconService(const TrayIconService&) = delete; + TrayIconService& operator=(const TrayIconService&) = delete; + + /// Create the Shell_NotifyIcon entry (call once, after message window up). + bool install(); + + /// Remove the tray entry (app exit / crash-safe teardown). + void remove(); + + /// Swap recent-shot list; menu rebuilds on next open (FR-34: 5 thumbnails). + void setRecentShots(std::vector shots); + + /// Left-click opens menu (Win11 style); right-click is a no-op here. + void showMenuAtCursor(); + + bool isInstalled() const { return installed_; } + +private: + void dispatch(TrayCommand command, int recentIndex); + + TrayCommandHandler handler_; + std::vector recent_; + bool installed_ = false; +}; + +} // namespace tf + +#endif // TF_TRAY_ICON_HPP diff --git a/windows/NativeShell/include/tf/WindowDetector.hpp b/windows/NativeShell/include/tf/WindowDetector.hpp new file mode 100644 index 0000000..50cb1c9 --- /dev/null +++ b/windows/NativeShell/include/tf/WindowDetector.hpp @@ -0,0 +1,87 @@ +// tf/WindowDetector.hpp +// Window detection for FR-02: EnumWindows + DwmGetWindowAttribute +// (DWMWA_EXTENDED_FRAME_BOUNDS / DWMWA_CLOAKED) with a mouse-down snapshot +// cache, mirroring the macOS WindowDetector.swift semantics: +// - visibleWindows(): topmost-first Z order, filtered +// - windowUnderPoint(): <= 1ms hot path from the cached snapshot +// - refreshSnapshot() at mouse-down (windows do not move while user operates overlay) +// +// Win32 specifics are isolated behind IWindowLister so geometry, filtering and +// hit-testing are unit-testable headless. +#ifndef TF_WINDOW_DETECTOR_HPP +#define TF_WINDOW_DETECTOR_HPP + +#include "CoreTypes.hpp" +#include "Geo.hpp" + +#include +#include +#include + +namespace tf { + +struct WindowInfo { + std::uint64_t hwnd = 0; // HWND as stable integer + std::uint32_t pid = 0; + Rect frame; // DWMWA_EXTENDED_FRAME_BOUNDS, physical px, virtual-desktop coords + std::wstring ownerName; // process / owner title + std::wstring windowName; // window title (best effort) + std::int32_t zOrder = 0; // 0 = topmost visible + bool isCloaked = false; // DWMWA_CLOAKED != 0 (UWP suspended etc.) + bool isOnScreen = true; + double alpha = 1.0; // GetLayeredWindowAttributes alpha / 255 (0 if layered absent) + + bool operator==(const WindowInfo& o) const { + return hwnd == o.hwnd && frame == o.frame && isCloaked == o.isCloaked; + } +}; + +/// Platform hook: production implementation in src/WindowDetector.cpp uses +/// EnumWindows + DwmGetWindowAttribute; tests feed synthetic window sets. +class IWindowLister { +public: + virtual ~IWindowLister() = default; + /// Topmost-first list of candidate windows (unfiltered raw frames). + virtual std::vector listTopmostFirst() = 0; +}; + +/// Pure filtering + hit-test policy. Given a raw topmost-first list: +/// - drop cloaked windows (DWMWA_CLOAKED) +/// - drop fully transparent (alpha == 0) +/// - drop zero-size / off-screen-empty frames +/// - keep everything else (owner-owned child windows included: browser +/// view children must be selectable per FR-02 acceptance) +/// Returns topmost-first filtered list. +std::vector filterVisibleWindows(std::vector windows); + +/// Hit-test: first window in topmost-first order whose frame contains the +/// point. Caller passes output of filterVisibleWindows. +std::optional windowUnderPoint(const std::vector& ordered, Point p); + +class WindowDetectorService { +public: + explicit WindowDetectorService(IWindowLister& lister) : lister_(&lister) {} + + /// Enumerate + filter now (also refreshes the snapshot cache). + std::vector visibleWindows(); + + /// Hot path (mouse-move / hover): hit-test against the cached snapshot. + /// Falls back to a fresh list when no snapshot exists yet. + std::optional windowUnderPoint(Point p); + + /// Refresh snapshot (call at mouse-down; see macOS spec caching note). + void refreshSnapshot(); + + /// Drop snapshot (call at overlay teardown). + void invalidate(); + + bool hasSnapshot() const { return snapshot_.has_value(); } + +private: + IWindowLister* lister_; + std::optional> snapshot_; +}; + +} // namespace tf + +#endif // TF_WINDOW_DETECTOR_HPP diff --git a/windows/NativeShell/src/CaptureService.cpp b/windows/NativeShell/src/CaptureService.cpp new file mode 100644 index 0000000..3563a9d --- /dev/null +++ b/windows/NativeShell/src/CaptureService.cpp @@ -0,0 +1,94 @@ +// CaptureService — engine chain + shared capture plumbing (portable core). +// Engine implementations: WGCCaptureEngine.cpp / DxgiDuplicationEngine.cpp / +// GdiCaptureEngine.cpp (Windows-only TUs). +#include "tf/CaptureService.hpp" + +#include + +namespace tf { + +bool wgcSupportsBorderless(std::uint32_t universalApiContractVersion) { + // GraphicsCaptureSession.IsBorderRequired is introduced in + // Windows.Foundation.UniversalApiContract version 15 (Windows 11 21H2, + // SDK 10.0.22000). Below that the property simply does not exist and the + // yellow border stays (Win10 degradation path, PRD §6.13). + return universalApiContractVersion >= 15; +} + +namespace { + +// Pixel allocation lives in the engine TUs (WGC/DXGI/GDI) where the staging +// stride is known; the chain itself never allocates. + +} // namespace + +CaptureService::CaptureService() = default; + +CaptureService::CaptureService(std::vector> engines) + : engines_(std::move(engines)) {} + +CaptureService::~CaptureService() = default; + +CaptureService::CaptureService(CaptureService&&) noexcept = default; +CaptureService& CaptureService::operator=(CaptureService&&) noexcept = default; + +Rect CaptureService::clampRegionToDisplay(const Rect& region, const DisplayInfo& display) { + const Rect clipped = region.intersection(display.framePhysical); + return clipped.empty() ? Rect{} : clipped; +} + +CaptureResult CaptureService::captureDisplay(const DisplayInfo& display, CaptureTrigger trigger) { + CaptureRequest req; + req.regionPhysical = display.framePhysical; + req.sourceDisplay = display; + req.trigger = trigger; + return runChain(req); +} + +CaptureResult CaptureService::captureRegion(const Rect& regionPhysical, + const DisplayInfo& sourceDisplay, + CaptureTrigger trigger) { + CaptureRequest req; + req.regionPhysical = clampRegionToDisplay(regionPhysical, sourceDisplay); + if (req.regionPhysical.empty()) { + CaptureResult fail; + fail.error = L"Capture region has empty intersection with the source display."; + return fail; + } + req.sourceDisplay = sourceDisplay; + req.trigger = trigger; + return runChain(req); +} + +CaptureResult CaptureService::runChain(const CaptureRequest& request) { + if (engines_.empty()) { + CaptureResult fail; + fail.error = L"No capture engine available."; + return fail; + } + CaptureEngine previous = CaptureEngine::None; + for (auto& engine : engines_) { + if (!engine->isAvailable()) { + if (observer_) observer_->onFallback(engine->kind(), CaptureEngine::None, + L"engine unavailable"); + previous = engine->kind(); + continue; + } + CaptureResult result = engine->capture(request); + if (result.ok) { + lastEngine_ = result.engine; + if (observer_) observer_->onEngineSelected(result.engine); + return result; + } + if (observer_ && previous != CaptureEngine::None) { + observer_->onFallback(previous, CaptureEngine::None, result.error); + } + previous = engine->kind(); + } + CaptureResult fail; + fail.engine = CaptureEngine::None; + fail.error = L"All capture engines failed."; + return fail; +} + +} // namespace tf diff --git a/windows/NativeShell/src/DisplayMonitor.cpp b/windows/NativeShell/src/DisplayMonitor.cpp new file mode 100644 index 0000000..e322638 --- /dev/null +++ b/windows/NativeShell/src/DisplayMonitor.cpp @@ -0,0 +1,48 @@ +// DisplayMonitor policy implementation (portable; no Win32). +// The Win32 enumerator lives in DisplayMonitorWin32.cpp. +#include "tf/DisplayMonitor.hpp" + +namespace tf { + +std::vector DisplayMonitorService::displays(const DisplayQuery& query) { + std::scoped_lock lock(mutex_); + if (needsRefresh(query, hasCache_)) { + cache_ = enumerator_->enumerate(); + cachedAt = clock_->now(); + hasCache_ = true; + } + return cache_; +} + +std::optional DisplayMonitorService::displayAt(Point p, const DisplayQuery& query) { + const auto list = displays(query); + for (const auto& d : list) { + if (d.framePhysical.contains(p)) return d; + } + return std::nullopt; +} + +void DisplayMonitorService::invalidate() { + std::scoped_lock lock(mutex_); + cache_.clear(); + hasCache_ = false; +} + +bool DisplayMonitorService::isMultiMonitor(const DisplayQuery& query) { + return displays(query).size() > 1; +} + +bool DisplayMonitorService::needsRefresh(const DisplayQuery& q, bool haveCache) const { + switch (q.freshness) { + case DisplayFreshness::Cached: + return !haveCache; // fill once, then serve from cache + case DisplayFreshness::AlwaysRefresh: + return true; + case DisplayFreshness::RefreshIfOlderThanMs: + if (!haveCache) return true; + return (clock_->now() - cachedAt) > q.maxAge; + } + return true; // unreachable; conservative default +} + +} // namespace tf diff --git a/windows/NativeShell/src/DisplayMonitorWin32.cpp b/windows/NativeShell/src/DisplayMonitorWin32.cpp new file mode 100644 index 0000000..c625293 --- /dev/null +++ b/windows/NativeShell/src/DisplayMonitorWin32.cpp @@ -0,0 +1,73 @@ +// DisplayMonitorWin32.cpp — EnumDisplayMonitors + GetDpiForMonitor provider. +// Physical-pixel frames come from GetMonitorInfo(rcMonitor) because the +// process is Per-Monitor V2 aware (app.manifest): rcMonitor is already in the +// physical coordinate space of the virtual desktop. +#include "pch.h" + +#include "tf/DisplayMonitor.hpp" + +#include + +namespace tf { +namespace { + +class Win32Enumerator final : public IDisplayEnumerator { +public: + std::vector enumerate() override { + std::vector out; + ::EnumDisplayMonitors( + nullptr, nullptr, + [](HMONITOR monitor, HDC, LPRECT, LPARAM lParam) -> BOOL { + auto* self = reinterpret_cast*>(lParam); + + MONITORINFOEXW mi{}; + mi.cbSize = sizeof(mi); + if (!::GetMonitorInfoW(monitor, &mi)) return TRUE; // skip broken entries + + UINT dpiX = 96, dpiY = 96; + // PROCESS_PER_MONITOR_DPI_AWARE => returns per-monitor DPI. + if (FAILED(::GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY))) { + dpiX = dpiY = 96; // assume 100% when the API is unavailable (Win10 1607-) + } + + const RECT& r = mi.rcMonitor; // physical px, virtual-desktop coords + DisplayInfo info; + info.id = mi.szDevice; + info.name = mi.szDevice; // friendly names need DISPLAYCONFIG; fine for v1 + info.framePhysical = Rect{r.left, r.top, + r.right - r.left, r.bottom - r.top}; + info.dpiX = dpiX; + info.dpiY = dpiY; + info.isPrimary = (mi.dwFlags & MONITORINFOF_PRIMARY) != 0; + self->push_back(std::move(info)); + return TRUE; + }, + reinterpret_cast(&out)); + + // Deterministic order: primary first, then by x (matches macOS + // DisplayInfo ordering expectations and keeps capture targeting stable). + std::sort(out.begin(), out.end(), [](const DisplayInfo& a, const DisplayInfo& b) { + if (a.isPrimary != b.isPrimary) return a.isPrimary; + return a.framePhysical.x < b.framePhysical.x; + }); + return out; + } +}; + +class SteadyClock final : public IClock { +public: + std::chrono::steady_clock::time_point now() override { + return std::chrono::steady_clock::now(); + } +}; + +} // namespace + +std::unique_ptr makeWin32DisplayEnumerator() { + return std::make_unique(); +} +std::unique_ptr makeSteadyClock() { + return std::make_unique(); +} + +} // namespace tf diff --git a/windows/NativeShell/src/DxgiDuplicationEngine.cpp b/windows/NativeShell/src/DxgiDuplicationEngine.cpp new file mode 100644 index 0000000..53a1159 --- /dev/null +++ b/windows/NativeShell/src/DxgiDuplicationEngine.cpp @@ -0,0 +1,25 @@ +// DxgiDuplicationEngine.cpp — DXGI Desktop Duplication fallback (engine 2). +// +// Used when WGC is unavailable (API contract missing, group policy, capture +// consent denied). One output duplication per monitor output; capture = +// AcquireNextFrame with a short timeout, copy the GPU texture into a staging +// texture, Map once, crop region into the Core PixelBuffer. +#include "pch.h" + +#include "tf/CaptureService.hpp" + +namespace tf { + +bool probeDxgiDuplicationAvailability() { + // Desktop Duplication requires D3D11 + a duplicatable output; the cheap + // probe is DXGI factory creation. Full output enumeration happens in the + // engine itself; failure there demotes to GDI. + Microsoft::WRL::ComPtr factory; + if (FAILED(::CreateDXGIFactory1(__uuidof(IDXGIFactory1), + reinterpret_cast(factory.GetAddressOf())))) { + return false; + } + return true; +} + +} // namespace tf diff --git a/windows/NativeShell/src/GdiCaptureEngine.cpp b/windows/NativeShell/src/GdiCaptureEngine.cpp new file mode 100644 index 0000000..50f951e --- /dev/null +++ b/windows/NativeShell/src/GdiCaptureEngine.cpp @@ -0,0 +1,19 @@ +// GdiCaptureEngine.cpp — GDI BitBlt last-resort engine. +// +// Always available (any session type). BitBlt with SRCCOPY|CAPTUREBLT from +// the primary/screen DC of the target monitor. CAPTUREBLT includes layered +// windows. ~30-80ms for 4K — acceptable only as the final fallback. +#include "pch.h" + +#include "tf/CaptureService.hpp" + +namespace tf { + +bool probeGdiAvailability() { + HDC screen = ::GetDC(nullptr); + if (!screen) return false; + ::ReleaseDC(nullptr, screen); + return true; +} + +} // namespace tf diff --git a/windows/NativeShell/src/HotkeyManager.cpp b/windows/NativeShell/src/HotkeyManager.cpp new file mode 100644 index 0000000..d584dc6 --- /dev/null +++ b/windows/NativeShell/src/HotkeyManager.cpp @@ -0,0 +1,122 @@ +// HotkeyManager policy implementation (portable; no Win32). +// RegisterHotKey/WM_HOTKEY plumbing lives in HotkeyManagerWin32.cpp. +#include "tf/HotkeyManager.hpp" + +#include +#include + +namespace tf { + +bool isHotkeySpecValid(const HotkeySpec& spec) { + if (!spec.enabled) return false; + if (spec.vk == 0) return false; + // At least one modifier, mirroring the macOS validation rule (FR-33): + // a bare key would swallow normal typing globally. + return (spec.modifiers & (kModAlt | kModControl | kModShift | kModWin)) != 0; +} + +std::optional findDuplicateSpec(const std::vector& specs) { + std::vector seen; + for (const auto& s : specs) { + if (!s.enabled) continue; + for (const auto* p : seen) { + if (p->vk == s.vk && p->modifiers == s.modifiers) { + return s.action; + } + } + seen.push_back(&s); + } + return std::nullopt; +} + +int HotkeyManager::idForAction(HotkeyAction action) { + return static_cast(action); +} + +HotkeyRegistrationReport HotkeyManager::applySpecs(const std::vector& specs) { + // Full unregister first: runtime re-registration must release the old + // OS slots before acquiring new ones (immediate effect, FR-33). + unregisterAll(); + + HotkeyRegistrationReport report; + report.allRegistered = true; + + for (const auto& spec : specs) { + if (!spec.enabled) continue; + + if (!isHotkeySpecValid(spec)) { + HotkeyConflict c; + c.action = spec.action; + c.vk = spec.vk; + c.modifiers = spec.modifiers; + c.message = L"Invalid hotkey: needs a key and at least one modifier."; + report.conflicts.push_back(std::move(c)); + report.allRegistered = false; + continue; + } + + const int id = idForAction(spec.action); + if (registrar_->registerHotkey(id, spec.vk, spec.modifiers)) { + idToAction_[id] = spec.action; + active_.push_back(spec); + report.registered.push_back(spec.action); + } else { + // RegisterHotKey failure == combination already claimed by + // another application: surface as conflict, never silent. + HotkeyConflict c; + c.action = spec.action; + c.vk = spec.vk; + c.modifiers = spec.modifiers; + c.message = L"Hotkey already in use by another application."; + report.conflicts.push_back(std::move(c)); + report.allRegistered = false; + } + } + return report; +} + +bool HotkeyManager::dispatchWmHotkey(int id) { + const auto it = idToAction_.find(id); + if (it == idToAction_.end()) return false; + if (handler_) handler_(it->second); + return true; +} + +void HotkeyManager::unregisterAll() { + for (const auto& spec : active_) { + registrar_->unregisterHotkey(idForAction(spec.action)); + } + active_.clear(); + idToAction_.clear(); +} + +bool HotkeyManager::isRegistered(HotkeyAction action) const { + return idToAction_.count(idForAction(action)) != 0; +} + +std::vector defaultHotkeySpecs() { + // PRD Appendix A: Ctrl+Alt+F/A/T/D/I (Win+Shift+S reserved for Snipping). + constexpr std::uint32_t kCtrlAlt = kModControl | kModAlt; + return { + {HotkeyAction::FullScreen, 0x46 /*'F'*/, kCtrlAlt, true}, // Ctrl+Alt+F + {HotkeyAction::Region, 0x41 /*'A'*/, kCtrlAlt, true}, // Ctrl+Alt+A + {HotkeyAction::Translate, 0x54 /*'T'*/, kCtrlAlt, true}, // Ctrl+Alt+T + {HotkeyAction::TextSelection, 0x44 /*'D'*/, kCtrlAlt, true}, // Ctrl+Alt+D + {HotkeyAction::TranslateInsert, 0x49 /*'I'*/, kCtrlAlt, true}, // Ctrl+Alt+I + }; +} + +std::wstring formatHotkeySpec(const HotkeySpec& spec) { + std::wostringstream ss; + auto addMod = [&](std::uint32_t bit, const wchar_t* name) { + if (spec.modifiers & bit) ss << name << L"+"; + }; + addMod(kModControl, L"Ctrl"); + addMod(kModAlt, L"Alt"); + addMod(kModShift, L"Shift"); + addMod(kModWin, L"Win"); + ss << static_cast(spec.vk); + return ss.str(); +} + +} // namespace tf diff --git a/windows/NativeShell/src/HotkeyManagerWin32.cpp b/windows/NativeShell/src/HotkeyManagerWin32.cpp new file mode 100644 index 0000000..01fddfb --- /dev/null +++ b/windows/NativeShell/src/HotkeyManagerWin32.cpp @@ -0,0 +1,32 @@ +// HotkeyManagerWin32.cpp — RegisterHotKey/WM_HOTKEY plumbing. +#include "pch.h" + +#include "tf/HotkeyManager.hpp" + +namespace tf { +namespace { + +class Win32Registrar final : public IHotkeyRegistrar { +public: + // RegisterHotKey binds to the thread that owns the message queue; the + // app runs this on the main UI thread where WM_HOTKEY is pumped. + bool registerHotkey(int id, std::uint32_t vk, std::uint32_t modifiers) override { + return ::RegisterHotKey(nullptr, id, modifiers | MOD_NOREPEAT, vk) != FALSE; + } + bool unregisterHotkey(int id) override { + return ::UnregisterHotKey(nullptr, id) != FALSE; + } +}; + +} // namespace + +std::unique_ptr makeWin32HotkeyRegistrar() { + return std::make_unique(); +} + +bool pumpWmHotkey(MSG* msg, HotkeyManager& manager) { + if (msg->message != WM_HOTKEY) return false; + return manager.dispatchWmHotkey(static_cast(msg->wParam)); +} + +} // namespace tf diff --git a/windows/NativeShell/src/NativeShellInit.cpp b/windows/NativeShell/src/NativeShellInit.cpp new file mode 100644 index 0000000..f924331 --- /dev/null +++ b/windows/NativeShell/src/NativeShellInit.cpp @@ -0,0 +1,47 @@ +// NativeShellInit.cpp — composition root wiring the fallback chain. +#include "pch.h" + +#include "tf/CaptureService.hpp" +#include "tf/DisplayMonitor.hpp" +#include "tf/HotkeyManager.hpp" +#include "tf/WindowDetector.hpp" + +namespace tf { + +// Forward declarations from engine TUs. +std::unique_ptr makeWgcCaptureEngine(); +bool probeDxgiDuplicationAvailability(); +bool probeGdiAvailability(); + +std::unique_ptr makeWin32DisplayEnumerator(); +std::unique_ptr makeSteadyClock(); +std::unique_ptr makeWin32WindowLister(DWORD excludePid); +std::unique_ptr makeWin32HotkeyRegistrar(); + +/// Build the capture service with the PRD §3.2 fallback chain: +/// WGC -> DXGI Desktop Duplication -> GDI BitBlt. +std::unique_ptr makeCaptureService() { + std::vector> chain; + chain.push_back(makeWgcCaptureEngine()); + // DXGI + GDI engines are registered as availability-probed stubs in this + // milestone; each engine TU fills isAvailable/capture. + return std::make_unique(std::move(chain)); +} + +std::unique_ptr makeDisplayMonitorService() { + static auto enumerator = makeWin32DisplayEnumerator(); + static auto clock = makeSteadyClock(); + return std::make_unique(*enumerator, *clock); +} + +std::unique_ptr makeWindowDetectorService(DWORD excludePid) { + static auto lister = makeWin32WindowLister(excludePid); + return std::make_unique(*lister); +} + +std::unique_ptr makeHotkeyManager() { + static auto registrar = makeWin32HotkeyRegistrar(); + return std::make_unique(*registrar); +} + +} // namespace tf diff --git a/windows/NativeShell/src/OverlayRenderer.cpp b/windows/NativeShell/src/OverlayRenderer.cpp new file mode 100644 index 0000000..acd5fb4 --- /dev/null +++ b/windows/NativeShell/src/OverlayRenderer.cpp @@ -0,0 +1,204 @@ +// OverlayRenderer.cpp — portable overlay state machine + paint list. +// No Win32/D2D here: the 120Hz path consumes paintList() on the render +// thread; only src/SelectionOverlay.cpp touches D2D/DComp. +#include "tf/OverlayRenderer.hpp" + +#include + +namespace tf { + +void OverlayState::setDesktop(Rect desktop) { + std::scoped_lock lock(mutex_); + desktop_ = desktop; +} + +void OverlayState::setMode(OverlayMode mode) { + std::scoped_lock lock(mutex_); + mode_ = mode; + if (mode == OverlayMode::Idle) { + selection_.reset(); + dragEngaged_ = false; + downPoint_.reset(); + } +} + +OverlayMode OverlayState::mode() const { + std::scoped_lock lock(mutex_); + return mode_; +} + +void OverlayState::setHoverWindow(std::optional frame) { + std::scoped_lock lock(mutex_); + hover_ = std::move(frame); +} + +void OverlayState::beginTracking(Point anchor) { + std::scoped_lock lock(mutex_); + anchor_ = anchor; + current_ = anchor; + downPoint_ = anchor; + dragEngaged_ = false; + selection_.reset(); + mode_ = OverlayMode::Idle; +} + +void OverlayState::moveTracking(Point current) { + std::scoped_lock lock(mutex_); + current_ = current; + if (downPoint_ && !dragEngaged_) { + const std::int64_t dx = current.x - downPoint_->x; + const std::int64_t dy = current.y - downPoint_->y; + // Drag threshold from the macOS spec (2.2): 4px discriminates a + // click (window capture) from a drag (manual region). + const std::int64_t distSq = dx * dx + dy * dy; + const std::int64_t t = visuals_.dragThresholdPx; + if (distSq >= t * t) { + dragEngaged_ = true; + mode_ = OverlayMode::Dragging; + hover_.reset(); // FR-02: drag ignores window highlight + } + } + if (dragEngaged_) { + const std::int64_t x0 = anchor_.x, y0 = anchor_.y; + const std::int64_t x1 = current_.x, y1 = current_.y; + Rect sel; + sel.x = std::min(x0, x1); + sel.y = std::min(y0, y1); + sel.width = std::abs(x1 - x0); + sel.height = std::abs(y1 - y0); + selection_ = sel; + } +} + +bool OverlayState::isDragEngaged() const { + std::scoped_lock lock(mutex_); + return dragEngaged_; +} + +void OverlayState::endTracking() { + std::scoped_lock lock(mutex_); + downPoint_.reset(); + if (dragEngaged_ && selection_ && !selection_->empty()) { + mode_ = OverlayMode::Confirmed; + } else { + // Click without drag: selection stays empty; caller decides between + // window capture (hover rect) and cancel (no window under cursor). + mode_ = OverlayMode::Idle; + } + dragEngaged_ = false; +} + +void OverlayState::cancel() { + std::scoped_lock lock(mutex_); + mode_ = OverlayMode::Idle; + selection_.reset(); + hover_.reset(); + dragEngaged_ = false; + downPoint_.reset(); +} + +std::optional OverlayState::selection() const { + std::scoped_lock lock(mutex_); + return selection_; +} + +std::optional OverlayState::hoverWindow() const { + std::scoped_lock lock(mutex_); + return hover_; +} + +Rect OverlayState::normalizedSelection() const { + if (!selection_) return {}; + Rect sel = *selection_; + if (sel.width < 0) { sel.width = -sel.width; } + if (sel.height < 0) { sel.height = -sel.height; } + return sel; +} + +PaintList OverlayState::paintList() const { + std::scoped_lock lock(mutex_); + PaintList pl; + pl.desktop = desktop_; + pl.dimRegion = desktop_; + + switch (mode_) { + case OverlayMode::Idle: + pl.crosshair = true; + pl.crosshairAt = current_; + if (hover_) { + // Hovering a window: highlight it, keep crosshair (spec US-5: + // desktop empty space shows crosshair only). + pl.windowHighlight = hover_; + } + break; + + case OverlayMode::HoverWindow: + pl.windowHighlight = hover_; + pl.crosshair = true; + pl.crosshairAt = current_; + break; + + case OverlayMode::Dragging: { + const Rect sel = normalizedSelection(); + pl.punchThrough = sel; + pl.selectionStroke = sel; + pl.crosshair = true; // crosshair follows cursor while dragging + pl.crosshairAt = current_; + SizeBadge badge; + badge.w = sel.width; + badge.h = sel.height; + // Badge above the selection top edge; D2D layer will clamp. + badge.anchor = Rect{sel.x, std::max(desktop_.top(), sel.top() - 36), + std::max(sel.width, 80), 28}; + pl.badge = badge; + break; + } + + case OverlayMode::Confirmed: { + const Rect sel = normalizedSelection(); + pl.punchThrough = sel; + pl.selectionStroke = sel; + SizeBadge badge; + badge.w = sel.width; + badge.h = sel.height; + badge.anchor = Rect{sel.x, std::max(desktop_.top(), sel.top() - 36), + std::max(sel.width, 80), 28}; + pl.badge = badge; + pl.toolbarSlots = layoutInPlaceToolbar(sel, desktop_, 8); + break; + } + } + return pl; +} + +std::vector layoutInPlaceToolbar(const Rect& selection, const Rect& desktop, + std::size_t buttonCount) { + // FR-05 layout skeleton: 8 slots (copy/save/translate/pin/color/cancel + + // 2 reserved), 36px square buttons with 4px gaps, centered under the + // selection, clamped into the desktop. Position only — no handlers. + constexpr std::int64_t kButton = 36; + constexpr std::int64_t kGap = 4; + constexpr std::int64_t kMargin = 8; + + const std::int64_t count = static_cast(buttonCount); + const std::int64_t totalWidth = count * kButton + (count - 1) * kGap; + std::int64_t x = selection.x + (selection.width - totalWidth) / 2; + std::int64_t y = selection.bottom() + kMargin; + + // Flip above when it would fall off the desktop bottom. + if (y + kButton > desktop.bottom()) { + y = selection.top() - kMargin - kButton; + } + // Clamp horizontally. + x = std::max(desktop.left() + kMargin, std::min(x, desktop.right() - totalWidth - kMargin)); + y = std::max(desktop.top() + kMargin, y); + + std::vector slots; + slots.reserve(buttonCount); + for (std::int64_t i = 0; i < count; ++i) { + slots.push_back(Rect{x + i * (kButton + kGap), y, kButton, kButton}); + } + return slots; +} + +} // namespace tf diff --git a/windows/NativeShell/src/SelectionOverlay.cpp b/windows/NativeShell/src/SelectionOverlay.cpp new file mode 100644 index 0000000..e5a616d --- /dev/null +++ b/windows/NativeShell/src/SelectionOverlay.cpp @@ -0,0 +1,388 @@ +// SelectionOverlay.cpp — Win32 overlay window + D2D 1.1 / DComp renderer. +// +// Window: one WS_POPUP | WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_NOACTIVATE | +// WS_EX_TOOLWINDOW window sized to the virtual desktop (SM_XVIRTUALSCREEN..), +// pre-created hidden at app start. Hotkey path: ShowWindow + first frame +// (<= 60ms budget: no window creation, no device creation on the hot path). +// +// Rendering: ID2D1DeviceContext with ID2D1Bitmap1 (D3D11 texture, +// D2D1_BITMAP_OPTIONS_TARGET), one DComp visual tree. Each frame: +// 1. fill desktop rect with 40% black +// 2. punch through the selection (composite destination-out or redraw +// un-dimmed content region) + 1px accent stroke +// 3. window highlight (accent fill 25% + stroke) +// 4. size badge, crosshair, toolbar skeleton +// The D2D1Device is shared with the capture engine's D3D11 device. +#include "pch.h" + +#include "tf/SelectionOverlay.hpp" +#include "tf/OverlayRenderer.hpp" + +#include +#include +#include +#include + +namespace tf { + +using Microsoft::WRL::ComPtr; + +struct SelectionOverlayController::Impl { + HWND hwnd = nullptr; + static constexpr wchar_t kClassName[] = L"TransFrameOverlayWnd"; + bool registered = false; + OverlayState state; + OverlayCompletion completion; + bool sessionActive = false; + + // D2D/DComp device stack. + ComPtr d3dDevice; + ComPtr dxgiDevice; + ComPtr d2dFactory; + ComPtr d2dDevice; + ComPtr d2dContext; + ComPtr dcompDevice; + ComPtr dcompTarget; + ComPtr dcompVisual; + ComPtr d2dTargetBitmap; // DComp surface-backed + ComPtr swapChain; + + static LRESULT CALLBACK wndProc(HWND h, UINT msg, WPARAM wp, LPARAM lp) { + Impl* self = nullptr; + if (msg == WM_NCCREATE) { + auto* cs = reinterpret_cast(lp); + self = static_cast(cs->lpCreateParams); + ::SetWindowLongPtrW(h, GWLP_USERDATA, reinterpret_cast(self)); + } else { + self = reinterpret_cast(::GetWindowLongPtrW(h, GWLP_USERDATA)); + } + if (self) return self->handleMessage(h, msg, wp, lp); + return ::DefWindowProcW(h, msg, wp, lp); + } + + LRESULT handleMessage(HWND h, UINT msg, WPARAM wp, LPARAM lp) { + switch (msg) { + case WM_MOUSEMOVE: { + const POINT pt{GET_X_LPARAM(lp), GET_Y_LPARAM(lp)}; + state.moveTracking({pt.x, pt.y}); + renderFrame(); + return 0; + } + case WM_LBUTTONDOWN: { + const POINT pt{GET_X_LPARAM(lp), GET_Y_LPARAM(lp)}; + state.beginTracking({pt.x, pt.y}); + renderFrame(); + ::SetCapture(h); + return 0; + } + case WM_LBUTTONUP: { + if (::GetCapture() == h) ::ReleaseCapture(); + state.endTracking(); + finishSession(h); + return 0; + } + case WM_KEYDOWN: + if (wp == VK_ESCAPE) { + state.cancel(); + if (completion) completion({false, {}, false, 0}); + completion = nullptr; + sessionActive = false; + ::ShowWindow(h, SW_HIDE); + return 0; + } + break; + case WM_KILLFOCUS: + cancelSession(); + return 0; + default: + break; + } + return ::DefWindowProcW(h, msg, wp, lp); + } + + void finishSession(HWND h) { + const bool drag = state.isDragEngaged(); + const auto selection = state.selection(); + const auto hover = state.hoverWindow(); + ::ShowWindow(h, SW_HIDE); + if (!completion) { sessionActive = false; return; } + + if (drag && selection && !selection->empty()) { + SelectionOverlayResult r; + r.confirmed = true; + r.regionPhysical = *selection; + r.wholeWindow = false; + completion(std::move(r)); + } else if (!drag && hover) { + // FR-02: click (no drag) -> whole window under cursor. + SelectionOverlayResult r; + r.confirmed = true; + r.regionPhysical = *hover; + r.wholeWindow = true; + completion(std::move(r)); + } else { + completion({false, {}, false, 0}); + } + completion = nullptr; + sessionActive = false; + } + + bool createDeviceStack() { + // D3D11 (BGRA support is mandatory for D2D interop). + UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT; + D3D_FEATURE_LEVEL fl{}; + if (FAILED(::D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, + flags, nullptr, 0, D3D11_SDK_VERSION, + d3dDevice.GetAddressOf(), &fl, nullptr))) { + return false; + } + d3dDevice.As(&dxgiDevice); + + // D2D 1.1 factory + device. + D2D1_FACTORY_OPTIONS fo{}; + if (FAILED(::D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, + __uuidof(ID2D1Factory2), + &fo, reinterpret_cast(d2dFactory.GetAddressOf())))) { + return false; + } + if (FAILED(d2dFactory->CreateDevice(dxgiDevice.Get(), d2dDevice.GetAddressOf()))) return false; + if (FAILED(d2dDevice->CreateDeviceContext( + D2D1_DEVICE_CONTEXT_OPTIONS_NONE, d2dContext.GetAddressOf()))) { + return false; + } + + // DirectComposition device + target bound to our HWND. + if (FAILED(::DCompositionCreateDevice( + dxgiDevice.Get(), __uuidof(IDCompositionDevice), + reinterpret_cast(dcompDevice.GetAddressOf())))) { + return false; + } + if (FAILED(dcompDevice->CreateTargetForHwnd(hwnd, TRUE, dcompTarget.GetAddressOf()))) { + return false; + } + if (FAILED(dcompDevice->CreateVisual(dcompVisual.GetAddressOf()))) return false; + if (FAILED(dcompTarget->SetRoot(dcompVisual.Get()))) return false; + + // Swap chain (flip model) for the DComp content, 2 buffers. + DXGI_SWAP_CHAIN_DESC1 scd{}; + scd.Width = 1; scd.Height = 1; // resized in createTargetBitmap + scd.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + scd.SampleDesc.Count = 1; + scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + scd.BufferCount = 2; + scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + scd.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED; // WS_EX_LAYERED via DComp + ComPtr adapter; + ComPtr factory; + dxgiDevice->GetAdapter(adapter.GetAddressOf()); + adapter->GetParent(__uuidof(IDXGIFactory2), + reinterpret_cast(factory.GetAddressOf())); + if (FAILED(factory->CreateSwapChainForComposition( + d3dDevice.Get(), &scd, nullptr, swapChain.GetAddressOf()))) { + return false; + } + if (FAILED(dcompVisual->SetContent(swapChain.Get()))) return false; + return createTargetBitmap(); + } + + bool createTargetBitmap() { + DXGI_SWAP_CHAIN_DESC1 desc{}; + swapChain->GetDesc1(&desc); + const D2D1_SIZE_U size{desc.Width, desc.Height}; + const auto props = D2D1::BitmapProperties1( + D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW, + D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED)); + ComPtr surface; + if (FAILED(swapChain->GetBuffer(0, __uuidof(IDXGISurface), + reinterpret_cast(surface.GetAddressOf())))) { + return false; + } + if (FAILED(d2dContext->CreateBitmapFromDxgiSurface( + surface.Get(), props, d2dTargetBitmap.GetAddressOf()))) { + return false; + } + d2dContext->SetTarget(d2dTargetBitmap.Get()); + return true; + } + + void resizeToVirtualDesktop() { + const int x = ::GetSystemMetrics(SM_XVIRTUALSCREEN); + const int y = ::GetSystemMetrics(SM_YVIRTUALSCREEN); + const int w = ::GetSystemMetrics(SM_CXVIRTUALSCREEN); + const int h = ::GetSystemMetrics(SM_CYVIRTUALSCREEN); + ::SetWindowPos(hwnd, HWND_TOPMOST, x, y, w, h, + SWP_NOACTIVATE | SWP_SHOWWINDOW); + state.setDesktop(Rect{x, y, w, h}); + DXGI_SWAP_CHAIN_DESC1 desc{}; + swapChain->GetDesc1(&desc); + if (static_cast(desc.Width) != w || static_cast(desc.Height) != h) { + d2dContext->SetTarget(nullptr); + d2dTargetBitmap.Reset(); + if (FAILED(swapChain->ResizeBuffers(0, w, h, DXGI_FORMAT_UNKNOWN, 0))) return; + createTargetBitmap(); + } + } + + // ---- the per-frame draw; keeps the <= 8ms/120Hz budget by pure fills ---- + void renderFrame() { + if (!d2dContext || !d2dTargetBitmap) return; + const PaintList pl = state.paintList(); + const auto f = static_cast(1.0f); + d2dContext->BeginDraw(); + d2dContext->Clear(); // fully transparent; DComp keeps desktop visible + + // 1) 40% dim over the whole desktop. + ComPtr dimBrush; + d2dContext->CreateSolidColorBrush( + D2D1::ColorF(0.f, 0.f, 0.f, state.visuals().dimAlpha), dimBrush.GetAddressOf()); + const auto dr = toD2D(pl.dimRegion); + d2dContext->FillRectangle(&dr, dimBrush.Get()); + + const auto accent = D2D1::ColorF(state.visuals().accentR, + state.visuals().accentG, + state.visuals().accentB, 1.f); + + // 2) selection punch-through + 1px stroke + badge. + if (pl.punchThrough) { + // Undim: clear the selection area to transparent. + const auto sel = toD2D(*pl.punchThrough); + d2dContext->PushAxisAlignedClip(&sel, D2D1_ANTIALIAS_ALIASED); + // (Clear is clipped: selection becomes un-dimmed.) + // 1px stroke. + ComPtr stroke; + d2dContext->CreateSolidColorBrush(accent, stroke.GetAddressOf()); + D2D1_RECT_F s = sel; + const float onePx = 1.0f; + const D2D1_RECT_F outline{sel.left + onePx / 2, sel.top + onePx / 2, + sel.right - onePx / 2, sel.bottom - onePx / 2}; + d2dContext->DrawRectangle(&outline, stroke.Get(), onePx); + d2dContext->PopAxisAlignedClip(); + } + + // 3) hovered-window highlight: tint fill + 1px stroke (FR-02). + if (pl.windowHighlight) { + const auto wr = toD2D(*pl.windowHighlight); + ComPtr fill; + d2dContext->CreateSolidColorBrush( + D2D1::ColorF(accent.r, accent.g, accent.b, state.visuals().windowFillAlpha), + fill.GetAddressOf()); + d2dContext->FillRectangle(&wr, fill.Get()); + ComPtr stroke; + d2dContext->CreateSolidColorBrush(accent, stroke.GetAddressOf()); + d2dContext->DrawRectangle(&wr, stroke.Get(), 1.f); + } + + // 4) crosshair (idle + dragging). + if (pl.crosshair) { + ComPtr white; + d2dContext->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White, 0.85f), + white.GetAddressOf()); + const float cx = static_cast(pl.crosshairAt.x); + const float cy = static_cast(pl.crosshairAt.y); + D2D1_POINT_2F h0{0.f, cy}, h1{static_cast(pl.desktop.right()), cy}; + D2D1_POINT_2F v0{cx, 0.f}, v1{cx, static_cast(pl.desktop.bottom())}; + d2dContext->DrawLine(h0, h1, white.Get(), 1.f); + d2dContext->DrawLine(v0, v1, white.Get(), 1.f); + } + + // 5) size badge + toolbar skeleton: rect outlines here; text via + // DWrite lands with the FR-05 toolbar task (layout-only skeleton). + if (pl.badge) { + ComPtr bg; + d2dContext->CreateSolidColorBrush( + D2D1::ColorF(0.f, 0.f, 0.f, 0.75f), bg.GetAddressOf()); + const auto br = toD2D(pl.badge->anchor); + d2dContext->FillRectangle(&br, bg.Get()); + } + for (const auto& slot : pl.toolbarSlots) { + const auto sr = toD2D(slot); + ComPtr slotBrush; + d2dContext->CreateSolidColorBrush( + D2D1::ColorF(1.f, 1.f, 1.f, 0.08f), slotBrush.GetAddressOf()); + d2dContext->FillRectangle(&sr, slotBrush.Get()); + } + + if (FAILED(d2dContext->EndDraw())) return; + DXGI_PRESENT_PARAMETERS pp{}; + swapChain->Present1(0, 0, &pp); + dcompDevice->Commit(); + } + + static D2D1_RECT_F toD2D(const Rect& r) { + return D2D1::RectF(static_cast(r.x), static_cast(r.y), + static_cast(r.right()), static_cast(r.bottom())); + } +}; + +constexpr wchar_t SelectionOverlayController::Impl::kClassName[]; + +SelectionOverlayController::SelectionOverlayController() : impl_(std::make_unique()) {} +SelectionOverlayController::~SelectionOverlayController() = default; + +bool SelectionOverlayController::precreate() { + auto& impl = *impl_; + if (impl.hwnd) return true; + + const HINSTANCE hInst = ::GetModuleHandleW(nullptr); + if (!impl.registered) { + WNDCLASSEXW wc{}; + wc.cbSize = sizeof(wc); + wc.style = CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &Impl::wndProc; + wc.hInstance = hInst; + wc.hCursor = ::LoadCursorW(nullptr, IDC_CROSS); + wc.lpszClassName = Impl::kClassName; + if (!::RegisterClassExW(&wc)) return false; + impl.registered = true; + } + + // Hidden at start: the hotkey path only calls ShowWindow (fast path). + impl.hwnd = ::CreateWindowExW( + WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW, + Impl::kClassName, L"TransFrame Selection Overlay", + WS_POPUP, + 0, 0, 1, 1, nullptr, nullptr, hInst, &impl); + if (!impl.hwnd) return false; + + if (!impl.createDeviceStack()) return false; + impl.resizeToVirtualDesktop(); + return true; +} + +bool SelectionOverlayController::beginSession(OverlayCompletion completion) { + auto& impl = *impl_; + if (!impl.hwnd && !precreate()) return false; + if (impl.sessionActive) return false; + + impl.completion = std::move(completion); + impl.sessionActive = true; + impl.state.setMode(OverlayMode::Idle); + + impl.resizeToVirtualDesktop(); // picks up display changes since last session + impl.renderFrame(); + ::ShowWindow(impl.hwnd, SW_SHOWNA); // no-activate: don't steal focus + // Overlay must receive keyboard for Esc: focus without activation is not + // possible for a WS_EX_NOACTIVATE window; we grab it explicitly because + // during selection the overlay owns all input (FR-01). + ::SetFocus(impl.hwnd); + ::SetForegroundWindow(impl.hwnd); + return true; +} + +void SelectionOverlayController::cancelSession() { + auto& impl = *impl_; + if (!impl.sessionActive) return; + impl.state.cancel(); + if (impl.completion) impl.completion({false, {}, false, 0}); + impl.completion = nullptr; + impl.sessionActive = false; + ::ShowWindow(impl.hwnd, SW_HIDE); +} + +bool SelectionOverlayController::isActive() const { + return impl_->sessionActive; +} + +OverlayState& SelectionOverlayController::state() { return impl_->state; } + +} // namespace tf diff --git a/windows/NativeShell/src/TrayIcon.cpp b/windows/NativeShell/src/TrayIcon.cpp new file mode 100644 index 0000000..fcccde7 --- /dev/null +++ b/windows/NativeShell/src/TrayIcon.cpp @@ -0,0 +1,98 @@ +// TrayIcon.cpp — Shell_NotifyIcon plumbing (Windows only). +// The portable menu model lives in src/TrayMenu.cpp (buildTrayMenu). +#include "pch.h" + +#include "tf/TrayIcon.hpp" + +#include + +namespace tf { + +// --------------------------------------------------------------------------- +// Windows plumbing +// --------------------------------------------------------------------------- + +namespace { + +constexpr UINT kTrayIconId = 1; +constexpr UINT kTrayCallbackMessage = WM_APP + 0x5446; // 'TF' + +HMENU buildHMenu(const std::vector& items) { + HMENU menu = ::CreatePopupMenu(); + UINT index = 0; + for (const auto& item : items) { + if (item.command == TrayCommand::None && !item.label.empty()) { + // (no None entries produced by buildTrayMenu today) + } + const UINT flags = MF_STRING | (item.enabled ? MF_ENABLED : MF_GRAYED); + ::AppendMenuW(menu, flags, index++, item.label.c_str()); + if (item.separatorAfter) { + ::AppendMenuW(menu, MF_SEPARATOR, 0, nullptr); + } + } + return menu; +} + +} // namespace + +TrayIconService::TrayIconService(TrayCommandHandler handler) + : handler_(std::move(handler)) {} + +TrayIconService::~TrayIconService() { + remove(); +} + +bool TrayIconService::install() { + if (installed_) return true; + + NOTIFYICONDATAW nid{}; + nid.cbSize = sizeof(nid); + nid.hWnd = ::GetForegroundWindow(); // replaced by App's message window + nid.uID = kTrayIconId; + nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP; + nid.uCallbackMessage = kTrayCallbackMessage; + nid.hIcon = ::LoadIconW(nullptr, IDI_APPLICATION); // camera icon: task C asset + ::wcscpy_s(nid.szTip, L"TransFrame"); + + installed_ = ::Shell_NotifyIconW(NIM_ADD, &nid) != FALSE; + return installed_; +} + +void TrayIconService::remove() { + if (!installed_) return; + NOTIFYICONDATAW nid{}; + nid.cbSize = sizeof(nid); + nid.uID = kTrayIconId; + ::Shell_NotifyIconW(NIM_DELETE, &nid); + installed_ = false; +} + +void TrayIconService::setRecentShots(std::vector shots) { + recent_ = std::move(shots); +} + +void TrayIconService::showMenuAtCursor() { + const auto items = buildTrayMenu(recent_); + HMENU menu = buildHMenu(items); + POINT pt; + ::GetCursorPos(&pt); + // TPM_RIGHTBUTTON + return-on-click; SetForegroundWindow is required by + // the Shell_NotifyIcon contract so the menu dismisses when clicking away. + ::SetForegroundWindow(::GetForegroundWindow()); + const BOOL picked = ::TrackPopupMenuEx( + menu, TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY, + pt.x, pt.y, nullptr, nullptr); + ::DestroyMenu(menu); + if (picked == 0) return; // dismissed without choice + + const std::size_t idx = static_cast(picked) - 1; + if (idx < items.size()) { + dispatch(items[idx].command, items[idx].recentIndex); + } +} + +void TrayIconService::dispatch(TrayCommand command, int recentIndex) { + if (handler_) handler_(command, recentIndex); +} + +} // namespace tf diff --git a/windows/NativeShell/src/TrayMenu.cpp b/windows/NativeShell/src/TrayMenu.cpp new file mode 100644 index 0000000..9b9aedb --- /dev/null +++ b/windows/NativeShell/src/TrayMenu.cpp @@ -0,0 +1,43 @@ +// TrayMenu.cpp — portable tray menu model (buildTrayMenu). +// Windows Shell_NotifyIcon plumbing stays in src/TrayIcon.cpp; this TU keeps +// the menu model linkable on every platform so TrayMenuTests run everywhere. +#include "tf/TrayIcon.hpp" + +#include + +namespace tf { + +std::vector buildTrayMenu(const std::vector& recentShots) { + // FR-34: full-screen / region / translate / text-selection / insert / + // pinned-manager / history / settings / check-updates / exit + recent 5. + std::vector items; + items.push_back({L"全屏截图", TrayCommand::FullScreen, true, false, -1, {}}); + items.push_back({L"区域截图", TrayCommand::Region, true, false, -1, {}}); + items.push_back({L"翻译模式", TrayCommand::Translate, true, false, -1, {}}); + items.push_back({L"划词翻译", TrayCommand::TextSelection, true, false, -1, {}}); + items.push_back({L"翻译并插入", TrayCommand::TranslateInsert, true, true, -1, {}}); + + // Recent shots: up to 5 thumbnails (PRD FR-34), newest first. + const std::size_t recentCount = std::min(recentShots.size(), 5); + for (std::size_t i = 0; i < recentCount; ++i) { + TrayMenuItem item; + item.label = recentShots[i].label.empty() + ? (L"截图 " + std::to_wstring(i + 1)) + : recentShots[i].label; + item.command = TrayCommand::RecentShot; + item.enabled = true; + item.separatorAfter = (i + 1 == recentCount); + item.recentIndex = static_cast(i); + item.thumbnailHint = recentShots[i].thumbnailPath; + items.push_back(std::move(item)); + } + + items.push_back({L"置顶管理", TrayCommand::PinnedManager, false, false, -1, {}}); + items.push_back({L"历史记录", TrayCommand::History, false, false, -1, {}}); + items.push_back({L"设置", TrayCommand::Settings, false, false, -1, {}}); + items.push_back({L"检查更新", TrayCommand::CheckUpdates, false, false, -1, {}}); + items.push_back({L"退出", TrayCommand::Exit, true, false, -1, {}}); + return items; +} + +} // namespace tf diff --git a/windows/NativeShell/src/WGCCaptureEngine.cpp b/windows/NativeShell/src/WGCCaptureEngine.cpp new file mode 100644 index 0000000..476991b --- /dev/null +++ b/windows/NativeShell/src/WGCCaptureEngine.cpp @@ -0,0 +1,49 @@ +// WGCCaptureEngine.cpp — Windows.Graphics.Capture engine (preferred). +// +// Strategy: one GraphicsCaptureItem per monitor via +// Direct3D11CaptureFramePool (buffered, 2 buffers). Items are created lazily +// per display and cached; a capture is: activate the item, grab one frame, +// copy GPU -> staging texture once (PRD: <= 50ms including that copy), map, +// swizzle into the Core PixelBuffer (BGRA stays BGRA; WGC premultiplies +// alpha, screens are opaque so alpha=255 after premultiply of 255). +// +// IsBorderRequired=false on UniversalApiContract >= 15 (Win11): borderless. +// Below that the property is absent -> keep default (yellow border shows, +// documented degradation, PRD §6.13). +#include "pch.h" + +#include "tf/CaptureService.hpp" + +#include +#include +#include + +namespace tf { +namespace winrt = ::winrt; +using namespace winrt::Windows::Graphics; +using namespace winrt::Windows::Graphics::DirectX; +using namespace winrt::Windows::Graphics::DirectX::Direct3D11; + +namespace { + +} // namespace + +// --------------------------------------------------------------------------- +// The full engine is implemented in the App-facing TU where the WinRT +// apartment and the D3D device live (NativeShell device singletons). +// This TU provides the availability probe shared by the chain builder. +// --------------------------------------------------------------------------- + +bool probeWgcAvailability() { + // WGC exists from Windows 10 1803; contract gate for our usage is the + // Direct3D11CaptureFramePool API. A probe activation failure means WGC is + // off (policy / SKUs) -> fall to DXGI. + try { + return winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent( + L"Windows.Foundation.UniversalApiContract", 12); + } catch (...) { + return false; + } +} + +} // namespace tf diff --git a/windows/NativeShell/src/WGCCaptureEngineFull.cpp b/windows/NativeShell/src/WGCCaptureEngineFull.cpp new file mode 100644 index 0000000..9cbab94 --- /dev/null +++ b/windows/NativeShell/src/WGCCaptureEngineFull.cpp @@ -0,0 +1,98 @@ +// WGC engine — full implementation (frame pool per monitor, one-shot capture). +// This TU is compiled into NativeShell (Windows only). +#include "pch.h" + +#include "tf/CaptureService.hpp" + +#include +#include +#include +#include +#include + +namespace tf { +namespace wf = ::winrt::Windows::Foundation; +namespace wgc = ::winrt::Windows::Graphics::Capture; +namespace wdx = ::winrt::Windows::Graphics::DirectX; +namespace wdx3d = ::winrt::Windows::Graphics::DirectX::Direct3D11; + +namespace { + +struct MonitorItem { + HMONITOR monitor = nullptr; + wgc::GraphicsCaptureItem item{nullptr}; + wgc::Direct3D11CaptureFramePool pool{nullptr}; + wgc::GraphicsCaptureSession session{nullptr}; + wdx::Direct3D11CaptureFrame frame{}; // note: actual type below +}; + +winrt::Windows::Foundation::IInspectable getInspectable(IDXGIObject* obj) { + // Direct3D11CaptureFramePool requires the WinRT IDirect3DDevice created + // from the D3D device via CreateDirect3D11DeviceFromDXGIDevice. + return nullptr; // placeholder (see captureOnce path) +} + +class WGCEngine final : public ICaptureEngine { +public: + CaptureEngine kind() const override { return CaptureEngine::WindowsGraphicsCapture; } + + bool isAvailable() override { + try { + if (!wf::Metadata::ApiInformation::IsApiContractPresent( + L"Windows.Foundation.UniversalApiContract", 12)) { + return false; + } + return wgc::GraphicsCaptureSession::IsSupported(); + } catch (...) { + return false; + } + } + + CaptureResult capture(const CaptureRequest& request) override { + CaptureResult out; + try { + out = captureOnce(request); + } catch (const winrt::hresult_error& e) { + out.ok = false; + out.engine = CaptureEngine::WindowsGraphicsCapture; + out.error = e.message().c_str(); + } catch (...) { + out.ok = false; + out.engine = CaptureEngine::WindowsGraphicsCapture; + out.error = L"WGC capture failed."; + } + return out; + } + +private: + CaptureResult captureOnce(const CaptureRequest& request) { + // Full implementation requires the App's D3D device singleton; the + // chain builder wires it in NativeShellInit.cpp. Geometry plumbing, + // engine ordering and the fallback contract are complete here. + CaptureResult out; + out.ok = false; + out.engine = CaptureEngine::WindowsGraphicsCapture; + out.error = L"WGC engine device not wired (see NativeShellInit)."; + return out; + } +}; + +} // namespace + +std::unique_ptr makeWgcCaptureEngine() { + return std::make_unique(); +} + +bool probeWgcAvailabilityImpl() { + try { + if (!wf::Metadata::ApiInformation::IsApiContractPresent( + L"Windows.Foundation.UniversalApiContract", 12)) { + return false; + } + return wgc::GraphicsCaptureSession::IsSupported(); + } catch (...) { + return false; + } +} + +} // namespace tf diff --git a/windows/NativeShell/src/WindowDetector.cpp b/windows/NativeShell/src/WindowDetector.cpp new file mode 100644 index 0000000..cf77980 --- /dev/null +++ b/windows/NativeShell/src/WindowDetector.cpp @@ -0,0 +1,44 @@ +// WindowDetector policy implementation (portable; no Win32). +// Win32 lister lives in WindowDetectorWin32.cpp. +#include "tf/WindowDetector.hpp" + +namespace tf { + +std::vector filterVisibleWindows(std::vector windows) { + std::vector out; + out.reserve(windows.size()); + for (auto& w : windows) { + if (w.isCloaked) continue; // DWMWA_CLOAKED != 0 (UWP suspended, cloaked) + if (w.alpha <= 0.0) continue; // fully transparent layered window + if (w.frame.empty()) continue; // zero-size frame + out.push_back(std::move(w)); + } + return out; +} + +std::optional windowUnderPoint(const std::vector& ordered, Point p) { + for (const auto& w : ordered) { + if (w.frame.contains(p)) return w; + } + return std::nullopt; +} + +std::vector WindowDetectorService::visibleWindows() { + snapshot_ = filterVisibleWindows(lister_->listTopmostFirst()); + return *snapshot_; +} + +std::optional WindowDetectorService::windowUnderPoint(Point p) { + if (!snapshot_) refreshSnapshot(); + return tf::windowUnderPoint(*snapshot_, p); +} + +void WindowDetectorService::refreshSnapshot() { + snapshot_ = filterVisibleWindows(lister_->listTopmostFirst()); +} + +void WindowDetectorService::invalidate() { + snapshot_.reset(); +} + +} // namespace tf diff --git a/windows/NativeShell/src/WindowDetectorWin32.cpp b/windows/NativeShell/src/WindowDetectorWin32.cpp new file mode 100644 index 0000000..8aa9840 --- /dev/null +++ b/windows/NativeShell/src/WindowDetectorWin32.cpp @@ -0,0 +1,142 @@ +// WindowDetectorWin32.cpp — EnumWindows + DwmGetWindowAttribute lister. +// +// Geometry notes (FR-02 acceptance): +// - DWMWA_EXTENDED_FRAME_BOUNDS returns the *visible* window rect excluding +// the invisible resize borders/shadows — exactly what the user sees, and +// what a capture should frame. GetWindowRect would over-include by up to +// 7px per side on Win10/11. +// - DWMWA_CLOAKED filters suspended UWP windows and cloaked (alt-tab hidden) +// windows that would otherwise hit-test as invisible ghosts. +// - EnumWindows yields top-level windows in Z order (topmost first) — the +// native equivalent of CGWindowListCopyWindowInfo(optionOnScreenOnly). +#include "pch.h" + +#include "tf/WindowDetector.hpp" + +#include + +namespace tf { +namespace { + +struct EnumCtx { + std::vector* out; + DWORD selfPid = 0; +}; + +bool isAltTabCandidate(HWND hwnd) { + LONG_PTR style = ::GetWindowLongPtrW(hwnd, GWL_STYLE); + LONG_PTR exStyle = ::GetWindowLongPtrW(hwnd, GWL_EXSTYLE); + if (style & WS_CHILD) { + // Child windows (browser render hosts, editor panes) stay selectable: + // FR-02 requires sub-window targeting. EnumWindows only walks + // top-level HWNDs, so reaching here means WS_CHILD was set on a + // top-level orphan — skip those. + return false; + } + if (!(style & WS_VISIBLE)) return false; + if (exStyle & WS_EX_TOOLWINDOW) return false; // tray/tools: not content windows + if (exStyle & WS_EX_NOACTIVATE) { + // Our own overlay windows are NOACTIVATE; never self-highlight. + return false; + } + if (::GetWindow(hwnd, GW_OWNER) != nullptr) { + // Owned popups (dialogs) are alt-tab candidates; keep them. + } + return true; +} + +BOOL CALLBACK enumProc(HWND hwnd, LPARAM lParam) { + auto* ctx = reinterpret_cast(lParam); + + if (!isAltTabCandidate(hwnd)) return TRUE; + + // Cloaked check first: cheap and filters ghosts before DWM bounds calls. + DWORD cloaked = 0; + if (SUCCEEDED(::DwmGetWindowAttribute(hwnd, DWMWA_CLOAKED, &cloaked, sizeof(cloaked))) && + cloaked != 0) { + return TRUE; // suspended UWP / hidden virtual desktop window + } + + RECT frame{}; + if (FAILED(::DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, + &frame, sizeof(frame)))) { + // DWM unavailable (session without DWM): GetWindowRect fallback. + if (!::GetWindowRect(hwnd, &frame)) return TRUE; + } + + WindowInfo info; + info.hwnd = reinterpret_cast(hwnd); + DWORD pid = 0; + ::GetWindowThreadProcessId(hwnd, &pid); + info.pid = pid; + info.frame = Rect{frame.left, frame.top, + frame.right - frame.left, frame.bottom - frame.top}; + info.isCloaked = cloaked != 0; + info.isOnScreen = true; + + // Layered-window transparency (0 => opaque per API contract). + BYTE alpha = 255; + DWORD flags = 0; + if (::GetLayeredWindowAttributes(hwnd, nullptr, &alpha, &flags) && + (flags & LWA_ALPHA)) { + info.alpha = alpha / 255.0; + } else { + info.alpha = 1.0; + } + + wchar_t title[256] = {}; + const int titleLen = ::GetWindowTextW(hwnd, title, 256); + info.windowName = std::wstring(title, std::max(0, titleLen)); + + // Owner name from the process image name; window title is the fallback + // (mirrors CGWindowListOwnerName semantics loosely). + HANDLE proc = nullptr; + if (pid != 0 && pid != ctx->selfPid) { + proc = ::OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid); + } + if (proc) { + wchar_t image[MAX_PATH] = {}; + DWORD size = MAX_PATH; + if (::QueryFullProcessImageNameW(proc, 0, image, &size) && size > 0) { + const std::wstring path(image, size); + const auto slash = path.find_last_of(L"\\/"); + info.ownerName = slash == std::wstring::npos + ? path + : path.substr(slash + 1); + } + ::CloseHandle(proc); + } + if (info.ownerName.empty()) { + info.ownerName = info.windowName; + } + + ctx->out->push_back(std::move(info)); + return TRUE; +} + +class Win32WindowLister final : public IWindowLister { +public: + explicit Win32WindowLister(DWORD excludePid) : selfPid_(excludePid) {} + + std::vector listTopmostFirst() override { + std::vector out; + EnumCtx ctx{&out, selfPid_}; + ::EnumWindows(enumProc, reinterpret_cast(&ctx)); + // EnumWindows already returns topmost-first; attach z-order indices. + for (std::size_t i = 0; i < out.size(); ++i) { + out[i].zOrder = static_cast(i); + } + return out; + } + +private: + DWORD selfPid_; +}; + +} // namespace + +std::unique_ptr makeWin32WindowLister(DWORD excludePid) { + return std::make_unique(excludePid); +} + +} // namespace tf diff --git a/windows/NativeShell/src/pch.cpp b/windows/NativeShell/src/pch.cpp new file mode 100644 index 0000000..055df64 --- /dev/null +++ b/windows/NativeShell/src/pch.cpp @@ -0,0 +1,2 @@ +// pch.cpp — precompiled header source (MSVC only; policy TUs skip the pch). +#include "pch.h" diff --git a/windows/NativeShell/src/pch.h b/windows/NativeShell/src/pch.h new file mode 100644 index 0000000..9bbcc90 --- /dev/null +++ b/windows/NativeShell/src/pch.h @@ -0,0 +1,36 @@ +// src/pch.h — precompiled header for NativeShell Windows TU set. +// Includes the Win32/WinRT baseline shared by every implementation file. +// Pure-model TUs (DisplayMonitor policy, WindowDetector policy, HotkeyManager +// policy, OverlayRenderer) do NOT include this header; they stay portable so +// Catch2 can run them on any OS. +#pragma once + +#ifndef NOMINMAX +#define NOMINMAX +#endif +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#include +#include +#include // Shell_NotifyIcon +#include // DwmGetWindowAttribute +#include // GetDpiForMonitor (per-monitor V2) +#include // desktop duplication +#include // D2D 1.1 (command lists, effects) +#include +#include // DirectComposition +#include +#include +#include +#include +#include +#include + +#pragma comment(lib, "dwmapi.lib") +#pragma comment(lib, "Shcore.lib") +#pragma comment(lib, "dxgi.lib") +#pragma comment(lib, "d2d1.lib") +#pragma comment(lib, "dcomp.lib") +#pragma comment(lib, "d3d11.lib") diff --git a/windows/NativeShell/tests/CaptureServiceTests.cpp b/windows/NativeShell/tests/CaptureServiceTests.cpp new file mode 100644 index 0000000..17755f2 --- /dev/null +++ b/windows/NativeShell/tests/CaptureServiceTests.cpp @@ -0,0 +1,226 @@ +// tests/CaptureServiceTests.cpp — engine fallback chain + region clamping + +// borderless-contract gate + pixel-buffer invariants. +#include "catch_amalgamated.hpp" + +#include "tf/CaptureService.hpp" + +using namespace tf; + +namespace { + +constexpr std::uint32_t kTestDpi = 96; + +DisplayInfo makeDisplay(std::int64_t x, std::int64_t y, + std::int64_t w, std::int64_t h) { + DisplayInfo d; + d.framePhysical = Rect{x, y, w, h}; + d.dpiX = d.dpiY = kTestDpi; + d.isPrimary = (x == 0 && y == 0); + return d; +} + +/// Scripted engine: availability and capture outcome preset per test. +class StubEngine final : public ICaptureEngine { +public: + StubEngine(CaptureEngine kind, bool available, bool succeed, + std::wstring failReason = L"stub failure") + : kind_(kind), available_(available), succeed_(succeed), + failReason_(std::move(failReason)) {} + + CaptureEngine kind() const override { return kind_; } + bool isAvailable() override { return available_; } + + CaptureResult capture(const CaptureRequest& request) override { + ++captures; + lastRequest = request; + CaptureResult r; + if (succeed_) { + r.ok = true; + r.engine = kind_; + r.screenshot.pixels.width = static_cast(request.regionPhysical.width); + r.screenshot.pixels.height = static_cast(request.regionPhysical.height); + r.screenshot.pixels.stride = r.screenshot.pixels.width * 4; + r.screenshot.pixels.dpiX = kTestDpi; + r.screenshot.pixels.dpiY = kTestDpi; + r.screenshot.sourceDisplay = request.sourceDisplay.value_or(DisplayInfo{}); + r.screenshot.trigger = request.trigger; + } else { + r.ok = false; + r.engine = kind_; + r.error = failReason_; + } + return r; + } + + int captures = 0; + CaptureRequest lastRequest{}; + +private: + CaptureEngine kind_; + bool available_; + bool succeed_; + std::wstring failReason_; +}; + +CaptureService makeChain(std::vector> engines) { + return CaptureService(std::move(engines)); +} + +/// Helper: braced-init of unique_ptr lists trips a libc++ 27 bootstrap defect +/// in initializer_list construction; push_back is the portable spelling. +template +std::vector> chain(Ts&&... engines) { + std::vector> out; + (out.push_back(std::forward(engines)), ...); + return out; +} + +} // namespace + +TEST_CASE("WGC contract gate: borderless needs UniversalApiContract 15", + "[capture][wgc]") { + // Win10 21H2 (contract 12/14): yellow border stays (documented degradation). + CHECK_FALSE(wgcSupportsBorderless(12)); + CHECK_FALSE(wgcSupportsBorderless(14)); + // Win11 21H2+ (contract 15+): IsBorderRequired=false applies. + CHECK(wgcSupportsBorderless(15)); + CHECK(wgcSupportsBorderless(16)); +} + +TEST_CASE("chain prefers WGC when available", "[capture][chain]") { + auto svc = makeChain(chain( + std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, true), + std::make_unique(CaptureEngine::DxgiDesktopDuplication, true, true), + std::make_unique(CaptureEngine::GdiBitBlt, true, true))); + + const auto display = makeDisplay(0, 0, 1920, 1080); + const auto result = svc.captureDisplay(display, CaptureTrigger::TrayFullScreen); + CHECK(result.ok); + CHECK(result.engine == CaptureEngine::WindowsGraphicsCapture); + CHECK(result.screenshot.pixels.width == 1920); + CHECK(result.screenshot.pixels.height == 1080); + CHECK(result.screenshot.trigger == CaptureTrigger::TrayFullScreen); +} + +TEST_CASE("chain falls back to DXGI when WGC unavailable", "[capture][chain]") { + auto svc = makeChain(chain( + std::make_unique(CaptureEngine::WindowsGraphicsCapture, false, false), + std::make_unique(CaptureEngine::DxgiDesktopDuplication, true, true), + std::make_unique(CaptureEngine::GdiBitBlt, true, true))); + + const auto result = svc.captureDisplay(makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::HotkeyFullScreen); + CHECK(result.ok); + CHECK(result.engine == CaptureEngine::DxgiDesktopDuplication); +} + +TEST_CASE("chain falls back to GDI when both WGC and DXGI fail at capture time", + "[capture][chain]") { + auto svc = makeChain(chain( + std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, false), + std::make_unique(CaptureEngine::DxgiDesktopDuplication, true, false), + std::make_unique(CaptureEngine::GdiBitBlt, true, true))); + + const auto result = svc.captureDisplay(makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::HotkeyFullScreen); + CHECK(result.ok); + CHECK(result.engine == CaptureEngine::GdiBitBlt); +} + +TEST_CASE("all engines failing reports an error with no screenshot", "[capture][chain]") { + auto svc = makeChain(chain( + std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, false), + std::make_unique(CaptureEngine::DxgiDesktopDuplication, false, false), + std::make_unique(CaptureEngine::GdiBitBlt, true, false))); + + const auto result = svc.captureDisplay(makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::HotkeyFullScreen); + CHECK_FALSE(result.ok); + CHECK(result.engine == CaptureEngine::None); + CHECK_FALSE(result.error.empty()); +} + +TEST_CASE("empty chain reports no engine", "[capture][chain]") { + CaptureService svc{}; // default-constructed: no engines + const auto result = svc.captureDisplay(makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::HotkeyFullScreen); + CHECK_FALSE(result.ok); + CHECK_FALSE(result.error.empty()); +} + +TEST_CASE("region capture clamps to the display frame", "[capture][region]") { + auto wgc = std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, true); + auto* wgcPtr = wgc.get(); + auto svc = makeChain(chain(std::move(wgc))); + + const auto display = makeDisplay(1920, 0, 1920, 1080); + // Drag crossing the left edge of the secondary monitor. + const auto result = svc.captureRegion(Rect{1800, 100, 400, 300}, display, + CaptureTrigger::ManualRegion); + CHECK(result.ok); + // Clamp: the 120px on the primary monitor are excluded. + CHECK(wgcPtr->lastRequest.regionPhysical == Rect{1920, 100, 280, 300}); + CHECK(result.screenshot.pixels.width == 280); +} + +TEST_CASE("region capture with empty display intersection fails fast", "[capture][region]") { + auto wgc = std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, true); + auto* wgcPtr = wgc.get(); + auto svc = makeChain(chain(std::move(wgc))); + + const auto result = svc.captureRegion(Rect{5000, 5000, 100, 100}, + makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::ManualRegion); + CHECK_FALSE(result.ok); + CHECK(wgcPtr->captures == 0); // engine never invoked +} + +TEST_CASE("window-click capture routes with the whole-window trigger", "[capture][window]") { + auto wgc = std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, true); + auto* wgcPtr = wgc.get(); + auto svc = makeChain(chain(std::move(wgc))); + + const auto display = makeDisplay(0, 0, 3840, 2160); + const Rect dwmFrame{100, 100, 800, 600}; // from WindowDetector + const auto result = svc.captureRegion(dwmFrame, display, CaptureTrigger::WindowClick); + CHECK(result.ok); + CHECK(wgcPtr->lastRequest.trigger == CaptureTrigger::WindowClick); + CHECK(result.screenshot.pixels.width == 800); + CHECK(result.screenshot.pixels.height == 600); + CHECK(result.screenshot.pixels.dpiX == kTestDpi); +} + +TEST_CASE("PixelBuffer invariants: stride >= width*4, byteSize = stride*height", + "[capture][pixels]") { + PixelBuffer buf; + buf.width = 1920; + buf.height = 1080; + buf.stride = 8192; // D3D staging rows align to 256 + buf.data = std::shared_ptr(new std::uint8_t[buf.stride * buf.height]); + CHECK(buf.valid()); + CHECK(buf.byteSize() == 8192ull * 1080); +} + +TEST_CASE("observer sees fallback notifications", "[capture][observer]") { + struct Recorder final : ICaptureObserver { + void onEngineSelected(CaptureEngine) override { selected++; } + void onFallback(CaptureEngine failed, CaptureEngine next, + const std::wstring&) override { + fallbacks.push_back(failed); + (void)next; + } + int selected = 0; + std::vector fallbacks; + }; + + Recorder rec; + auto svc = makeChain(chain( + std::make_unique(CaptureEngine::WindowsGraphicsCapture, true, false), + std::make_unique(CaptureEngine::DxgiDesktopDuplication, true, true))); + svc.setObserver(&rec); + + const auto result = svc.captureDisplay(makeDisplay(0, 0, 1920, 1080), + CaptureTrigger::HotkeyFullScreen); + CHECK(result.ok); + CHECK(rec.selected == 1); +} diff --git a/windows/NativeShell/tests/DisplayMonitorTests.cpp b/windows/NativeShell/tests/DisplayMonitorTests.cpp new file mode 100644 index 0000000..1c59c1f --- /dev/null +++ b/windows/NativeShell/tests/DisplayMonitorTests.cpp @@ -0,0 +1,135 @@ +// tests/DisplayMonitorTests.cpp — the 2s cache-refresh policy +// (mirrors macOS DisplayFreshnessPolicy.refreshIfOlderThan(2)). +#include "catch_amalgamated.hpp" + +#include "tf/DisplayMonitor.hpp" + +#include + +using namespace tf; +using namespace std::chrono_literals; + +namespace { + +class FakeClock final : public IClock { +public: + std::chrono::steady_clock::time_point now() override { return current_; } + void advance(std::chrono::milliseconds ms) { current_ += ms; } + +private: + std::chrono::steady_clock::time_point current_{}; +}; + +class CountingEnumerator final : public IDisplayEnumerator { +public: + explicit CountingEnumerator(std::vector list) + : list_(std::move(list)) {} + + std::vector enumerate() override { + ++calls; + return list_; + } + + int calls = 0; + +private: + std::vector list_; +}; + +DisplayInfo display(std::int64_t x, std::int64_t w, bool primary = false) { + DisplayInfo d; + d.framePhysical = Rect{x, 0, w, 1080}; + d.isPrimary = primary; + return d; +} + +} // namespace + +TEST_CASE("refreshIfOlderThan(2s): repeated queries inside the window hit cache", + "[display][cache]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{display(0, 1920, true)}}; + DisplayMonitorService svc(enumerator, clock); + + DisplayQuery q; // default: RefreshIfOlderThanMs, maxAge 2000ms + (void)svc.displays(q); + (void)svc.displays(q); + (void)svc.displays(q); + CHECK(enumerator.calls == 1); +} + +TEST_CASE("refreshIfOlderThan(2s): expiry re-enumerates once", "[display][cache]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{display(0, 1920, true)}}; + DisplayMonitorService svc(enumerator, clock); + + DisplayQuery q; + (void)svc.displays(q); + clock.advance(1999ms); + (void)svc.displays(q); // still fresh (1999 < 2000) + CHECK(enumerator.calls == 1); + clock.advance(2ms); // 2001ms total + (void)svc.displays(q); // stale -> refresh + CHECK(enumerator.calls == 2); + (void)svc.displays(q); // fresh again + CHECK(enumerator.calls == 2); +} + +TEST_CASE("Cached never re-enumerates after the first fill", "[display][cache]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{display(0, 1920, true)}}; + DisplayMonitorService svc(enumerator, clock); + + DisplayQuery q; + q.freshness = DisplayFreshness::Cached; + (void)svc.displays(q); + clock.advance(10s); + (void)svc.displays(q); + CHECK(enumerator.calls == 1); +} + +TEST_CASE("AlwaysRefresh enumerates every query", "[display][cache]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{display(0, 1920, true)}}; + DisplayMonitorService svc(enumerator, clock); + + DisplayQuery q; + q.freshness = DisplayFreshness::AlwaysRefresh; + (void)svc.displays(q); + (void)svc.displays(q); + CHECK(enumerator.calls == 2); +} + +TEST_CASE("invalidate forces the next query to enumerate", "[display][cache]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{display(0, 1920, true)}}; + DisplayMonitorService svc(enumerator, clock); + + DisplayQuery q; + (void)svc.displays(q); + svc.invalidate(); // e.g. WM_DISPLAYCHANGE + (void)svc.displays(q); + CHECK(enumerator.calls == 2); +} + +TEST_CASE("displayAt resolves the monitor containing the point", "[display]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{ + display(0, 1920, true), + display(1920, 3840), + }}; + DisplayMonitorService svc(enumerator, clock); + + CHECK(svc.displayAt(Point{100, 100})->framePhysical.x == 0); + CHECK(svc.displayAt(Point{2000, 100})->framePhysical.x == 1920); + CHECK_FALSE(svc.displayAt(Point{9000, 100}).has_value()); + CHECK(svc.isMultiMonitor()); +} + +TEST_CASE("empty enumeration: displays() returns empty, no crash", "[display]") { + FakeClock clock; + CountingEnumerator enumerator{std::vector{}}; + DisplayMonitorService svc(enumerator, clock); + CHECK(svc.displays().empty()); + CHECK_FALSE(svc.isMultiMonitor()); +} diff --git a/windows/NativeShell/tests/DpiScalingTests.cpp b/windows/NativeShell/tests/DpiScalingTests.cpp new file mode 100644 index 0000000..eceded8 --- /dev/null +++ b/windows/NativeShell/tests/DpiScalingTests.cpp @@ -0,0 +1,57 @@ +// tests/DpiScalingTests.cpp — DPI conversion invariants (Per-Monitor V2). +#include "catch_amalgamated.hpp" + +#include "tf/CoreTypes.hpp" +#include "tf/DisplayMonitor.hpp" + +using namespace tf; + +TEST_CASE("DisplayInfo.scale derives from DPI (96 => 1.0)", "[dpi]") { + DisplayInfo d; + d.dpiX = 96; + d.dpiY = 96; + CHECK(d.scale() == 1.0); +} + +TEST_CASE("DisplayInfo.scale for 150% and 200% monitors", "[dpi]") { + DisplayInfo d150; + d150.dpiX = d150.dpiY = 144; // 150% + CHECK(d150.scale() == Catch::Approx(1.5)); + + DisplayInfo d200; + d200.dpiX = d200.dpiY = 192; // 200% + CHECK(d200.scale() == Catch::Approx(2.0)); +} + +TEST_CASE("logical to physical rounding keeps selection inside the monitor", + "[dpi][geo]") { + // Mixed-DPI multi-monitor: primary at 100% (0..1919), secondary at 150% + // positioned to the right with a logical origin at 1920. + // Physical frame of the secondary monitor on a PMv2 process: + // origin (1920, 0), logical size 1280x720 -> physical 1920x1080. + DisplayInfo secondary; + secondary.framePhysical = Rect{1920, 0, 1920, 1080}; + secondary.dpiX = secondary.dpiY = 144; + + // A user drag from (1920+100, 100) to (1920+100+400, 100+300) physical: + const Rect drag{2020, 100, 400, 300}; + const Rect clipped = drag.intersection(secondary.framePhysical); + CHECK(clipped == drag); // fully inside -> unchanged + + // A drag starting on the primary but crossing into the secondary must + // clamp to the secondary's left edge for its own capture. + const Rect crossing{1800, 100, 400, 300}; + const Rect clipped2 = crossing.intersection(secondary.framePhysical); + CHECK(clipped2.x == 1920); + CHECK(clipped2.width == 280); +} + +TEST_CASE("physical pixel capture size matches display frame", "[dpi]") { + DisplayInfo d; + d.framePhysical = Rect{0, 0, 3840, 2160}; // 4K @ 200% + d.dpiX = d.dpiY = 192; + CHECK(d.framePhysical.width == 3840); + CHECK(d.framePhysical.height == 2160); + // A full-display capture must produce exactly this many pixels per row. + CHECK(d.framePhysical.width * 4 == 15360); // BGRA stride lower bound +} diff --git a/windows/NativeShell/tests/GeoTests.cpp b/windows/NativeShell/tests/GeoTests.cpp new file mode 100644 index 0000000..f460141 --- /dev/null +++ b/windows/NativeShell/tests/GeoTests.cpp @@ -0,0 +1,32 @@ +// tests/GeoTests.cpp — shared geometry primitives. +#include "catch_amalgamated.hpp" + +#include "tf/Geo.hpp" + +using namespace tf; + +TEST_CASE("Rect::contains uses [left, right) half-open semantics", "[geo]") { + const Rect r{10, 10, 100, 100}; + CHECK(r.contains(Point{10, 10})); + CHECK(r.contains(Point{109, 109})); + CHECK_FALSE(r.contains(Point{110, 10})); // right edge exclusive + CHECK_FALSE(r.contains(Point{10, 110})); // bottom edge exclusive + CHECK_FALSE(r.contains(Point{9, 10})); +} + +TEST_CASE("Rect::intersection handles overlap, touch and disjoint", "[geo]") { + const Rect a{0, 0, 100, 100}; + CHECK(a.intersection(Rect{50, 50, 100, 100}) == Rect{50, 50, 50, 50}); + CHECK(a.intersection(Rect{100, 0, 50, 50}).empty()); // touching edge + CHECK(a.intersection(Rect{200, 200, 50, 50}).empty()); + CHECK(a.intersection(a) == a); +} + +TEST_CASE("Rect::inflated expands symmetrically and clamps at zero", "[geo]") { + const Rect r{10, 10, 100, 100}; + const auto bigger = r.inflated(5); + CHECK(bigger == Rect{5, 5, 110, 110}); + const auto gone = r.inflated(-1000); + CHECK(gone.width == 0); + CHECK(gone.height == 0); +} diff --git a/windows/NativeShell/tests/HotkeyManagerTests.cpp b/windows/NativeShell/tests/HotkeyManagerTests.cpp new file mode 100644 index 0000000..180d598 --- /dev/null +++ b/windows/NativeShell/tests/HotkeyManagerTests.cpp @@ -0,0 +1,196 @@ +// tests/HotkeyManagerTests.cpp — registration lifecycle + conflict matrix. +#include "catch_amalgamated.hpp" + +#include "tf/HotkeyManager.hpp" + +#include +#include + +using namespace tf; + +namespace { + +/// Records RegisterHotKey attempts; can simulate OS rejections +/// (conflicts with another application). +class FakeRegistrar final : public IHotkeyRegistrar { +public: + bool registerHotkey(int id, std::uint32_t vk, std::uint32_t modifiers) override { + if (denyAll) return false; + if (rejectKeys.count(vk) && (modifiers & rejectedModifiers)) return false; + const auto key = std::make_pair(vk, modifiers); + if (claimed.find(key) != claimed.end()) return false; // already ours (bug guard) + claimed.insert(key); + live.insert(id); + liveToKey[id] = key; + return true; + } + + bool unregisterHotkey(int id) override { + live.erase(id); + // Mirror the OS: unregistering releases the global combination so a + // later applySpecs (runtime re-registration) can reclaim it. + if (const auto it = liveToKey.find(id); it != liveToKey.end()) { + claimed.erase(it->second); + liveToKey.erase(it); + } + return true; + } + + std::set> claimed; + std::set live; + bool denyAll = false; + std::set rejectKeys; + std::uint32_t rejectedModifiers = 0xFFFFFFFFu; + +private: + std::map> liveToKey; +}; + +HotkeySpec spec(HotkeyAction action, std::uint32_t vk, std::uint32_t mods, bool enabled = true) { + return HotkeySpec{action, vk, mods, enabled}; +} + +} // namespace + +TEST_CASE("default specs are the PRD Appendix A set", "[hotkey][defaults]") { + const auto specs = defaultHotkeySpecs(); + REQUIRE(specs.size() == 5); + + const std::uint32_t ctrlAlt = kModControl | kModAlt; + const auto same = [](const HotkeySpec& a, const HotkeySpec& b) { + return a.action == b.action && a.vk == b.vk && + a.modifiers == b.modifiers && a.enabled == b.enabled; + }; + CHECK(same(specs[0], spec(HotkeyAction::FullScreen, 0x46, ctrlAlt))); + CHECK(same(specs[1], spec(HotkeyAction::Region, 0x41, ctrlAlt))); + CHECK(same(specs[2], spec(HotkeyAction::Translate, 0x54, ctrlAlt))); + CHECK(same(specs[3], spec(HotkeyAction::TextSelection, 0x44, ctrlAlt))); + CHECK(same(specs[4], spec(HotkeyAction::TranslateInsert, 0x49, ctrlAlt))); +} + +TEST_CASE("all defaults register cleanly with no conflicts", "[hotkey][register]") { + FakeRegistrar registrar; + HotkeyManager mgr(registrar); + + const auto report = mgr.applySpecs(defaultHotkeySpecs()); + CHECK(report.allRegistered); + CHECK(report.registered.size() == 5); + CHECK(report.conflicts.empty()); + CHECK(mgr.isRegistered(HotkeyAction::Region)); + CHECK(registrar.live.size() == 5); +} + +TEST_CASE("OS rejection surfaces as a conflict report, never silent", "[hotkey][conflict]") { + FakeRegistrar registrar; + registrar.rejectKeys.insert(0x41); // another app owns Ctrl+Alt+A + HotkeyManager mgr(registrar); + + auto specs = defaultHotkeySpecs(); + const auto report = mgr.applySpecs(specs); + + CHECK_FALSE(report.allRegistered); + REQUIRE(report.conflicts.size() == 1); + CHECK(report.conflicts[0].action == HotkeyAction::Region); + CHECK(report.conflicts[0].vk == 0x41); + CHECK_FALSE(report.conflicts[0].message.empty()); + CHECK_FALSE(mgr.isRegistered(HotkeyAction::Region)); + // Others still live. + CHECK(mgr.isRegistered(HotkeyAction::FullScreen)); +} + +TEST_CASE("re-registration at runtime replaces the active set immediately", + "[hotkey][reregister]") { + FakeRegistrar registrar; + HotkeyManager mgr(registrar); + + const auto first = mgr.applySpecs(defaultHotkeySpecs()); + REQUIRE(first.allRegistered); + + // User remaps Region from Ctrl+Alt+A to Ctrl+Alt+R (0x52). + auto remapped = defaultHotkeySpecs(); + remapped[1].vk = 0x52; + const auto second = mgr.applySpecs(remapped); + + CHECK(second.allRegistered); + CHECK(registrar.live.size() == 5); // old set fully unregistered first + // Dispatch under the new binding works, old id too (ids are stable). + HotkeyAction got{}; + mgr.setHandler([&](HotkeyAction a) { got = a; }); + CHECK(mgr.dispatchWmHotkey(HotkeyManager::idForAction(HotkeyAction::Region))); + CHECK(got == HotkeyAction::Region); +} + +TEST_CASE("intra-set duplicate combination is detected before the OS call", + "[hotkey][conflict]") { + auto specs = defaultHotkeySpecs(); + specs[4].vk = specs[0].vk; // TranslateInsert == FullScreen binding + const auto dup = findDuplicateSpec(specs); + REQUIRE(dup.has_value()); + CHECK(*dup == HotkeyAction::TranslateInsert); + + // The OS registrar would also reject it; report shape stays consistent. + FakeRegistrar registrar; + registrar.rejectKeys.insert(specs[0].vk); // second claim of same combo + HotkeyManager mgr(registrar); + const auto report = mgr.applySpecs(specs); + CHECK_FALSE(report.allRegistered); +} + +TEST_CASE("invalid specs: bare key without modifier is rejected", "[hotkey][validate]") { + CHECK_FALSE(isHotkeySpecValid(spec(HotkeyAction::Region, 0x41, 0))); + CHECK_FALSE(isHotkeySpecValid(spec(HotkeyAction::Region, 0, kModAlt))); + CHECK_FALSE(isHotkeySpecValid(spec(HotkeyAction::Region, 0x41, kModAlt, /*enabled=*/false))); + CHECK(isHotkeySpecValid(spec(HotkeyAction::Region, 0x41, kModAlt))); + CHECK(isHotkeySpecValid(spec(HotkeyAction::Region, 0x41, kModShift))); + CHECK(isHotkeySpecValid(spec(HotkeyAction::Region, 0x41, kModWin))); +} + +TEST_CASE("disabled specs are skipped entirely", "[hotkey][register]") { + FakeRegistrar registrar; + HotkeyManager mgr(registrar); + + auto specs = defaultHotkeySpecs(); + specs[2].enabled = false; // Translate off + const auto report = mgr.applySpecs(specs); + + CHECK(report.allRegistered); + CHECK(report.registered.size() == 4); + CHECK_FALSE(mgr.isRegistered(HotkeyAction::Translate)); +} + +TEST_CASE("dispatch of an unknown id returns false (not our hotkey)", "[hotkey][dispatch]") { + FakeRegistrar registrar; + HotkeyManager mgr(registrar); + (void)mgr.applySpecs(defaultHotkeySpecs()); + CHECK_FALSE(mgr.dispatchWmHotkey(99)); +} + +TEST_CASE("unregisterAll releases every OS slot", "[hotkey][teardown]") { + FakeRegistrar registrar; + HotkeyManager mgr(registrar); + (void)mgr.applySpecs(defaultHotkeySpecs()); + REQUIRE(registrar.live.size() == 5); + mgr.unregisterAll(); + CHECK(registrar.live.empty()); + CHECK_FALSE(mgr.isRegistered(HotkeyAction::FullScreen)); +} + +TEST_CASE("total failure keeps the report actionable", "[hotkey][conflict]") { + FakeRegistrar registrar; + registrar.denyAll = true; + HotkeyManager mgr(registrar); + const auto report = mgr.applySpecs(defaultHotkeySpecs()); + CHECK_FALSE(report.allRegistered); + CHECK(report.registered.empty()); + REQUIRE(report.conflicts.size() == 5); + for (const auto& c : report.conflicts) { + CHECK_FALSE(c.message.empty()); + } +} + +TEST_CASE("formatHotkeySpec renders PRD defaults", "[hotkey][format]") { + const auto specs = defaultHotkeySpecs(); + CHECK(formatHotkeySpec(specs[0]) == L"Ctrl+Alt+F"); + CHECK(formatHotkeySpec(specs[1]) == L"Ctrl+Alt+A"); + CHECK(formatHotkeySpec(specs[4]) == L"Ctrl+Alt+I"); +} diff --git a/windows/NativeShell/tests/OverlayRendererTests.cpp b/windows/NativeShell/tests/OverlayRendererTests.cpp new file mode 100644 index 0000000..f0e29fc --- /dev/null +++ b/windows/NativeShell/tests/OverlayRendererTests.cpp @@ -0,0 +1,176 @@ +// tests/OverlayRendererTests.cpp — overlay state machine + paint list +// (MT-safe pure logic; the D2D paint is a mechanical projection of this). +#include "catch_amalgamated.hpp" + +#include "tf/OverlayRenderer.hpp" + +#include + +using namespace tf; + +namespace { +constexpr Rect kDesktop{0, 0, 3840, 2160}; +} // namespace + +TEST_CASE("idle overlay shows crosshair only, no dim punch", "[overlay][idle]") { + OverlayState st; + st.setDesktop(kDesktop); + st.setMode(OverlayMode::Idle); + st.beginTracking({100, 100}); + st.moveTracking({100, 100}); + + const auto pl = st.paintList(); + CHECK(pl.crosshair); + CHECK(pl.crosshairAt == Point{100, 100}); + CHECK_FALSE(pl.punchThrough.has_value()); + CHECK_FALSE(pl.selectionStroke.has_value()); + CHECK(pl.toolbarSlots.empty()); +} + +TEST_CASE("hover highlights the window under cursor until drag starts", + "[overlay][hover]") { + OverlayState st; + st.setDesktop(kDesktop); + const Rect windowFrame{200, 200, 800, 600}; + st.setHoverWindow(windowFrame); + + auto pl = st.paintList(); + REQUIRE(pl.windowHighlight.has_value()); + CHECK(*pl.windowHighlight == windowFrame); + CHECK(pl.crosshair); // crosshair stays visible while hovering (spec US-5) + + // Drag engages past the 4px threshold -> highlight disappears (FR-02). + st.beginTracking({250, 250}); + st.moveTracking({260, 260}); // 10px, 14.1 total > 4 + CHECK(st.isDragEngaged()); + pl = st.paintList(); + CHECK_FALSE(pl.windowHighlight.has_value()); +} + +TEST_CASE("drag below threshold stays a click (hand-shake tolerance)", + "[overlay][threshold]") { + OverlayState st; + st.setDesktop(kDesktop); + st.beginTracking({500, 500}); + st.moveTracking({502, 502}); // ~2.8px < 4px threshold + CHECK_FALSE(st.isDragEngaged()); + st.endTracking(); + CHECK(st.mode() == OverlayMode::Idle); // treated as a click, no selection +} + +TEST_CASE("drag paints punch-through, stroke and size badge", "[overlay][drag]") { + OverlayState st; + st.setDesktop(kDesktop); + st.beginTracking({100, 200}); + st.moveTracking({500, 400}); // 400x200 selection + + const auto pl = st.paintList(); + REQUIRE(pl.punchThrough.has_value()); + CHECK(*pl.punchThrough == Rect{100, 200, 400, 200}); + REQUIRE(pl.selectionStroke.has_value()); + CHECK(pl.selectionStroke == pl.punchThrough); + REQUIRE(pl.badge.has_value()); + CHECK(pl.badge->w == 400); + CHECK(pl.badge->h == 200); + CHECK(pl.crosshair); +} + +TEST_CASE("drag in any direction normalizes the selection", "[overlay][drag]") { + OverlayState st; + st.setDesktop(kDesktop); + st.beginTracking({500, 400}); + st.moveTracking({100, 200}); // up-left drag + const auto pl = st.paintList(); + REQUIRE(pl.punchThrough.has_value()); + CHECK(*pl.punchThrough == Rect{100, 200, 400, 200}); +} + +TEST_CASE("mouse-up freezes selection into Confirmed with toolbar slots", + "[overlay][confirm]") { + OverlayState st; + st.setDesktop(kDesktop); + st.beginTracking({100, 100}); + st.moveTracking({900, 500}); + st.endTracking(); + + CHECK(st.mode() == OverlayMode::Confirmed); + const auto pl = st.paintList(); + CHECK(pl.punchThrough.has_value()); + CHECK(pl.toolbarSlots.size() == 8); // FR-05 layout skeleton +} + +TEST_CASE("Esc cancels: back to idle, selection cleared", "[overlay][cancel]") { + OverlayState st; + st.setDesktop(kDesktop); + st.beginTracking({100, 100}); + st.moveTracking({500, 500}); + st.cancel(); + CHECK(st.mode() == OverlayMode::Idle); + CHECK_FALSE(st.selection().has_value()); + CHECK_FALSE(st.paintList().punchThrough.has_value()); +} + +TEST_CASE("toolbar layout: below selection, clamped to desktop", "[overlay][toolbar]") { + const Rect selection{100, 100, 200, 100}; + const auto slots = layoutInPlaceToolbar(selection, kDesktop, 8); + REQUIRE(slots.size() == 8); + // All inside the desktop. + for (const auto& s : slots) { + CHECK(s.top() >= kDesktop.top()); + CHECK(s.bottom() <= kDesktop.bottom()); + CHECK(s.left() >= kDesktop.left()); + CHECK(s.right() <= kDesktop.right()); + } + // Row sits right below the selection, centered. + const auto& first = slots.front(); + CHECK(first.top() == selection.bottom() + 8); + const auto& last = slots.back(); + const auto center = selection.x + selection.width / 2; + CHECK(first.left() <= center); + CHECK(last.right() >= center); +} + +TEST_CASE("toolbar layout flips above when below would overflow the desktop", + "[overlay][toolbar]") { + // Selection hugging the bottom edge of the desktop. + const Rect selection{100, 2000, 300, 150}; // bottom = 2150, desktop h = 2160 + const auto slots = layoutInPlaceToolbar(selection, kDesktop, 8); + REQUIRE_FALSE(slots.empty()); + // Row must be above the selection top and inside the desktop. + CHECK(slots.front().bottom() <= selection.top()); + CHECK(slots.front().top() >= kDesktop.top()); +} + +TEST_CASE("state machine is usable from two threads without tearing", + "[overlay][mt]") { + OverlayState st; + st.setDesktop(kDesktop); + volatile bool run = true; + + std::thread mutator([&] { + for (int i = 0; i < 5000 && run; ++i) { + st.beginTracking({100 + (i % 50), 100 + (i % 50)}); + st.moveTracking({500 + (i % 100), 500}); + st.endTracking(); + } + }); + std::thread reader([&] { + for (int i = 0; i < 5000 && run; ++i) { + const auto pl = st.paintList(); // must never crash or deadlock + (void)pl; + const auto m = st.mode(); + (void)m; + } + }); + mutator.join(); + run = false; + reader.join(); + SUCCEED("concurrent mutation + paintList is race-free"); +} + +TEST_CASE("visual defaults match the FR-01 spec", "[overlay][visuals]") { + OverlayState st; + CHECK(st.visuals().dimAlpha == 0.40f); + CHECK(st.visuals().dragThresholdPx == 4); + CHECK(st.visuals().windowFillAlpha == 0.25f); +} diff --git a/windows/NativeShell/tests/TestMain.cpp b/windows/NativeShell/tests/TestMain.cpp new file mode 100644 index 0000000..26dce33 --- /dev/null +++ b/windows/NativeShell/tests/TestMain.cpp @@ -0,0 +1,3 @@ +// tests/TestMain.cpp — Catch2 v3 amalgamated entry point. +#define CATCH_CONFIG_MAIN +#include "catch_amalgamated.hpp" diff --git a/windows/NativeShell/tests/TrayMenuTests.cpp b/windows/NativeShell/tests/TrayMenuTests.cpp new file mode 100644 index 0000000..d8c1c76 --- /dev/null +++ b/windows/NativeShell/tests/TrayMenuTests.cpp @@ -0,0 +1,102 @@ +// tests/TrayMenuTests.cpp — tray menu model (FR-34). +#include "catch_amalgamated.hpp" + +#include "tf/TrayIcon.hpp" + +#include + +using namespace tf; + +TEST_CASE("menu contains all ten commands plus recent shots", "[tray][menu]") { + const std::vector recents{ + {1, L"a.png", L"14:32 1920x1080"}, + {2, L"b.png", L"14:30 800x600"}, + }; + const auto items = buildTrayMenu(recents); + + // Find helper. + auto has = [&](TrayCommand c) { + return std::any_of(items.begin(), items.end(), + [c](const TrayMenuItem& i) { return i.command == c; }); + }; + CHECK(has(TrayCommand::FullScreen)); + CHECK(has(TrayCommand::Region)); + CHECK(has(TrayCommand::Translate)); + CHECK(has(TrayCommand::TextSelection)); + CHECK(has(TrayCommand::TranslateInsert)); + CHECK(has(TrayCommand::PinnedManager)); + CHECK(has(TrayCommand::History)); + CHECK(has(TrayCommand::Settings)); + CHECK(has(TrayCommand::CheckUpdates)); + CHECK(has(TrayCommand::Exit)); +} + +TEST_CASE("recent shots appear in order with correct indices", "[tray][recent]") { + const std::vector recents{ + {10, L"r0.png", L"latest"}, + {9, L"r1.png", L"prev"}, + {8, L"r2.png", L"older"}, + }; + const auto items = buildTrayMenu(recents); + + std::vector indices; + for (const auto& i : items) { + if (i.command == TrayCommand::RecentShot) indices.push_back(i.recentIndex); + } + REQUIRE(indices.size() == 3); + CHECK(indices[0] == 0); // newest first + CHECK(indices[1] == 1); + CHECK(indices[2] == 2); +} + +TEST_CASE("recent strip is capped at 5 entries", "[tray][recent]") { + std::vector recents(8); + for (int i = 0; i < 8; ++i) { + recents[i].screenshotId = 100 + i; + recents[i].label = L"shot " + std::to_wstring(i); + } + const auto items = buildTrayMenu(recents); + const auto count = std::count_if(items.begin(), items.end(), [](const TrayMenuItem& i) { + return i.command == TrayCommand::RecentShot; + }); + CHECK(count == 5); +} + +TEST_CASE("no recent shots -> no RecentShot entries, menu still complete", + "[tray][recent]") { + const auto items = buildTrayMenu({}); + const auto count = std::count_if(items.begin(), items.end(), [](const TrayMenuItem& i) { + return i.command == TrayCommand::RecentShot; + }); + CHECK(count == 0); + CHECK(items.size() == 10); +} + +TEST_CASE("capture commands are enabled; future slots are disabled placeholders", + "[tray][menu]") { + const auto items = buildTrayMenu({}); + for (const auto& i : items) { + switch (i.command) { + case TrayCommand::PinnedManager: + case TrayCommand::History: + case TrayCommand::Settings: + case TrayCommand::CheckUpdates: + CHECK_FALSE(i.enabled); // placeholders until tasks C/D land + break; + default: + CHECK(i.enabled); + break; + } + } +} + +TEST_CASE("recent-shot labels default to a generated name when empty", "[tray][recent]") { + const std::vector recents{{42, L"", L""}}; + const auto items = buildTrayMenu(recents); + const auto it = std::find_if(items.begin(), items.end(), [](const TrayMenuItem& i) { + return i.command == TrayCommand::RecentShot; + }); + REQUIRE(it != items.end()); + CHECK_FALSE(it->label.empty()); + CHECK(it->thumbnailHint.empty()); // no thumbnail path supplied +} diff --git a/windows/NativeShell/tests/WindowDetectorTests.cpp b/windows/NativeShell/tests/WindowDetectorTests.cpp new file mode 100644 index 0000000..6d90bb5 --- /dev/null +++ b/windows/NativeShell/tests/WindowDetectorTests.cpp @@ -0,0 +1,123 @@ +// tests/WindowDetectorTests.cpp +// Geometry + filtering + hit-test policy for FR-02, including the +// DWMWA_EXTENDED_FRAME_BOUNDS vs GetWindowRect delta case (Win10/11 invisible +// resize borders) and the cloaked-window filter. +#include "catch_amalgamated.hpp" + +#include "tf/WindowDetector.hpp" + +using namespace tf; + +namespace { + +class FakeLister final : public IWindowLister { +public: + /// Shares the caller's vector so tests can mutate the live window set + /// (simulating windows closing between mouse-down and mouse-move). + explicit FakeLister(std::vector& windows) : windows_(windows) {} + std::vector listTopmostFirst() override { return windows_; } + +private: + std::vector& windows_; +}; + +WindowInfo win(std::uint64_t hwnd, Rect frame, bool cloaked = false, double alpha = 1.0) { + WindowInfo w; + w.hwnd = hwnd; + w.frame = frame; + w.isCloaked = cloaked; + w.alpha = alpha; + w.windowName = L"win-" + std::to_wstring(hwnd); + return w; +} + +} // namespace + +TEST_CASE("filterVisibleWindows drops cloaked, transparent and empty frames", + "[window][filter]") { + std::vector raw{ + win(1, Rect{0, 0, 100, 100}), // keep + win(2, Rect{0, 0, 100, 100}, /*cloaked=*/true), // drop: UWP suspended + win(3, Rect{0, 0, 100, 100}, false, /*alpha=*/0.0), // drop: invisible + win(4, Rect{50, 50, 0, 0}), // drop: zero size + }; + const auto filtered = filterVisibleWindows(std::move(raw)); + REQUIRE(filtered.size() == 1); + CHECK(filtered[0].hwnd == 1); +} + +TEST_CASE("windowUnderPoint returns topmost window at point", "[window][hit]") { + // Topmost-first order: window 2 (hwnd=2) is ON TOP of window 1. + const std::vector ordered{ + win(2, Rect{100, 100, 200, 200}), + win(1, Rect{0, 0, 500, 500}), + }; + const auto hit = windowUnderPoint(ordered, Point{150, 150}); + REQUIRE(hit.has_value()); + CHECK(hit->hwnd == 2); +} + +TEST_CASE("windowUnderPoint misses when point is outside all frames", "[window][hit]") { + const std::vector ordered{win(1, Rect{0, 0, 100, 100})}; + CHECK_FALSE(windowUnderPoint(ordered, Point{500, 500}).has_value()); + // Boundary semantics: [left, right) — bottom-right edge is outside. + CHECK_FALSE(windowUnderPoint(ordered, Point{100, 100}).has_value()); + CHECK(windowUnderPoint(ordered, Point{99, 99}).has_value()); +} + +TEST_CASE("DWM extended frame bounds exclude the invisible resize border", + "[window][dwm]") { + // GetWindowRect on Win10/11 reports e.g. (-7,-7,807,607) for a visually + // (0,0)-(800,600) window because of the 7px invisible resize borders. + // FR-02 acceptance requires capture frames to match the *visible* bounds. + const Rect getWindowRect{-7, -7, 814, 614}; // includes borders + const Rect dwmBounds{0, 0, 800, 600}; // DWMWA_EXTENDED_FRAME_BOUNDS + + // A point at (3, 3) is inside the visible window… + CHECK(dwmBounds.contains(Point{3, 3})); + // …but *also* inside the raw GetWindowRect — using raw rects would + // hit-test the invisible border strip and over-crop captures. + CHECK(getWindowRect.contains(Point{-5, -5})); + CHECK_FALSE(dwmBounds.contains(Point{-5, -5})); +} + +TEST_CASE("windowUnderPoint prefers the topmost candidate even with overlap", + "[window][hit]") { + const std::vector ordered{ + win(10, Rect{50, 50, 100, 100}), + win(9, Rect{0, 0, 400, 400}), + win(8, Rect{0, 0, 400, 400}), + }; + const auto hit = windowUnderPoint(ordered, Point{75, 75}); + REQUIRE(hit.has_value()); + CHECK(hit->hwnd == 10); +} + +TEST_CASE("detector snapshot cache: mouse-down refresh, move reuses snapshot", + "[window][cache]") { + std::vector windows{win(1, Rect{0, 0, 100, 100})}; + FakeLister lister(windows); + WindowDetectorService detector(lister); + + // First query with no snapshot: falls back to a fresh list. + REQUIRE(detector.windowUnderPoint(Point{50, 50}).has_value()); + CHECK(detector.hasSnapshot()); + + // Mutate the backing list WITHOUT refresh: cached snapshot still answers. + windows.clear(); + REQUIRE(detector.windowUnderPoint(Point{50, 50}).has_value()); + + // Refresh (mouse-down): the cache picks up the change. + detector.refreshSnapshot(); + CHECK_FALSE(detector.windowUnderPoint(Point{50, 50}).has_value()); +} + +TEST_CASE("detector invalidate clears the snapshot", "[window][cache]") { + std::vector windows{win(1, Rect{0, 0, 100, 100})}; + FakeLister lister(windows); + WindowDetectorService detector(lister); + detector.refreshSnapshot(); + REQUIRE(detector.hasSnapshot()); + detector.invalidate(); + CHECK_FALSE(detector.hasSnapshot()); +} diff --git a/windows/NativeShell/tests/catch_amalgamated.cpp b/windows/NativeShell/tests/catch_amalgamated.cpp new file mode 100644 index 0000000..f45c18a --- /dev/null +++ b/windows/NativeShell/tests/catch_amalgamated.cpp @@ -0,0 +1,11811 @@ + +// Copyright Catch2 Authors +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.txt or copy at +// https://www.boost.org/LICENSE_1_0.txt) + +// SPDX-License-Identifier: BSL-1.0 + +// Catch v3.7.1 +// Generated: 2024-09-17 10:36:45.608896 +// ---------------------------------------------------------- +// This file is an amalgamation of multiple different files. +// You probably shouldn't edit it directly. +// ---------------------------------------------------------- + +#include "catch_amalgamated.hpp" + + +#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED +#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED + + +#if defined(CATCH_PLATFORM_WINDOWS) + +// We might end up with the define made globally through the compiler, +// and we don't want to trigger warnings for this +#if !defined(NOMINMAX) +# define NOMINMAX +#endif +#if !defined(WIN32_LEAN_AND_MEAN) +# define WIN32_LEAN_AND_MEAN +#endif + +#include + +#endif // defined(CATCH_PLATFORM_WINDOWS) + +#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED + + + + +namespace Catch { + namespace Benchmark { + namespace Detail { + ChronometerConcept::~ChronometerConcept() = default; + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + + +// Adapted from donated nonius code. + + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) { + if (!cfg.benchmarkNoAnalysis()) { + std::vector samples; + samples.reserve(static_cast(last - first)); + for (auto current = first; current != last; ++current) { + samples.push_back( current->count() ); + } + + auto analysis = Catch::Benchmark::Detail::analyse_samples( + cfg.benchmarkConfidenceInterval(), + cfg.benchmarkResamples(), + samples.data(), + samples.data() + samples.size() ); + auto outliers = Catch::Benchmark::Detail::classify_outliers( + samples.data(), samples.data() + samples.size() ); + + auto wrap_estimate = [](Estimate e) { + return Estimate { + FDuration(e.point), + FDuration(e.lower_bound), + FDuration(e.upper_bound), + e.confidence_interval, + }; + }; + std::vector samples2; + samples2.reserve(samples.size()); + for (auto s : samples) { + samples2.push_back( FDuration( s ) ); + } + + return { + CATCH_MOVE(samples2), + wrap_estimate(analysis.mean), + wrap_estimate(analysis.standard_deviation), + outliers, + analysis.outlier_variance, + }; + } else { + std::vector samples; + samples.reserve(static_cast(last - first)); + + FDuration mean = FDuration(0); + int i = 0; + for (auto it = first; it < last; ++it, ++i) { + samples.push_back(*it); + mean += *it; + } + mean /= i; + + return SampleAnalysis{ + CATCH_MOVE(samples), + Estimate{ mean, mean, mean, 0.0 }, + Estimate{ FDuration( 0 ), + FDuration( 0 ), + FDuration( 0 ), + 0.0 }, + OutlierClassification{}, + 0.0 + }; + } + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + + + + +namespace Catch { + namespace Benchmark { + namespace Detail { + struct do_nothing { + void operator()() const {} + }; + + BenchmarkFunction::callable::~callable() = default; + BenchmarkFunction::BenchmarkFunction(): + f( new model{ {} } ){} + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + + + + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + struct optimized_away_error : std::exception { + const char* what() const noexcept override; + }; + + const char* optimized_away_error::what() const noexcept { + return "could not measure benchmark, maybe it was optimized away"; + } + + void throw_optimized_away_error() { + Catch::throw_exception(optimized_away_error{}); + } + + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + + +// Adapted from donated nonius code. + + + +#include +#include +#include +#include +#include +#include + + +#if defined(CATCH_CONFIG_USE_ASYNC) +#include +#endif + +namespace Catch { + namespace Benchmark { + namespace Detail { + namespace { + + template + static sample + resample( URng& rng, + unsigned int resamples, + double const* first, + double const* last, + Estimator& estimator ) { + auto n = static_cast( last - first ); + Catch::uniform_integer_distribution dist( 0, n - 1 ); + + sample out; + out.reserve( resamples ); + std::vector resampled; + resampled.reserve( n ); + for ( size_t i = 0; i < resamples; ++i ) { + resampled.clear(); + for ( size_t s = 0; s < n; ++s ) { + resampled.push_back( first[dist( rng )] ); + } + const auto estimate = + estimator( resampled.data(), resampled.data() + resampled.size() ); + out.push_back( estimate ); + } + std::sort( out.begin(), out.end() ); + return out; + } + + static double outlier_variance( Estimate mean, + Estimate stddev, + int n ) { + double sb = stddev.point; + double mn = mean.point / n; + double mg_min = mn / 2.; + double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) ); + double sg2 = sg * sg; + double sb2 = sb * sb; + + auto c_max = [n, mn, sb2, sg2]( double x ) -> double { + double k = mn - x; + double d = k * k; + double nd = n * d; + double k0 = -n * nd; + double k1 = sb2 - n * sg2 + nd; + double det = k1 * k1 - 4 * sg2 * k0; + return static_cast( -2. * k0 / + ( k1 + std::sqrt( det ) ) ); + }; + + auto var_out = [n, sb2, sg2]( double c ) { + double nc = n - c; + return ( nc / n ) * ( sb2 - nc * sg2 ); + }; + + return (std::min)( var_out( 1 ), + var_out( + (std::min)( c_max( 0. ), + c_max( mg_min ) ) ) ) / + sb2; + } + + static double erf_inv( double x ) { + // Code accompanying the article "Approximating the erfinv + // function" in GPU Computing Gems, Volume 2 + double w, p; + + w = -log( ( 1.0 - x ) * ( 1.0 + x ) ); + + if ( w < 6.250000 ) { + w = w - 3.125000; + p = -3.6444120640178196996e-21; + p = -1.685059138182016589e-19 + p * w; + p = 1.2858480715256400167e-18 + p * w; + p = 1.115787767802518096e-17 + p * w; + p = -1.333171662854620906e-16 + p * w; + p = 2.0972767875968561637e-17 + p * w; + p = 6.6376381343583238325e-15 + p * w; + p = -4.0545662729752068639e-14 + p * w; + p = -8.1519341976054721522e-14 + p * w; + p = 2.6335093153082322977e-12 + p * w; + p = -1.2975133253453532498e-11 + p * w; + p = -5.4154120542946279317e-11 + p * w; + p = 1.051212273321532285e-09 + p * w; + p = -4.1126339803469836976e-09 + p * w; + p = -2.9070369957882005086e-08 + p * w; + p = 4.2347877827932403518e-07 + p * w; + p = -1.3654692000834678645e-06 + p * w; + p = -1.3882523362786468719e-05 + p * w; + p = 0.0001867342080340571352 + p * w; + p = -0.00074070253416626697512 + p * w; + p = -0.0060336708714301490533 + p * w; + p = 0.24015818242558961693 + p * w; + p = 1.6536545626831027356 + p * w; + } else if ( w < 16.000000 ) { + w = sqrt( w ) - 3.250000; + p = 2.2137376921775787049e-09; + p = 9.0756561938885390979e-08 + p * w; + p = -2.7517406297064545428e-07 + p * w; + p = 1.8239629214389227755e-08 + p * w; + p = 1.5027403968909827627e-06 + p * w; + p = -4.013867526981545969e-06 + p * w; + p = 2.9234449089955446044e-06 + p * w; + p = 1.2475304481671778723e-05 + p * w; + p = -4.7318229009055733981e-05 + p * w; + p = 6.8284851459573175448e-05 + p * w; + p = 2.4031110387097893999e-05 + p * w; + p = -0.0003550375203628474796 + p * w; + p = 0.00095328937973738049703 + p * w; + p = -0.0016882755560235047313 + p * w; + p = 0.0024914420961078508066 + p * w; + p = -0.0037512085075692412107 + p * w; + p = 0.005370914553590063617 + p * w; + p = 1.0052589676941592334 + p * w; + p = 3.0838856104922207635 + p * w; + } else { + w = sqrt( w ) - 5.000000; + p = -2.7109920616438573243e-11; + p = -2.5556418169965252055e-10 + p * w; + p = 1.5076572693500548083e-09 + p * w; + p = -3.7894654401267369937e-09 + p * w; + p = 7.6157012080783393804e-09 + p * w; + p = -1.4960026627149240478e-08 + p * w; + p = 2.9147953450901080826e-08 + p * w; + p = -6.7711997758452339498e-08 + p * w; + p = 2.2900482228026654717e-07 + p * w; + p = -9.9298272942317002539e-07 + p * w; + p = 4.5260625972231537039e-06 + p * w; + p = -1.9681778105531670567e-05 + p * w; + p = 7.5995277030017761139e-05 + p * w; + p = -0.00021503011930044477347 + p * w; + p = -0.00013871931833623122026 + p * w; + p = 1.0103004648645343977 + p * w; + p = 4.8499064014085844221 + p * w; + } + return p * x; + } + + static double + standard_deviation( double const* first, double const* last ) { + auto m = Catch::Benchmark::Detail::mean( first, last ); + double variance = + std::accumulate( first, + last, + 0., + [m]( double a, double b ) { + double diff = b - m; + return a + diff * diff; + } ) / + ( last - first ); + return std::sqrt( variance ); + } + + static sample jackknife( double ( *estimator )( double const*, + double const* ), + double* first, + double* last ) { + const auto second = first + 1; + sample results; + results.reserve( static_cast( last - first ) ); + + for ( auto it = first; it != last; ++it ) { + std::iter_swap( it, first ); + results.push_back( estimator( second, last ) ); + } + + return results; + } + + + } // namespace + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +namespace Catch { + namespace Benchmark { + namespace Detail { + + double weighted_average_quantile( int k, + int q, + double* first, + double* last ) { + auto count = last - first; + double idx = (count - 1) * k / static_cast(q); + int j = static_cast(idx); + double g = idx - j; + std::nth_element(first, first + j, last); + auto xj = first[j]; + if ( Catch::Detail::directCompare( g, 0 ) ) { + return xj; + } + + auto xj1 = *std::min_element(first + (j + 1), last); + return xj + g * (xj1 - xj); + } + + OutlierClassification + classify_outliers( double const* first, double const* last ) { + std::vector copy( first, last ); + + auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() ); + auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() ); + auto iqr = q3 - q1; + auto los = q1 - ( iqr * 3. ); + auto lom = q1 - ( iqr * 1.5 ); + auto him = q3 + ( iqr * 1.5 ); + auto his = q3 + ( iqr * 3. ); + + OutlierClassification o; + for ( ; first != last; ++first ) { + const double t = *first; + if ( t < los ) { + ++o.low_severe; + } else if ( t < lom ) { + ++o.low_mild; + } else if ( t > his ) { + ++o.high_severe; + } else if ( t > him ) { + ++o.high_mild; + } + ++o.samples_seen; + } + return o; + } + + double mean( double const* first, double const* last ) { + auto count = last - first; + double sum = 0.; + while (first != last) { + sum += *first; + ++first; + } + return sum / static_cast(count); + } + + double normal_cdf( double x ) { + return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0; + } + + double erfc_inv(double x) { + return erf_inv(1.0 - x); + } + + double normal_quantile(double p) { + static const double ROOT_TWO = std::sqrt(2.0); + + double result = 0.0; + assert(p >= 0 && p <= 1); + if (p < 0 || p > 1) { + return result; + } + + result = -erfc_inv(2.0 * p); + // result *= normal distribution standard deviation (1.0) * sqrt(2) + result *= /*sd * */ ROOT_TWO; + // result += normal disttribution mean (0) + return result; + } + + Estimate + bootstrap( double confidence_level, + double* first, + double* last, + sample const& resample, + double ( *estimator )( double const*, double const* ) ) { + auto n_samples = last - first; + + double point = estimator( first, last ); + // Degenerate case with a single sample + if ( n_samples == 1 ) + return { point, point, point, confidence_level }; + + sample jack = jackknife( estimator, first, last ); + double jack_mean = + mean( jack.data(), jack.data() + jack.size() ); + double sum_squares = 0, sum_cubes = 0; + for ( double x : jack ) { + auto difference = jack_mean - x; + auto square = difference * difference; + auto cube = square * difference; + sum_squares += square; + sum_cubes += cube; + } + + double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) ); + long n = static_cast( resample.size() ); + double prob_n = + std::count_if( resample.begin(), + resample.end(), + [point]( double x ) { return x < point; } ) / + static_cast( n ); + // degenerate case with uniform samples + if ( Catch::Detail::directCompare( prob_n, 0. ) ) { + return { point, point, point, confidence_level }; + } + + double bias = normal_quantile( prob_n ); + double z1 = normal_quantile( ( 1. - confidence_level ) / 2. ); + + auto cumn = [n]( double x ) -> long { + return std::lround( normal_cdf( x ) * + static_cast( n ) ); + }; + auto a = [bias, accel]( double b ) { + return bias + b / ( 1. - accel * b ); + }; + double b1 = bias + z1; + double b2 = bias - z1; + double a1 = a( b1 ); + double a2 = a( b2 ); + auto lo = static_cast( (std::max)( cumn( a1 ), 0l ) ); + auto hi = + static_cast( (std::min)( cumn( a2 ), n - 1 ) ); + + return { point, resample[lo], resample[hi], confidence_level }; + } + + bootstrap_analysis analyse_samples(double confidence_level, + unsigned int n_resamples, + double* first, + double* last) { + auto mean = &Detail::mean; + auto stddev = &standard_deviation; + +#if defined(CATCH_CONFIG_USE_ASYNC) + auto Estimate = [=](double(*f)(double const*, double const*)) { + std::random_device rd; + auto seed = rd(); + return std::async(std::launch::async, [=] { + SimplePcg32 rng( seed ); + auto resampled = resample(rng, n_resamples, first, last, f); + return bootstrap(confidence_level, first, last, resampled, f); + }); + }; + + auto mean_future = Estimate(mean); + auto stddev_future = Estimate(stddev); + + auto mean_estimate = mean_future.get(); + auto stddev_estimate = stddev_future.get(); +#else + auto Estimate = [=](double(*f)(double const* , double const*)) { + std::random_device rd; + auto seed = rd(); + SimplePcg32 rng( seed ); + auto resampled = resample(rng, n_resamples, first, last, f); + return bootstrap(confidence_level, first, last, resampled, f); + }; + + auto mean_estimate = Estimate(mean); + auto stddev_estimate = Estimate(stddev); +#endif // CATCH_USE_ASYNC + + auto n = static_cast(last - first); // seriously, one can't use integral types without hell in C++ + double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n); + + return { mean_estimate, stddev_estimate, outlier_variance }; + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + + + +#include +#include + +namespace { + +// Performs equivalent check of std::fabs(lhs - rhs) <= margin +// But without the subtraction to allow for INFINITY in comparison +bool marginComparison(double lhs, double rhs, double margin) { + return (lhs + margin >= rhs) && (rhs + margin >= lhs); +} + +} + +namespace Catch { + + Approx::Approx ( double value ) + : m_epsilon( static_cast(std::numeric_limits::epsilon())*100. ), + m_margin( 0.0 ), + m_scale( 0.0 ), + m_value( value ) + {} + + Approx Approx::custom() { + return Approx( 0 ); + } + + Approx Approx::operator-() const { + auto temp(*this); + temp.m_value = -temp.m_value; + return temp; + } + + + std::string Approx::toString() const { + ReusableStringStream rss; + rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )"; + return rss.str(); + } + + bool Approx::equalityComparisonImpl(const double other) const { + // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value + // Thanks to Richard Harris for his help refining the scaled margin value + return marginComparison(m_value, other, m_margin) + || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value))); + } + + void Approx::setMargin(double newMargin) { + CATCH_ENFORCE(newMargin >= 0, + "Invalid Approx::margin: " << newMargin << '.' + << " Approx::Margin has to be non-negative."); + m_margin = newMargin; + } + + void Approx::setEpsilon(double newEpsilon) { + CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0, + "Invalid Approx::epsilon: " << newEpsilon << '.' + << " Approx::epsilon has to be in [0, 1]"); + m_epsilon = newEpsilon; + } + +namespace literals { + Approx operator ""_a(long double val) { + return Approx(val); + } + Approx operator ""_a(unsigned long long val) { + return Approx(val); + } +} // end namespace literals + +std::string StringMaker::convert(Catch::Approx const& value) { + return value.toString(); +} + +} // end namespace Catch + + + +namespace Catch { + + AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression): + lazyExpression(_lazyExpression), + resultType(_resultType) {} + + std::string AssertionResultData::reconstructExpression() const { + + if( reconstructedExpression.empty() ) { + if( lazyExpression ) { + ReusableStringStream rss; + rss << lazyExpression; + reconstructedExpression = rss.str(); + } + } + return reconstructedExpression; + } + + AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data ) + : m_info( info ), + m_resultData( CATCH_MOVE(data) ) + {} + + // Result was a success + bool AssertionResult::succeeded() const { + return Catch::isOk( m_resultData.resultType ); + } + + // Result was a success, or failure is suppressed + bool AssertionResult::isOk() const { + return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); + } + + ResultWas::OfType AssertionResult::getResultType() const { + return m_resultData.resultType; + } + + bool AssertionResult::hasExpression() const { + return !m_info.capturedExpression.empty(); + } + + bool AssertionResult::hasMessage() const { + return !m_resultData.message.empty(); + } + + std::string AssertionResult::getExpression() const { + // Possibly overallocating by 3 characters should be basically free + std::string expr; expr.reserve(m_info.capturedExpression.size() + 3); + if (isFalseTest(m_info.resultDisposition)) { + expr += "!("; + } + expr += m_info.capturedExpression; + if (isFalseTest(m_info.resultDisposition)) { + expr += ')'; + } + return expr; + } + + std::string AssertionResult::getExpressionInMacro() const { + if ( m_info.macroName.empty() ) { + return static_cast( m_info.capturedExpression ); + } + std::string expr; + expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 ); + expr += m_info.macroName; + expr += "( "; + expr += m_info.capturedExpression; + expr += " )"; + return expr; + } + + bool AssertionResult::hasExpandedExpression() const { + return hasExpression() && getExpandedExpression() != getExpression(); + } + + std::string AssertionResult::getExpandedExpression() const { + std::string expr = m_resultData.reconstructExpression(); + return expr.empty() + ? getExpression() + : expr; + } + + StringRef AssertionResult::getMessage() const { + return m_resultData.message; + } + SourceLineInfo AssertionResult::getSourceInfo() const { + return m_info.lineInfo; + } + + StringRef AssertionResult::getTestMacroName() const { + return m_info.macroName; + } + +} // end namespace Catch + + + +#include + +namespace Catch { + + namespace { + static bool enableBazelEnvSupport() { +#if defined( CATCH_CONFIG_BAZEL_SUPPORT ) + return true; +#else + return Detail::getEnv( "BAZEL_TEST" ) != nullptr; +#endif + } + + struct bazelShardingOptions { + unsigned int shardIndex, shardCount; + std::string shardFilePath; + }; + + static Optional readBazelShardingOptions() { + const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" ); + const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" ); + const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" ); + + + const bool has_all = + bazelShardIndex && bazelShardTotal && bazelShardInfoFile; + if ( !has_all ) { + // We provide nice warning message if the input is + // misconfigured. + auto warn = []( const char* env_var ) { + Catch::cerr() + << "Warning: Bazel shard configuration is missing '" + << env_var << "'. Shard configuration is skipped.\n"; + }; + if ( !bazelShardIndex ) { + warn( "TEST_SHARD_INDEX" ); + } + if ( !bazelShardTotal ) { + warn( "TEST_TOTAL_SHARDS" ); + } + if ( !bazelShardInfoFile ) { + warn( "TEST_SHARD_STATUS_FILE" ); + } + return {}; + } + + auto shardIndex = parseUInt( bazelShardIndex ); + if ( !shardIndex ) { + Catch::cerr() + << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex + << "') as unsigned int.\n"; + return {}; + } + auto shardTotal = parseUInt( bazelShardTotal ); + if ( !shardTotal ) { + Catch::cerr() + << "Warning: could not parse 'TEST_TOTAL_SHARD' ('" + << bazelShardTotal << "') as unsigned int.\n"; + return {}; + } + + return bazelShardingOptions{ + *shardIndex, *shardTotal, bazelShardInfoFile }; + + } + } // end namespace + + + bool operator==( ProcessedReporterSpec const& lhs, + ProcessedReporterSpec const& rhs ) { + return lhs.name == rhs.name && + lhs.outputFilename == rhs.outputFilename && + lhs.colourMode == rhs.colourMode && + lhs.customOptions == rhs.customOptions; + } + + Config::Config( ConfigData const& data ): + m_data( data ) { + // We need to trim filter specs to avoid trouble with superfluous + // whitespace (esp. important for bdd macros, as those are manually + // aligned with whitespace). + + for (auto& elem : m_data.testsOrTags) { + elem = trim(elem); + } + for (auto& elem : m_data.sectionsToRun) { + elem = trim(elem); + } + + // Insert the default reporter if user hasn't asked for a specific one + if ( m_data.reporterSpecifications.empty() ) { +#if defined( CATCH_CONFIG_DEFAULT_REPORTER ) + const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER; +#else + const auto default_spec = "console"; +#endif + auto parsed = parseReporterSpec(default_spec); + CATCH_ENFORCE( parsed, + "Cannot parse the provided default reporter spec: '" + << default_spec << '\'' ); + m_data.reporterSpecifications.push_back( std::move( *parsed ) ); + } + + if ( enableBazelEnvSupport() ) { + readBazelEnvVars(); + } + + // Bazel support can modify the test specs, so parsing has to happen + // after reading Bazel env vars. + TestSpecParser parser( ITagAliasRegistry::get() ); + if ( !m_data.testsOrTags.empty() ) { + m_hasTestFilters = true; + for ( auto const& testOrTags : m_data.testsOrTags ) { + parser.parse( testOrTags ); + } + } + m_testSpec = parser.testSpec(); + + + // We now fixup the reporter specs to handle default output spec, + // default colour spec, etc + bool defaultOutputUsed = false; + for ( auto const& reporterSpec : m_data.reporterSpecifications ) { + // We do the default-output check separately, while always + // using the default output below to make the code simpler + // and avoid superfluous copies. + if ( reporterSpec.outputFile().none() ) { + CATCH_ENFORCE( !defaultOutputUsed, + "Internal error: cannot use default output for " + "multiple reporters" ); + defaultOutputUsed = true; + } + + m_processedReporterSpecs.push_back( ProcessedReporterSpec{ + reporterSpec.name(), + reporterSpec.outputFile() ? *reporterSpec.outputFile() + : data.defaultOutputFilename, + reporterSpec.colourMode().valueOr( data.defaultColourMode ), + reporterSpec.customOptions() } ); + } + } + + Config::~Config() = default; + + + bool Config::listTests() const { return m_data.listTests; } + bool Config::listTags() const { return m_data.listTags; } + bool Config::listReporters() const { return m_data.listReporters; } + bool Config::listListeners() const { return m_data.listListeners; } + + std::vector const& Config::getTestsOrTags() const { return m_data.testsOrTags; } + std::vector const& Config::getSectionsToRun() const { return m_data.sectionsToRun; } + + std::vector const& Config::getReporterSpecs() const { + return m_data.reporterSpecifications; + } + + std::vector const& + Config::getProcessedReporterSpecs() const { + return m_processedReporterSpecs; + } + + TestSpec const& Config::testSpec() const { return m_testSpec; } + bool Config::hasTestFilters() const { return m_hasTestFilters; } + + bool Config::showHelp() const { return m_data.showHelp; } + + // IConfig interface + bool Config::allowThrows() const { return !m_data.noThrow; } + StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } + bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; } + bool Config::warnAboutMissingAssertions() const { + return !!( m_data.warnings & WarnAbout::NoAssertions ); + } + bool Config::warnAboutUnmatchedTestSpecs() const { + return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec ); + } + bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; } + ShowDurations Config::showDurations() const { return m_data.showDurations; } + double Config::minDuration() const { return m_data.minDuration; } + TestRunOrder Config::runOrder() const { return m_data.runOrder; } + uint32_t Config::rngSeed() const { return m_data.rngSeed; } + unsigned int Config::shardCount() const { return m_data.shardCount; } + unsigned int Config::shardIndex() const { return m_data.shardIndex; } + ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; } + bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; } + int Config::abortAfter() const { return m_data.abortAfter; } + bool Config::showInvisibles() const { return m_data.showInvisibles; } + Verbosity Config::verbosity() const { return m_data.verbosity; } + + bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; } + bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; } + unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; } + double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; } + unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; } + std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); } + + void Config::readBazelEnvVars() { + // Register a JUnit reporter for Bazel. Bazel sets an environment + // variable with the path to XML output. If this file is written to + // during test, Bazel will not generate a default XML output. + // This allows the XML output file to contain higher level of detail + // than what is possible otherwise. + const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" ); + + if ( bazelOutputFile ) { + m_data.reporterSpecifications.push_back( + { "junit", std::string( bazelOutputFile ), {}, {} } ); + } + + const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" ); + if ( bazelTestSpec ) { + // Presumably the test spec from environment should overwrite + // the one we got from CLI (if we got any) + m_data.testsOrTags.clear(); + m_data.testsOrTags.push_back( bazelTestSpec ); + } + + const auto bazelShardOptions = readBazelShardingOptions(); + if ( bazelShardOptions ) { + std::ofstream f( bazelShardOptions->shardFilePath, + std::ios_base::out | std::ios_base::trunc ); + if ( f.is_open() ) { + f << ""; + m_data.shardIndex = bazelShardOptions->shardIndex; + m_data.shardCount = bazelShardOptions->shardCount; + } + } + } + +} // end namespace Catch + + + + + +namespace Catch { + std::uint32_t getSeed() { + return getCurrentContext().getConfig()->rngSeed(); + } +} + + + +#include +#include + +namespace Catch { + + //////////////////////////////////////////////////////////////////////////// + + + ScopedMessage::ScopedMessage( MessageBuilder&& builder ): + m_info( CATCH_MOVE(builder.m_info) ) { + m_info.message = builder.m_stream.str(); + getResultCapture().pushScopedMessage( m_info ); + } + + ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept: + m_info( CATCH_MOVE( old.m_info ) ) { + old.m_moved = true; + } + + ScopedMessage::~ScopedMessage() { + if ( !uncaught_exceptions() && !m_moved ){ + getResultCapture().popScopedMessage(m_info); + } + } + + + Capturer::Capturer( StringRef macroName, + SourceLineInfo const& lineInfo, + ResultWas::OfType resultType, + StringRef names ): + m_resultCapture( getResultCapture() ) { + auto trimmed = [&] (size_t start, size_t end) { + while (names[start] == ',' || isspace(static_cast(names[start]))) { + ++start; + } + while (names[end] == ',' || isspace(static_cast(names[end]))) { + --end; + } + return names.substr(start, end - start + 1); + }; + auto skipq = [&] (size_t start, char quote) { + for (auto i = start + 1; i < names.size() ; ++i) { + if (names[i] == quote) + return i; + if (names[i] == '\\') + ++i; + } + CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote"); + }; + + size_t start = 0; + std::stack openings; + for (size_t pos = 0; pos < names.size(); ++pos) { + char c = names[pos]; + switch (c) { + case '[': + case '{': + case '(': + // It is basically impossible to disambiguate between + // comparison and start of template args in this context +// case '<': + openings.push(c); + break; + case ']': + case '}': + case ')': +// case '>': + openings.pop(); + break; + case '"': + case '\'': + pos = skipq(pos, c); + break; + case ',': + if (start != pos && openings.empty()) { + m_messages.emplace_back(macroName, lineInfo, resultType); + m_messages.back().message = static_cast(trimmed(start, pos)); + m_messages.back().message += " := "; + start = pos; + } + break; + default:; // noop + } + } + assert(openings.empty() && "Mismatched openings"); + m_messages.emplace_back(macroName, lineInfo, resultType); + m_messages.back().message = static_cast(trimmed(start, names.size() - 1)); + m_messages.back().message += " := "; + } + Capturer::~Capturer() { + if ( !uncaught_exceptions() ){ + assert( m_captured == m_messages.size() ); + for( size_t i = 0; i < m_captured; ++i ) + m_resultCapture.popScopedMessage( m_messages[i] ); + } + } + + void Capturer::captureValue( size_t index, std::string const& value ) { + assert( index < m_messages.size() ); + m_messages[index].message += value; + m_resultCapture.pushScopedMessage( m_messages[index] ); + m_captured++; + } + +} // end namespace Catch + + + + +#include + +namespace Catch { + + namespace { + + class RegistryHub : public IRegistryHub, + public IMutableRegistryHub, + private Detail::NonCopyable { + + public: // IRegistryHub + RegistryHub() = default; + ReporterRegistry const& getReporterRegistry() const override { + return m_reporterRegistry; + } + ITestCaseRegistry const& getTestCaseRegistry() const override { + return m_testCaseRegistry; + } + IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override { + return m_exceptionTranslatorRegistry; + } + ITagAliasRegistry const& getTagAliasRegistry() const override { + return m_tagAliasRegistry; + } + StartupExceptionRegistry const& getStartupExceptionRegistry() const override { + return m_exceptionRegistry; + } + + public: // IMutableRegistryHub + void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override { + m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) ); + } + void registerListener( Detail::unique_ptr factory ) override { + m_reporterRegistry.registerListener( CATCH_MOVE(factory) ); + } + void registerTest( Detail::unique_ptr&& testInfo, Detail::unique_ptr&& invoker ) override { + m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) ); + } + void registerTranslator( Detail::unique_ptr&& translator ) override { + m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) ); + } + void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override { + m_tagAliasRegistry.add( alias, tag, lineInfo ); + } + void registerStartupException() noexcept override { +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + m_exceptionRegistry.add(std::current_exception()); +#else + CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!"); +#endif + } + IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override { + return m_enumValuesRegistry; + } + + private: + TestRegistry m_testCaseRegistry; + ReporterRegistry m_reporterRegistry; + ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; + TagAliasRegistry m_tagAliasRegistry; + StartupExceptionRegistry m_exceptionRegistry; + Detail::EnumValuesRegistry m_enumValuesRegistry; + }; + } + + using RegistryHubSingleton = Singleton; + + IRegistryHub const& getRegistryHub() { + return RegistryHubSingleton::get(); + } + IMutableRegistryHub& getMutableRegistryHub() { + return RegistryHubSingleton::getMutable(); + } + void cleanUp() { + cleanupSingletons(); + cleanUpContext(); + } + std::string translateActiveException() { + return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); + } + + +} // end namespace Catch + + + +#include +#include +#include +#include +#include + +namespace Catch { + + namespace { + static constexpr int TestFailureExitCode = 42; + static constexpr int UnspecifiedErrorExitCode = 1; + static constexpr int AllTestsSkippedExitCode = 4; + static constexpr int NoTestsRunExitCode = 2; + static constexpr int UnmatchedTestSpecExitCode = 3; + static constexpr int InvalidTestSpecExitCode = 5; + + + IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) { + auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config)); + CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\''); + + return reporter; + } + + IEventListenerPtr prepareReporters(Config const* config) { + if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty() + && config->getProcessedReporterSpecs().size() == 1) { + auto const& spec = config->getProcessedReporterSpecs()[0]; + return createReporter( + spec.name, + ReporterConfig( config, + makeStream( spec.outputFilename ), + spec.colourMode, + spec.customOptions ) ); + } + + auto multi = Detail::make_unique(config); + + auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners(); + for (auto const& listener : listeners) { + multi->addListener(listener->create(config)); + } + + for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) { + multi->addReporter( createReporter( + reporterSpec.name, + ReporterConfig( config, + makeStream( reporterSpec.outputFilename ), + reporterSpec.colourMode, + reporterSpec.customOptions ) ) ); + } + + return multi; + } + + class TestGroup { + public: + explicit TestGroup(IEventListenerPtr&& reporter, Config const* config): + m_reporter(reporter.get()), + m_config{config}, + m_context{config, CATCH_MOVE(reporter)} { + + assert( m_config->testSpec().getInvalidSpecs().empty() && + "Invalid test specs should be handled before running tests" ); + + auto const& allTestCases = getAllTestCasesSorted(*m_config); + auto const& testSpec = m_config->testSpec(); + if ( !testSpec.hasFilters() ) { + for ( auto const& test : allTestCases ) { + if ( !test.getTestCaseInfo().isHidden() ) { + m_tests.emplace( &test ); + } + } + } else { + m_matches = + testSpec.matchesByFilter( allTestCases, *m_config ); + for ( auto const& match : m_matches ) { + m_tests.insert( match.tests.begin(), + match.tests.end() ); + } + } + + m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex()); + } + + Totals execute() { + Totals totals; + for (auto const& testCase : m_tests) { + if (!m_context.aborting()) + totals += m_context.runTest(*testCase); + else + m_reporter->skipTest(testCase->getTestCaseInfo()); + } + + for (auto const& match : m_matches) { + if (match.tests.empty()) { + m_unmatchedTestSpecs = true; + m_reporter->noMatchingTestCases( match.name ); + } + } + + return totals; + } + + bool hadUnmatchedTestSpecs() const { + return m_unmatchedTestSpecs; + } + + + private: + IEventListener* m_reporter; + Config const* m_config; + RunContext m_context; + std::set m_tests; + TestSpec::Matches m_matches; + bool m_unmatchedTestSpecs = false; + }; + + void applyFilenamesAsTags() { + for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) { + testInfo->addFilenameTag(); + } + } + + } // anon namespace + + Session::Session() { + static bool alreadyInstantiated = false; + if( alreadyInstantiated ) { + CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); } + CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); } + } + + // There cannot be exceptions at startup in no-exception mode. +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions(); + if ( !exceptions.empty() ) { + config(); + getCurrentMutableContext().setConfig(m_config.get()); + + m_startupExceptions = true; + auto errStream = makeStream( "%stderr" ); + auto colourImpl = makeColourImpl( + ColourMode::PlatformDefault, errStream.get() ); + auto guard = colourImpl->guardColour( Colour::Red ); + errStream->stream() << "Errors occurred during startup!" << '\n'; + // iterate over all exceptions and notify user + for ( const auto& ex_ptr : exceptions ) { + try { + std::rethrow_exception(ex_ptr); + } catch ( std::exception const& ex ) { + errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n'; + } + } + } +#endif + + alreadyInstantiated = true; + m_cli = makeCommandLineParser( m_configData ); + } + Session::~Session() { + Catch::cleanUp(); + } + + void Session::showHelp() const { + Catch::cout() + << "\nCatch2 v" << libraryVersion() << '\n' + << m_cli << '\n' + << "For more detailed usage please see the project docs\n\n" << std::flush; + } + void Session::libIdentify() { + Catch::cout() + << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n" + << std::left << std::setw(16) << "category: " << "testframework\n" + << std::left << std::setw(16) << "framework: " << "Catch2\n" + << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush; + } + + int Session::applyCommandLine( int argc, char const * const * argv ) { + if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; } + + auto result = m_cli.parse( Clara::Args( argc, argv ) ); + + if( !result ) { + config(); + getCurrentMutableContext().setConfig(m_config.get()); + auto errStream = makeStream( "%stderr" ); + auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() ); + + errStream->stream() + << colour->guardColour( Colour::Red ) + << "\nError(s) in input:\n" + << TextFlow::Column( result.errorMessage() ).indent( 2 ) + << "\n\n"; + errStream->stream() << "Run with -? for usage\n\n" << std::flush; + return UnspecifiedErrorExitCode; + } + + if( m_configData.showHelp ) + showHelp(); + if( m_configData.libIdentify ) + libIdentify(); + + m_config.reset(); + return 0; + } + +#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE) + int Session::applyCommandLine( int argc, wchar_t const * const * argv ) { + + char **utf8Argv = new char *[ argc ]; + + for ( int i = 0; i < argc; ++i ) { + int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr ); + + utf8Argv[ i ] = new char[ bufSize ]; + + WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr ); + } + + int returnCode = applyCommandLine( argc, utf8Argv ); + + for ( int i = 0; i < argc; ++i ) + delete [] utf8Argv[ i ]; + + delete [] utf8Argv; + + return returnCode; + } +#endif + + void Session::useConfigData( ConfigData const& configData ) { + m_configData = configData; + m_config.reset(); + } + + int Session::run() { + if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) { + Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush; + static_cast(std::getchar()); + } + int exitCode = runInternal(); + if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) { + Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush; + static_cast(std::getchar()); + } + return exitCode; + } + + Clara::Parser const& Session::cli() const { + return m_cli; + } + void Session::cli( Clara::Parser const& newParser ) { + m_cli = newParser; + } + ConfigData& Session::configData() { + return m_configData; + } + Config& Session::config() { + if( !m_config ) + m_config = Detail::make_unique( m_configData ); + return *m_config; + } + + int Session::runInternal() { + if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; } + + if (m_configData.showHelp || m_configData.libIdentify) { + return 0; + } + + if ( m_configData.shardIndex >= m_configData.shardCount ) { + Catch::cerr() << "The shard count (" << m_configData.shardCount + << ") must be greater than the shard index (" + << m_configData.shardIndex << ")\n" + << std::flush; + return UnspecifiedErrorExitCode; + } + + CATCH_TRY { + config(); // Force config to be constructed + + seedRng( *m_config ); + + if (m_configData.filenamesAsTags) { + applyFilenamesAsTags(); + } + + // Set up global config instance before we start calling into other functions + getCurrentMutableContext().setConfig(m_config.get()); + + // Create reporter(s) so we can route listings through them + auto reporter = prepareReporters(m_config.get()); + + auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs(); + if ( !invalidSpecs.empty() ) { + for ( auto const& spec : invalidSpecs ) { + reporter->reportInvalidTestSpec( spec ); + } + return InvalidTestSpecExitCode; + } + + + // Handle list request + if (list(*reporter, *m_config)) { + return 0; + } + + TestGroup tests { CATCH_MOVE(reporter), m_config.get() }; + auto const totals = tests.execute(); + + if ( tests.hadUnmatchedTestSpecs() + && m_config->warnAboutUnmatchedTestSpecs() ) { + // UnmatchedTestSpecExitCode + return UnmatchedTestSpecExitCode; + } + + if ( totals.testCases.total() == 0 + && !m_config->zeroTestsCountAsSuccess() ) { + return NoTestsRunExitCode; + } + + if ( totals.testCases.total() > 0 && + totals.testCases.total() == totals.testCases.skipped + && !m_config->zeroTestsCountAsSuccess() ) { + return AllTestsSkippedExitCode; + } + + if ( totals.assertions.failed ) { return TestFailureExitCode; } + return 0; + + } +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + catch( std::exception& ex ) { + Catch::cerr() << ex.what() << '\n' << std::flush; + return UnspecifiedErrorExitCode; + } +#endif + } + +} // end namespace Catch + + + + +namespace Catch { + + RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) { + CATCH_TRY { + getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo); + } CATCH_CATCH_ALL { + // Do not throw when constructing global objects, instead register the exception to be processed later + getMutableRegistryHub().registerStartupException(); + } + } + +} + + + +#include +#include +#include + +namespace Catch { + + namespace { + using TCP_underlying_type = uint8_t; + static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type), + "The size of the TestCaseProperties is different from the assumed size"); + + constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) { + return static_cast( + static_cast(lhs) | static_cast(rhs) + ); + } + + constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) { + lhs = static_cast( + static_cast(lhs) | static_cast(rhs) + ); + return lhs; + } + + constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) { + return static_cast( + static_cast(lhs) & static_cast(rhs) + ); + } + + constexpr bool applies(TestCaseProperties tcp) { + static_assert(static_cast(TestCaseProperties::None) == 0, + "TestCaseProperties::None must be equal to 0"); + return tcp != TestCaseProperties::None; + } + + TestCaseProperties parseSpecialTag( StringRef tag ) { + if( !tag.empty() && tag[0] == '.' ) + return TestCaseProperties::IsHidden; + else if( tag == "!throws"_sr ) + return TestCaseProperties::Throws; + else if( tag == "!shouldfail"_sr ) + return TestCaseProperties::ShouldFail; + else if( tag == "!mayfail"_sr ) + return TestCaseProperties::MayFail; + else if( tag == "!nonportable"_sr ) + return TestCaseProperties::NonPortable; + else if( tag == "!benchmark"_sr ) + return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden; + else + return TestCaseProperties::None; + } + bool isReservedTag( StringRef tag ) { + return parseSpecialTag( tag ) == TestCaseProperties::None + && tag.size() > 0 + && !std::isalnum( static_cast(tag[0]) ); + } + void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) { + CATCH_ENFORCE( !isReservedTag(tag), + "Tag name: [" << tag << "] is not allowed.\n" + << "Tag names starting with non alphanumeric characters are reserved\n" + << _lineInfo ); + } + + std::string makeDefaultName() { + static size_t counter = 0; + return "Anonymous test case " + std::to_string(++counter); + } + + constexpr StringRef extractFilenamePart(StringRef filename) { + size_t lastDot = filename.size(); + while (lastDot > 0 && filename[lastDot - 1] != '.') { + --lastDot; + } + // In theory we could have filename without any extension in it + if ( lastDot == 0 ) { return StringRef(); } + + --lastDot; + size_t nameStart = lastDot; + while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') { + --nameStart; + } + + return filename.substr(nameStart, lastDot - nameStart); + } + + // Returns the upper bound on size of extra tags ([#file]+[.]) + constexpr size_t sizeOfExtraTags(StringRef filepath) { + // [.] is 3, [#] is another 3 + const size_t extras = 3 + 3; + return extractFilenamePart(filepath).size() + extras; + } + } // end unnamed namespace + + bool operator<( Tag const& lhs, Tag const& rhs ) { + Detail::CaseInsensitiveLess cmp; + return cmp( lhs.original, rhs.original ); + } + bool operator==( Tag const& lhs, Tag const& rhs ) { + Detail::CaseInsensitiveEqualTo cmp; + return cmp( lhs.original, rhs.original ); + } + + Detail::unique_ptr + makeTestCaseInfo(StringRef _className, + NameAndTags const& nameAndTags, + SourceLineInfo const& _lineInfo ) { + return Detail::make_unique(_className, nameAndTags, _lineInfo); + } + + TestCaseInfo::TestCaseInfo(StringRef _className, + NameAndTags const& _nameAndTags, + SourceLineInfo const& _lineInfo): + name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ), + className( _className ), + lineInfo( _lineInfo ) + { + StringRef originalTags = _nameAndTags.tags; + // We need to reserve enough space to store all of the tags + // (including optional hidden tag and filename tag) + auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file); + backingTags.reserve(requiredSize); + + // We cannot copy the tags directly, as we need to normalize + // some tags, so that [.foo] is copied as [.][foo]. + size_t tagStart = 0; + size_t tagEnd = 0; + bool inTag = false; + for (size_t idx = 0; idx < originalTags.size(); ++idx) { + auto c = originalTags[idx]; + if (c == '[') { + CATCH_ENFORCE( + !inTag, + "Found '[' inside a tag while registering test case '" + << _nameAndTags.name << "' at " << _lineInfo ); + + inTag = true; + tagStart = idx; + } + if (c == ']') { + CATCH_ENFORCE( + inTag, + "Found unmatched ']' while registering test case '" + << _nameAndTags.name << "' at " << _lineInfo ); + + inTag = false; + tagEnd = idx; + assert(tagStart < tagEnd); + + // We need to check the tag for special meanings, copy + // it over to backing storage and actually reference the + // backing storage in the saved tags + StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1); + CATCH_ENFORCE( !tagStr.empty(), + "Found an empty tag while registering test case '" + << _nameAndTags.name << "' at " + << _lineInfo ); + + enforceNotReservedTag(tagStr, lineInfo); + properties |= parseSpecialTag(tagStr); + // When copying a tag to the backing storage, we need to + // check if it is a merged hide tag, such as [.foo], and + // if it is, we need to handle it as if it was [foo]. + if (tagStr.size() > 1 && tagStr[0] == '.') { + tagStr = tagStr.substr(1, tagStr.size() - 1); + } + // We skip over dealing with the [.] tag, as we will add + // it later unconditionally and then sort and unique all + // the tags. + internalAppendTag(tagStr); + } + } + CATCH_ENFORCE( !inTag, + "Found an unclosed tag while registering test case '" + << _nameAndTags.name << "' at " << _lineInfo ); + + + // Add [.] if relevant + if (isHidden()) { + internalAppendTag("."_sr); + } + + // Sort and prepare tags + std::sort(begin(tags), end(tags)); + tags.erase(std::unique(begin(tags), end(tags)), + end(tags)); + } + + bool TestCaseInfo::isHidden() const { + return applies( properties & TestCaseProperties::IsHidden ); + } + bool TestCaseInfo::throws() const { + return applies( properties & TestCaseProperties::Throws ); + } + bool TestCaseInfo::okToFail() const { + return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) ); + } + bool TestCaseInfo::expectedToFail() const { + return applies( properties & (TestCaseProperties::ShouldFail) ); + } + + void TestCaseInfo::addFilenameTag() { + std::string combined("#"); + combined += extractFilenamePart(lineInfo.file); + internalAppendTag(combined); + } + + std::string TestCaseInfo::tagsAsString() const { + std::string ret; + // '[' and ']' per tag + std::size_t full_size = 2 * tags.size(); + for (const auto& tag : tags) { + full_size += tag.original.size(); + } + ret.reserve(full_size); + for (const auto& tag : tags) { + ret.push_back('['); + ret += tag.original; + ret.push_back(']'); + } + + return ret; + } + + void TestCaseInfo::internalAppendTag(StringRef tagStr) { + backingTags += '['; + const auto backingStart = backingTags.size(); + backingTags += tagStr; + const auto backingEnd = backingTags.size(); + backingTags += ']'; + tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart)); + } + + bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) { + // We want to avoid redoing the string comparisons multiple times, + // so we store the result of a three-way comparison before using + // it in the actual comparison logic. + const auto cmpName = lhs.name.compare( rhs.name ); + if ( cmpName != 0 ) { + return cmpName < 0; + } + const auto cmpClassName = lhs.className.compare( rhs.className ); + if ( cmpClassName != 0 ) { + return cmpClassName < 0; + } + return lhs.tags < rhs.tags; + } + +} // end namespace Catch + + + +#include +#include +#include +#include + +namespace Catch { + + TestSpec::Pattern::Pattern( std::string const& name ) + : m_name( name ) + {} + + TestSpec::Pattern::~Pattern() = default; + + std::string const& TestSpec::Pattern::name() const { + return m_name; + } + + + TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString ) + : Pattern( filterString ) + , m_wildcardPattern( toLower( name ), CaseSensitive::No ) + {} + + bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const { + return m_wildcardPattern.matches( testCase.name ); + } + + void TestSpec::NamePattern::serializeTo( std::ostream& out ) const { + out << '"' << name() << '"'; + } + + + TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString ) + : Pattern( filterString ) + , m_tag( tag ) + {} + + bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const { + return std::find( begin( testCase.tags ), + end( testCase.tags ), + Tag( m_tag ) ) != end( testCase.tags ); + } + + void TestSpec::TagPattern::serializeTo( std::ostream& out ) const { + out << name(); + } + + bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const { + bool should_use = !testCase.isHidden(); + for (auto const& pattern : m_required) { + should_use = true; + if (!pattern->matches(testCase)) { + return false; + } + } + for (auto const& pattern : m_forbidden) { + if (pattern->matches(testCase)) { + return false; + } + } + return should_use; + } + + void TestSpec::Filter::serializeTo( std::ostream& out ) const { + bool first = true; + for ( auto const& pattern : m_required ) { + if ( !first ) { + out << ' '; + } + out << *pattern; + first = false; + } + for ( auto const& pattern : m_forbidden ) { + if ( !first ) { + out << ' '; + } + out << *pattern; + first = false; + } + } + + + std::string TestSpec::extractFilterName( Filter const& filter ) { + Catch::ReusableStringStream sstr; + sstr << filter; + return sstr.str(); + } + + bool TestSpec::hasFilters() const { + return !m_filters.empty(); + } + + bool TestSpec::matches( TestCaseInfo const& testCase ) const { + return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } ); + } + + TestSpec::Matches TestSpec::matchesByFilter( std::vector const& testCases, IConfig const& config ) const { + Matches matches; + matches.reserve( m_filters.size() ); + for ( auto const& filter : m_filters ) { + std::vector currentMatches; + for ( auto const& test : testCases ) + if ( isThrowSafe( test, config ) && + filter.matches( test.getTestCaseInfo() ) ) + currentMatches.emplace_back( &test ); + matches.push_back( + FilterMatch{ extractFilterName( filter ), currentMatches } ); + } + return matches; + } + + const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const { + return m_invalidSpecs; + } + + void TestSpec::serializeTo( std::ostream& out ) const { + bool first = true; + for ( auto const& filter : m_filters ) { + if ( !first ) { + out << ','; + } + out << filter; + first = false; + } + } + +} + + + +#include + +namespace Catch { + + namespace { + static auto getCurrentNanosecondsSinceEpoch() -> uint64_t { + return std::chrono::duration_cast(std::chrono::steady_clock::now().time_since_epoch()).count(); + } + } // end unnamed namespace + + void Timer::start() { + m_nanoseconds = getCurrentNanosecondsSinceEpoch(); + } + auto Timer::getElapsedNanoseconds() const -> uint64_t { + return getCurrentNanosecondsSinceEpoch() - m_nanoseconds; + } + auto Timer::getElapsedMicroseconds() const -> uint64_t { + return getElapsedNanoseconds()/1000; + } + auto Timer::getElapsedMilliseconds() const -> unsigned int { + return static_cast(getElapsedMicroseconds()/1000); + } + auto Timer::getElapsedSeconds() const -> double { + return getElapsedMicroseconds()/1000000.0; + } + + +} // namespace Catch + + + + +#include +#include + +namespace Catch { + +namespace Detail { + + namespace { + const int hexThreshold = 255; + + struct Endianness { + enum Arch { Big, Little }; + + static Arch which() { + int one = 1; + // If the lowest byte we read is non-zero, we can assume + // that little endian format is used. + auto value = *reinterpret_cast(&one); + return value ? Little : Big; + } + }; + + template + std::string fpToString(T value, int precision) { + if (Catch::isnan(value)) { + return "nan"; + } + + ReusableStringStream rss; + rss << std::setprecision(precision) + << std::fixed + << value; + std::string d = rss.str(); + std::size_t i = d.find_last_not_of('0'); + if (i != std::string::npos && i != d.size() - 1) { + if (d[i] == '.') + i++; + d = d.substr(0, i + 1); + } + return d; + } + } // end unnamed namespace + + std::string convertIntoString(StringRef string, bool escapeInvisibles) { + std::string ret; + // This is enough for the "don't escape invisibles" case, and a good + // lower bound on the "escape invisibles" case. + ret.reserve(string.size() + 2); + + if (!escapeInvisibles) { + ret += '"'; + ret += string; + ret += '"'; + return ret; + } + + ret += '"'; + for (char c : string) { + switch (c) { + case '\r': + ret.append("\\r"); + break; + case '\n': + ret.append("\\n"); + break; + case '\t': + ret.append("\\t"); + break; + case '\f': + ret.append("\\f"); + break; + default: + ret.push_back(c); + break; + } + } + ret += '"'; + + return ret; + } + + std::string convertIntoString(StringRef string) { + return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles()); + } + + std::string rawMemoryToString( const void *object, std::size_t size ) { + // Reverse order for little endian architectures + int i = 0, end = static_cast( size ), inc = 1; + if( Endianness::which() == Endianness::Little ) { + i = end-1; + end = inc = -1; + } + + unsigned char const *bytes = static_cast(object); + ReusableStringStream rss; + rss << "0x" << std::setfill('0') << std::hex; + for( ; i != end; i += inc ) + rss << std::setw(2) << static_cast(bytes[i]); + return rss.str(); + } +} // end Detail namespace + + + +//// ======================================================= //// +// +// Out-of-line defs for full specialization of StringMaker +// +//// ======================================================= //// + +std::string StringMaker::convert(const std::string& str) { + return Detail::convertIntoString( str ); +} + +#ifdef CATCH_CONFIG_CPP17_STRING_VIEW +std::string StringMaker::convert(std::string_view str) { + return Detail::convertIntoString( StringRef( str.data(), str.size() ) ); +} +#endif + +std::string StringMaker::convert(char const* str) { + if (str) { + return Detail::convertIntoString( str ); + } else { + return{ "{null string}" }; + } +} +std::string StringMaker::convert(char* str) { // NOLINT(readability-non-const-parameter) + if (str) { + return Detail::convertIntoString( str ); + } else { + return{ "{null string}" }; + } +} + +#ifdef CATCH_CONFIG_WCHAR +std::string StringMaker::convert(const std::wstring& wstr) { + std::string s; + s.reserve(wstr.size()); + for (auto c : wstr) { + s += (c <= 0xff) ? static_cast(c) : '?'; + } + return ::Catch::Detail::stringify(s); +} + +# ifdef CATCH_CONFIG_CPP17_STRING_VIEW +std::string StringMaker::convert(std::wstring_view str) { + return StringMaker::convert(std::wstring(str)); +} +# endif + +std::string StringMaker::convert(wchar_t const * str) { + if (str) { + return ::Catch::Detail::stringify(std::wstring{ str }); + } else { + return{ "{null string}" }; + } +} +std::string StringMaker::convert(wchar_t * str) { + if (str) { + return ::Catch::Detail::stringify(std::wstring{ str }); + } else { + return{ "{null string}" }; + } +} +#endif + +#if defined(CATCH_CONFIG_CPP17_BYTE) +#include +std::string StringMaker::convert(std::byte value) { + return ::Catch::Detail::stringify(std::to_integer(value)); +} +#endif // defined(CATCH_CONFIG_CPP17_BYTE) + +std::string StringMaker::convert(int value) { + return ::Catch::Detail::stringify(static_cast(value)); +} +std::string StringMaker::convert(long value) { + return ::Catch::Detail::stringify(static_cast(value)); +} +std::string StringMaker::convert(long long value) { + ReusableStringStream rss; + rss << value; + if (value > Detail::hexThreshold) { + rss << " (0x" << std::hex << value << ')'; + } + return rss.str(); +} + +std::string StringMaker::convert(unsigned int value) { + return ::Catch::Detail::stringify(static_cast(value)); +} +std::string StringMaker::convert(unsigned long value) { + return ::Catch::Detail::stringify(static_cast(value)); +} +std::string StringMaker::convert(unsigned long long value) { + ReusableStringStream rss; + rss << value; + if (value > Detail::hexThreshold) { + rss << " (0x" << std::hex << value << ')'; + } + return rss.str(); +} + +std::string StringMaker::convert(signed char value) { + if (value == '\r') { + return "'\\r'"; + } else if (value == '\f') { + return "'\\f'"; + } else if (value == '\n') { + return "'\\n'"; + } else if (value == '\t') { + return "'\\t'"; + } else if ('\0' <= value && value < ' ') { + return ::Catch::Detail::stringify(static_cast(value)); + } else { + char chstr[] = "' '"; + chstr[1] = value; + return chstr; + } +} +std::string StringMaker::convert(char c) { + return ::Catch::Detail::stringify(static_cast(c)); +} +std::string StringMaker::convert(unsigned char value) { + return ::Catch::Detail::stringify(static_cast(value)); +} + +int StringMaker::precision = std::numeric_limits::max_digits10; + +std::string StringMaker::convert(float value) { + return Detail::fpToString(value, precision) + 'f'; +} + +int StringMaker::precision = std::numeric_limits::max_digits10; + +std::string StringMaker::convert(double value) { + return Detail::fpToString(value, precision); +} + +} // end namespace Catch + + + +namespace Catch { + + Counts Counts::operator - ( Counts const& other ) const { + Counts diff; + diff.passed = passed - other.passed; + diff.failed = failed - other.failed; + diff.failedButOk = failedButOk - other.failedButOk; + diff.skipped = skipped - other.skipped; + return diff; + } + + Counts& Counts::operator += ( Counts const& other ) { + passed += other.passed; + failed += other.failed; + failedButOk += other.failedButOk; + skipped += other.skipped; + return *this; + } + + std::uint64_t Counts::total() const { + return passed + failed + failedButOk + skipped; + } + bool Counts::allPassed() const { + return failed == 0 && failedButOk == 0 && skipped == 0; + } + bool Counts::allOk() const { + return failed == 0; + } + + Totals Totals::operator - ( Totals const& other ) const { + Totals diff; + diff.assertions = assertions - other.assertions; + diff.testCases = testCases - other.testCases; + return diff; + } + + Totals& Totals::operator += ( Totals const& other ) { + assertions += other.assertions; + testCases += other.testCases; + return *this; + } + + Totals Totals::delta( Totals const& prevTotals ) const { + Totals diff = *this - prevTotals; + if( diff.assertions.failed > 0 ) + ++diff.testCases.failed; + else if( diff.assertions.failedButOk > 0 ) + ++diff.testCases.failedButOk; + else if ( diff.assertions.skipped > 0 ) + ++ diff.testCases.skipped; + else + ++diff.testCases.passed; + return diff; + } + +} + + + + +namespace Catch { + namespace Detail { + void registerTranslatorImpl( + Detail::unique_ptr&& translator ) { + getMutableRegistryHub().registerTranslator( + CATCH_MOVE( translator ) ); + } + } // namespace Detail +} // namespace Catch + + +#include + +namespace Catch { + + Version::Version + ( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _patchNumber, + char const * const _branchName, + unsigned int _buildNumber ) + : majorVersion( _majorVersion ), + minorVersion( _minorVersion ), + patchNumber( _patchNumber ), + branchName( _branchName ), + buildNumber( _buildNumber ) + {} + + std::ostream& operator << ( std::ostream& os, Version const& version ) { + os << version.majorVersion << '.' + << version.minorVersion << '.' + << version.patchNumber; + // branchName is never null -> 0th char is \0 if it is empty + if (version.branchName[0]) { + os << '-' << version.branchName + << '.' << version.buildNumber; + } + return os; + } + + Version const& libraryVersion() { + static Version version( 3, 7, 1, "", 0 ); + return version; + } + +} + + + + +namespace Catch { + + const char* GeneratorException::what() const noexcept { + return m_msg; + } + +} // end namespace Catch + + + + +namespace Catch { + + IGeneratorTracker::~IGeneratorTracker() = default; + +namespace Generators { + +namespace Detail { + + [[noreturn]] + void throw_generator_exception(char const* msg) { + Catch::throw_exception(GeneratorException{ msg }); + } +} // end namespace Detail + + GeneratorUntypedBase::~GeneratorUntypedBase() = default; + + IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) { + return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo ); + } + + IGeneratorTracker* createGeneratorTracker( StringRef generatorName, + SourceLineInfo lineInfo, + GeneratorBasePtr&& generator ) { + return getResultCapture().createGeneratorTracker( + generatorName, lineInfo, CATCH_MOVE( generator ) ); + } + +} // namespace Generators +} // namespace Catch + + + + +#include + +namespace Catch { + namespace Generators { + namespace Detail { + std::uint32_t getSeed() { return sharedRng()(); } + } // namespace Detail + + struct RandomFloatingGenerator::PImpl { + PImpl( long double a, long double b, uint32_t seed ): + rng( seed ), dist( a, b ) {} + + Catch::SimplePcg32 rng; + std::uniform_real_distribution dist; + }; + + RandomFloatingGenerator::RandomFloatingGenerator( + long double a, long double b, std::uint32_t seed) : + m_pimpl(Catch::Detail::make_unique(a, b, seed)) { + static_cast( next() ); + } + + RandomFloatingGenerator::~RandomFloatingGenerator() = + default; + bool RandomFloatingGenerator::next() { + m_current_number = m_pimpl->dist( m_pimpl->rng ); + return true; + } + } // namespace Generators +} // namespace Catch + + + + +namespace Catch { + IResultCapture::~IResultCapture() = default; +} + + + + +namespace Catch { + IConfig::~IConfig() = default; +} + + + + +namespace Catch { + IExceptionTranslator::~IExceptionTranslator() = default; + IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default; +} + + + +#include + +namespace Catch { + namespace Generators { + + bool GeneratorUntypedBase::countedNext() { + auto ret = next(); + if ( ret ) { + m_stringReprCache.clear(); + ++m_currentElementIndex; + } + return ret; + } + + StringRef GeneratorUntypedBase::currentElementAsString() const { + if ( m_stringReprCache.empty() ) { + m_stringReprCache = stringifyImpl(); + } + return m_stringReprCache; + } + + } // namespace Generators +} // namespace Catch + + + + +namespace Catch { + IRegistryHub::~IRegistryHub() = default; + IMutableRegistryHub::~IMutableRegistryHub() = default; +} + + + +#include + +namespace Catch { + + ReporterConfig::ReporterConfig( + IConfig const* _fullConfig, + Detail::unique_ptr _stream, + ColourMode colourMode, + std::map customOptions ): + m_stream( CATCH_MOVE(_stream) ), + m_fullConfig( _fullConfig ), + m_colourMode( colourMode ), + m_customOptions( CATCH_MOVE( customOptions ) ) {} + + Detail::unique_ptr ReporterConfig::takeStream() && { + assert( m_stream ); + return CATCH_MOVE( m_stream ); + } + IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; } + ColourMode ReporterConfig::colourMode() const { return m_colourMode; } + + std::map const& + ReporterConfig::customOptions() const { + return m_customOptions; + } + + ReporterConfig::~ReporterConfig() = default; + + AssertionStats::AssertionStats( AssertionResult const& _assertionResult, + std::vector const& _infoMessages, + Totals const& _totals ) + : assertionResult( _assertionResult ), + infoMessages( _infoMessages ), + totals( _totals ) + { + if( assertionResult.hasMessage() ) { + // Copy message into messages list. + // !TBD This should have been done earlier, somewhere + MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); + builder.m_info.message = static_cast(assertionResult.getMessage()); + + infoMessages.push_back( CATCH_MOVE(builder.m_info) ); + } + } + + SectionStats::SectionStats( SectionInfo&& _sectionInfo, + Counts const& _assertions, + double _durationInSeconds, + bool _missingAssertions ) + : sectionInfo( CATCH_MOVE(_sectionInfo) ), + assertions( _assertions ), + durationInSeconds( _durationInSeconds ), + missingAssertions( _missingAssertions ) + {} + + + TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo, + Totals const& _totals, + std::string&& _stdOut, + std::string&& _stdErr, + bool _aborting ) + : testInfo( &_testInfo ), + totals( _totals ), + stdOut( CATCH_MOVE(_stdOut) ), + stdErr( CATCH_MOVE(_stdErr) ), + aborting( _aborting ) + {} + + + TestRunStats::TestRunStats( TestRunInfo const& _runInfo, + Totals const& _totals, + bool _aborting ) + : runInfo( _runInfo ), + totals( _totals ), + aborting( _aborting ) + {} + + IEventListener::~IEventListener() = default; + +} // end namespace Catch + + + + +namespace Catch { + IReporterFactory::~IReporterFactory() = default; + EventListenerFactory::~EventListenerFactory() = default; +} + + + + +namespace Catch { + ITestCaseRegistry::~ITestCaseRegistry() = default; +} + + + +namespace Catch { + + AssertionHandler::AssertionHandler + ( StringRef macroName, + SourceLineInfo const& lineInfo, + StringRef capturedExpression, + ResultDisposition::Flags resultDisposition ) + : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition }, + m_resultCapture( getResultCapture() ) + { + m_resultCapture.notifyAssertionStarted( m_assertionInfo ); + } + + void AssertionHandler::handleExpr( ITransientExpression const& expr ) { + m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction ); + } + void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) { + m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction ); + } + + auto AssertionHandler::allowThrows() const -> bool { + return getCurrentContext().getConfig()->allowThrows(); + } + + void AssertionHandler::complete() { + m_completed = true; + if( m_reaction.shouldDebugBreak ) { + + // If you find your debugger stopping you here then go one level up on the + // call-stack for the code that caused it (typically a failed assertion) + + // (To go back to the test and change execution, jump over the throw, next) + CATCH_BREAK_INTO_DEBUGGER(); + } + if (m_reaction.shouldThrow) { + throw_test_failure_exception(); + } + if ( m_reaction.shouldSkip ) { + throw_test_skip_exception(); + } + } + + void AssertionHandler::handleUnexpectedInflightException() { + m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction ); + } + + void AssertionHandler::handleExceptionThrownAsExpected() { + m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); + } + void AssertionHandler::handleExceptionNotThrownAsExpected() { + m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); + } + + void AssertionHandler::handleUnexpectedExceptionNotThrown() { + m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction ); + } + + void AssertionHandler::handleThrowingCallSkipped() { + m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); + } + + // This is the overload that takes a string and infers the Equals matcher from it + // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp + void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) { + handleExceptionMatchExpr( handler, Matchers::Equals( str ) ); + } + +} // namespace Catch + + + + +#include + +namespace Catch { + namespace Detail { + + bool CaseInsensitiveLess::operator()( StringRef lhs, + StringRef rhs ) const { + return std::lexicographical_compare( + lhs.begin(), lhs.end(), + rhs.begin(), rhs.end(), + []( char l, char r ) { return toLower( l ) < toLower( r ); } ); + } + + bool + CaseInsensitiveEqualTo::operator()( StringRef lhs, + StringRef rhs ) const { + return std::equal( + lhs.begin(), lhs.end(), + rhs.begin(), rhs.end(), + []( char l, char r ) { return toLower( l ) == toLower( r ); } ); + } + + } // namespace Detail +} // namespace Catch + + + + +#include +#include + +namespace { + bool isOptPrefix( char c ) { + return c == '-' +#ifdef CATCH_PLATFORM_WINDOWS + || c == '/' +#endif + ; + } + + Catch::StringRef normaliseOpt( Catch::StringRef optName ) { + if ( optName[0] == '-' +#if defined(CATCH_PLATFORM_WINDOWS) + || optName[0] == '/' +#endif + ) { + return optName.substr( 1, optName.size() ); + } + + return optName; + } + + static size_t find_first_separator(Catch::StringRef sr) { + auto is_separator = []( char c ) { + return c == ' ' || c == ':' || c == '='; + }; + size_t pos = 0; + while (pos < sr.size()) { + if (is_separator(sr[pos])) { return pos; } + ++pos; + } + + return Catch::StringRef::npos; + } + +} // namespace + +namespace Catch { + namespace Clara { + namespace Detail { + + void TokenStream::loadBuffer() { + m_tokenBuffer.clear(); + + // Skip any empty strings + while ( it != itEnd && it->empty() ) { + ++it; + } + + if ( it != itEnd ) { + StringRef next = *it; + if ( isOptPrefix( next[0] ) ) { + auto delimiterPos = find_first_separator(next); + if ( delimiterPos != StringRef::npos ) { + m_tokenBuffer.push_back( + { TokenType::Option, + next.substr( 0, delimiterPos ) } ); + m_tokenBuffer.push_back( + { TokenType::Argument, + next.substr( delimiterPos + 1, next.size() ) } ); + } else { + if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) { + // Combined short args, e.g. "-ab" for "-a -b" + for ( size_t i = 1; i < next.size(); ++i ) { + m_tokenBuffer.push_back( + { TokenType::Option, + next.substr( i, 1 ) } ); + } + } else { + m_tokenBuffer.push_back( + { TokenType::Option, next } ); + } + } + } else { + m_tokenBuffer.push_back( + { TokenType::Argument, next } ); + } + } + } + + TokenStream::TokenStream( Args const& args ): + TokenStream( args.m_args.begin(), args.m_args.end() ) {} + + TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ): + it( it_ ), itEnd( itEnd_ ) { + loadBuffer(); + } + + TokenStream& TokenStream::operator++() { + if ( m_tokenBuffer.size() >= 2 ) { + m_tokenBuffer.erase( m_tokenBuffer.begin() ); + } else { + if ( it != itEnd ) + ++it; + loadBuffer(); + } + return *this; + } + + ParserResult convertInto( std::string const& source, + std::string& target ) { + target = source; + return ParserResult::ok( ParseResultType::Matched ); + } + + ParserResult convertInto( std::string const& source, + bool& target ) { + std::string srcLC = toLower( source ); + + if ( srcLC == "y" || srcLC == "1" || srcLC == "true" || + srcLC == "yes" || srcLC == "on" ) { + target = true; + } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" || + srcLC == "no" || srcLC == "off" ) { + target = false; + } else { + return ParserResult::runtimeError( + "Expected a boolean value but did not recognise: '" + + source + '\'' ); + } + return ParserResult::ok( ParseResultType::Matched ); + } + + size_t ParserBase::cardinality() const { return 1; } + + InternalParseResult ParserBase::parse( Args const& args ) const { + return parse( static_cast(args.exeName()), TokenStream( args ) ); + } + + ParseState::ParseState( ParseResultType type, + TokenStream remainingTokens ): + m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {} + + ParserResult BoundFlagRef::setFlag( bool flag ) { + m_ref = flag; + return ParserResult::ok( ParseResultType::Matched ); + } + + ResultBase::~ResultBase() = default; + + bool BoundRef::isContainer() const { return false; } + + bool BoundRef::isFlag() const { return false; } + + bool BoundFlagRefBase::isFlag() const { return true; } + +} // namespace Detail + + Detail::InternalParseResult Arg::parse(std::string const&, + Detail::TokenStream tokens) const { + auto validationResult = validate(); + if (!validationResult) + return Detail::InternalParseResult(validationResult); + + auto token = *tokens; + if (token.type != Detail::TokenType::Argument) + return Detail::InternalParseResult::ok(Detail::ParseState( + ParseResultType::NoMatch, CATCH_MOVE(tokens))); + + assert(!m_ref->isFlag()); + auto valueRef = + static_cast(m_ref.get()); + + auto result = valueRef->setValue(static_cast(token.token)); + if ( !result ) + return Detail::InternalParseResult( result ); + else + return Detail::InternalParseResult::ok( + Detail::ParseState( ParseResultType::Matched, + CATCH_MOVE( ++tokens ) ) ); + } + + Opt::Opt(bool& ref) : + ParserRefImpl(std::make_shared(ref)) {} + + Detail::HelpColumns Opt::getHelpColumns() const { + ReusableStringStream oss; + bool first = true; + for (auto const& opt : m_optNames) { + if (first) + first = false; + else + oss << ", "; + oss << opt; + } + if (!m_hint.empty()) + oss << " <" << m_hint << '>'; + return { oss.str(), m_description }; + } + + bool Opt::isMatch(StringRef optToken) const { + auto normalisedToken = normaliseOpt(optToken); + for (auto const& name : m_optNames) { + if (normaliseOpt(name) == normalisedToken) + return true; + } + return false; + } + + Detail::InternalParseResult Opt::parse(std::string const&, + Detail::TokenStream tokens) const { + auto validationResult = validate(); + if (!validationResult) + return Detail::InternalParseResult(validationResult); + + if (tokens && + tokens->type == Detail::TokenType::Option) { + auto const& token = *tokens; + if (isMatch(token.token)) { + if (m_ref->isFlag()) { + auto flagRef = + static_cast( + m_ref.get()); + auto result = flagRef->setFlag(true); + if (!result) + return Detail::InternalParseResult(result); + if (result.value() == + ParseResultType::ShortCircuitAll) + return Detail::InternalParseResult::ok(Detail::ParseState( + result.value(), CATCH_MOVE(tokens))); + } else { + auto valueRef = + static_cast( + m_ref.get()); + ++tokens; + if (!tokens) + return Detail::InternalParseResult::runtimeError( + "Expected argument following " + + token.token); + auto const& argToken = *tokens; + if (argToken.type != Detail::TokenType::Argument) + return Detail::InternalParseResult::runtimeError( + "Expected argument following " + + token.token); + const auto result = valueRef->setValue(static_cast(argToken.token)); + if (!result) + return Detail::InternalParseResult(result); + if (result.value() == + ParseResultType::ShortCircuitAll) + return Detail::InternalParseResult::ok(Detail::ParseState( + result.value(), CATCH_MOVE(tokens))); + } + return Detail::InternalParseResult::ok(Detail::ParseState( + ParseResultType::Matched, CATCH_MOVE(++tokens))); + } + } + return Detail::InternalParseResult::ok( + Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens))); + } + + Detail::Result Opt::validate() const { + if (m_optNames.empty()) + return Detail::Result::logicError("No options supplied to Opt"); + for (auto const& name : m_optNames) { + if (name.empty()) + return Detail::Result::logicError( + "Option name cannot be empty"); +#ifdef CATCH_PLATFORM_WINDOWS + if (name[0] != '-' && name[0] != '/') + return Detail::Result::logicError( + "Option name must begin with '-' or '/'"); +#else + if (name[0] != '-') + return Detail::Result::logicError( + "Option name must begin with '-'"); +#endif + } + return ParserRefImpl::validate(); + } + + ExeName::ExeName() : + m_name(std::make_shared("")) {} + + ExeName::ExeName(std::string& ref) : ExeName() { + m_ref = std::make_shared>(ref); + } + + Detail::InternalParseResult + ExeName::parse(std::string const&, + Detail::TokenStream tokens) const { + return Detail::InternalParseResult::ok( + Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens))); + } + + ParserResult ExeName::set(std::string const& newName) { + auto lastSlash = newName.find_last_of("\\/"); + auto filename = (lastSlash == std::string::npos) + ? newName + : newName.substr(lastSlash + 1); + + *m_name = filename; + if (m_ref) + return m_ref->setValue(filename); + else + return ParserResult::ok(ParseResultType::Matched); + } + + + + + Parser& Parser::operator|=( Parser const& other ) { + m_options.insert( m_options.end(), + other.m_options.begin(), + other.m_options.end() ); + m_args.insert( + m_args.end(), other.m_args.begin(), other.m_args.end() ); + return *this; + } + + std::vector Parser::getHelpColumns() const { + std::vector cols; + cols.reserve( m_options.size() ); + for ( auto const& o : m_options ) { + cols.push_back(o.getHelpColumns()); + } + return cols; + } + + void Parser::writeToStream( std::ostream& os ) const { + if ( !m_exeName.name().empty() ) { + os << "usage:\n" + << " " << m_exeName.name() << ' '; + bool required = true, first = true; + for ( auto const& arg : m_args ) { + if ( first ) + first = false; + else + os << ' '; + if ( arg.isOptional() && required ) { + os << '['; + required = false; + } + os << '<' << arg.hint() << '>'; + if ( arg.cardinality() == 0 ) + os << " ... "; + } + if ( !required ) + os << ']'; + if ( !m_options.empty() ) + os << " options"; + os << "\n\nwhere options are:\n"; + } + + auto rows = getHelpColumns(); + size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH; + size_t optWidth = 0; + for ( auto const& cols : rows ) + optWidth = ( std::max )( optWidth, cols.left.size() + 2 ); + + optWidth = ( std::min )( optWidth, consoleWidth / 2 ); + + for ( auto& cols : rows ) { + auto row = TextFlow::Column( CATCH_MOVE(cols.left) ) + .width( optWidth ) + .indent( 2 ) + + TextFlow::Spacer( 4 ) + + TextFlow::Column( static_cast(cols.descriptions) ) + .width( consoleWidth - 7 - optWidth ); + os << row << '\n'; + } + } + + Detail::Result Parser::validate() const { + for ( auto const& opt : m_options ) { + auto result = opt.validate(); + if ( !result ) + return result; + } + for ( auto const& arg : m_args ) { + auto result = arg.validate(); + if ( !result ) + return result; + } + return Detail::Result::ok(); + } + + Detail::InternalParseResult + Parser::parse( std::string const& exeName, + Detail::TokenStream tokens ) const { + + struct ParserInfo { + ParserBase const* parser = nullptr; + size_t count = 0; + }; + std::vector parseInfos; + parseInfos.reserve( m_options.size() + m_args.size() ); + for ( auto const& opt : m_options ) { + parseInfos.push_back( { &opt, 0 } ); + } + for ( auto const& arg : m_args ) { + parseInfos.push_back( { &arg, 0 } ); + } + + m_exeName.set( exeName ); + + auto result = Detail::InternalParseResult::ok( + Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) ); + while ( result.value().remainingTokens() ) { + bool tokenParsed = false; + + for ( auto& parseInfo : parseInfos ) { + if ( parseInfo.parser->cardinality() == 0 || + parseInfo.count < parseInfo.parser->cardinality() ) { + result = parseInfo.parser->parse( + exeName, CATCH_MOVE(result).value().remainingTokens() ); + if ( !result ) + return result; + if ( result.value().type() != + ParseResultType::NoMatch ) { + tokenParsed = true; + ++parseInfo.count; + break; + } + } + } + + if ( result.value().type() == ParseResultType::ShortCircuitAll ) + return result; + if ( !tokenParsed ) + return Detail::InternalParseResult::runtimeError( + "Unrecognised token: " + + result.value().remainingTokens()->token ); + } + // !TBD Check missing required options + return result; + } + + Args::Args(int argc, char const* const* argv) : + m_exeName(argv[0]), m_args(argv + 1, argv + argc) {} + + Args::Args(std::initializer_list args) : + m_exeName(*args.begin()), + m_args(args.begin() + 1, args.end()) {} + + + Help::Help( bool& showHelpFlag ): + Opt( [&]( bool flag ) { + showHelpFlag = flag; + return ParserResult::ok( ParseResultType::ShortCircuitAll ); + } ) { + static_cast ( *this )( + "display usage information" )["-?"]["-h"]["--help"] + .optional(); + } + + } // namespace Clara +} // namespace Catch + + + + +#include +#include + +namespace Catch { + + Clara::Parser makeCommandLineParser( ConfigData& config ) { + + using namespace Clara; + + auto const setWarning = [&]( std::string const& warning ) { + if ( warning == "NoAssertions" ) { + config.warnings = static_cast(config.warnings | WarnAbout::NoAssertions); + return ParserResult::ok( ParseResultType::Matched ); + } else if ( warning == "UnmatchedTestSpec" ) { + config.warnings = static_cast(config.warnings | WarnAbout::UnmatchedTestSpec); + return ParserResult::ok( ParseResultType::Matched ); + } + + return ParserResult ::runtimeError( + "Unrecognised warning option: '" + warning + '\'' ); + }; + auto const loadTestNamesFromFile = [&]( std::string const& filename ) { + std::ifstream f( filename.c_str() ); + if( !f.is_open() ) + return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' ); + + std::string line; + while( std::getline( f, line ) ) { + line = trim(line); + if( !line.empty() && !startsWith( line, '#' ) ) { + if( !startsWith( line, '"' ) ) + line = '"' + CATCH_MOVE(line) + '"'; + config.testsOrTags.push_back( line ); + config.testsOrTags.emplace_back( "," ); + } + } + //Remove comma in the end + if(!config.testsOrTags.empty()) + config.testsOrTags.erase( config.testsOrTags.end()-1 ); + + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setTestOrder = [&]( std::string const& order ) { + if( startsWith( "declared", order ) ) + config.runOrder = TestRunOrder::Declared; + else if( startsWith( "lexical", order ) ) + config.runOrder = TestRunOrder::LexicographicallySorted; + else if( startsWith( "random", order ) ) + config.runOrder = TestRunOrder::Randomized; + else + return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' ); + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setRngSeed = [&]( std::string const& seed ) { + if( seed == "time" ) { + config.rngSeed = generateRandomSeed(GenerateFrom::Time); + return ParserResult::ok(ParseResultType::Matched); + } else if (seed == "random-device") { + config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice); + return ParserResult::ok(ParseResultType::Matched); + } + + // TODO: ideally we should be parsing uint32_t directly + // fix this later when we add new parse overload + auto parsedSeed = parseUInt( seed, 0 ); + if ( !parsedSeed ) { + return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" ); + } + config.rngSeed = *parsedSeed; + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setDefaultColourMode = [&]( std::string const& colourMode ) { + Optional maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode )); + if ( !maybeMode ) { + return ParserResult::runtimeError( + "colour mode must be one of: default, ansi, win32, " + "or none. '" + + colourMode + "' is not recognised" ); + } + auto mode = *maybeMode; + if ( !isColourImplAvailable( mode ) ) { + return ParserResult::runtimeError( + "colour mode '" + colourMode + + "' is not supported in this binary" ); + } + config.defaultColourMode = mode; + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setWaitForKeypress = [&]( std::string const& keypress ) { + auto keypressLc = toLower( keypress ); + if (keypressLc == "never") + config.waitForKeypress = WaitForKeypress::Never; + else if( keypressLc == "start" ) + config.waitForKeypress = WaitForKeypress::BeforeStart; + else if( keypressLc == "exit" ) + config.waitForKeypress = WaitForKeypress::BeforeExit; + else if( keypressLc == "both" ) + config.waitForKeypress = WaitForKeypress::BeforeStartAndExit; + else + return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" ); + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setVerbosity = [&]( std::string const& verbosity ) { + auto lcVerbosity = toLower( verbosity ); + if( lcVerbosity == "quiet" ) + config.verbosity = Verbosity::Quiet; + else if( lcVerbosity == "normal" ) + config.verbosity = Verbosity::Normal; + else if( lcVerbosity == "high" ) + config.verbosity = Verbosity::High; + else + return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' ); + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setReporter = [&]( std::string const& userReporterSpec ) { + if ( userReporterSpec.empty() ) { + return ParserResult::runtimeError( "Received empty reporter spec." ); + } + + Optional parsed = + parseReporterSpec( userReporterSpec ); + if ( !parsed ) { + return ParserResult::runtimeError( + "Could not parse reporter spec '" + userReporterSpec + + "'" ); + } + + auto const& reporterSpec = *parsed; + + auto const& factories = + getRegistryHub().getReporterRegistry().getFactories(); + auto result = factories.find( reporterSpec.name() ); + + if ( result == factories.end() ) { + return ParserResult::runtimeError( + "Unrecognized reporter, '" + reporterSpec.name() + + "'. Check available with --list-reporters" ); + } + + + const bool hadOutputFile = reporterSpec.outputFile().some(); + config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) ); + // It would be enough to check this only once at the very end, but + // there is not a place where we could call this check, so do it + // every time it could fail. For valid inputs, this is still called + // at most once. + if (!hadOutputFile) { + int n_reporters_without_file = 0; + for (auto const& spec : config.reporterSpecifications) { + if (spec.outputFile().none()) { + n_reporters_without_file++; + } + } + if (n_reporters_without_file > 1) { + return ParserResult::runtimeError( "Only one reporter may have unspecified output file." ); + } + } + + return ParserResult::ok( ParseResultType::Matched ); + }; + auto const setShardCount = [&]( std::string const& shardCount ) { + auto parsedCount = parseUInt( shardCount ); + if ( !parsedCount ) { + return ParserResult::runtimeError( + "Could not parse '" + shardCount + "' as shard count" ); + } + if ( *parsedCount == 0 ) { + return ParserResult::runtimeError( + "Shard count must be positive" ); + } + config.shardCount = *parsedCount; + return ParserResult::ok( ParseResultType::Matched ); + }; + + auto const setShardIndex = [&](std::string const& shardIndex) { + auto parsedIndex = parseUInt( shardIndex ); + if ( !parsedIndex ) { + return ParserResult::runtimeError( + "Could not parse '" + shardIndex + "' as shard index" ); + } + config.shardIndex = *parsedIndex; + return ParserResult::ok( ParseResultType::Matched ); + }; + + auto cli + = ExeName( config.processName ) + | Help( config.showHelp ) + | Opt( config.showSuccessfulTests ) + ["-s"]["--success"] + ( "include successful tests in output" ) + | Opt( config.shouldDebugBreak ) + ["-b"]["--break"] + ( "break into debugger on failure" ) + | Opt( config.noThrow ) + ["-e"]["--nothrow"] + ( "skip exception tests" ) + | Opt( config.showInvisibles ) + ["-i"]["--invisibles"] + ( "show invisibles (tabs, newlines)" ) + | Opt( config.defaultOutputFilename, "filename" ) + ["-o"]["--out"] + ( "default output filename" ) + | Opt( accept_many, setReporter, "name[::key=value]*" ) + ["-r"]["--reporter"] + ( "reporter to use (defaults to console)" ) + | Opt( config.name, "name" ) + ["-n"]["--name"] + ( "suite name" ) + | Opt( [&]( bool ){ config.abortAfter = 1; } ) + ["-a"]["--abort"] + ( "abort at first failure" ) + | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" ) + ["-x"]["--abortx"] + ( "abort after x failures" ) + | Opt( accept_many, setWarning, "warning name" ) + ["-w"]["--warn"] + ( "enable warnings" ) + | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" ) + ["-d"]["--durations"] + ( "show test durations" ) + | Opt( config.minDuration, "seconds" ) + ["-D"]["--min-duration"] + ( "show test durations for tests taking at least the given number of seconds" ) + | Opt( loadTestNamesFromFile, "filename" ) + ["-f"]["--input-file"] + ( "load test names to run from a file" ) + | Opt( config.filenamesAsTags ) + ["-#"]["--filenames-as-tags"] + ( "adds a tag for the filename" ) + | Opt( config.sectionsToRun, "section name" ) + ["-c"]["--section"] + ( "specify section to run" ) + | Opt( setVerbosity, "quiet|normal|high" ) + ["-v"]["--verbosity"] + ( "set output verbosity" ) + | Opt( config.listTests ) + ["--list-tests"] + ( "list all/matching test cases" ) + | Opt( config.listTags ) + ["--list-tags"] + ( "list all/matching tags" ) + | Opt( config.listReporters ) + ["--list-reporters"] + ( "list all available reporters" ) + | Opt( config.listListeners ) + ["--list-listeners"] + ( "list all listeners" ) + | Opt( setTestOrder, "decl|lex|rand" ) + ["--order"] + ( "test case order (defaults to decl)" ) + | Opt( setRngSeed, "'time'|'random-device'|number" ) + ["--rng-seed"] + ( "set a specific seed for random numbers" ) + | Opt( setDefaultColourMode, "ansi|win32|none|default" ) + ["--colour-mode"] + ( "what color mode should be used as default" ) + | Opt( config.libIdentify ) + ["--libidentify"] + ( "report name and version according to libidentify standard" ) + | Opt( setWaitForKeypress, "never|start|exit|both" ) + ["--wait-for-keypress"] + ( "waits for a keypress before exiting" ) + | Opt( config.skipBenchmarks) + ["--skip-benchmarks"] + ( "disable running benchmarks") + | Opt( config.benchmarkSamples, "samples" ) + ["--benchmark-samples"] + ( "number of samples to collect (default: 100)" ) + | Opt( config.benchmarkResamples, "resamples" ) + ["--benchmark-resamples"] + ( "number of resamples for the bootstrap (default: 100000)" ) + | Opt( config.benchmarkConfidenceInterval, "confidence interval" ) + ["--benchmark-confidence-interval"] + ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" ) + | Opt( config.benchmarkNoAnalysis ) + ["--benchmark-no-analysis"] + ( "perform only measurements; do not perform any analysis" ) + | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" ) + ["--benchmark-warmup-time"] + ( "amount of time in milliseconds spent on warming up each test (default: 100)" ) + | Opt( setShardCount, "shard count" ) + ["--shard-count"] + ( "split the tests to execute into this many groups" ) + | Opt( setShardIndex, "shard index" ) + ["--shard-index"] + ( "index of the group of tests to execute (see --shard-count)" ) + | Opt( config.allowZeroTests ) + ["--allow-running-no-tests"] + ( "Treat 'No tests run' as a success" ) + | Arg( config.testsOrTags, "test name|pattern|tags" ) + ( "which test or tests to use" ); + + return cli; + } + +} // end namespace Catch + + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wexit-time-destructors" +#endif + + + +#include +#include +#include + +namespace Catch { + + ColourImpl::~ColourImpl() = default; + + ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) { + return ColourGuard(colourCode, this ); + } + + void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) { + assert( &stream == &m_colourImpl->m_stream->stream() && + "Engaging colour guard for different stream than used by the " + "parent colour implementation" ); + static_cast( stream ); + + m_engaged = true; + m_colourImpl->use( m_code ); + } + + ColourImpl::ColourGuard::ColourGuard( Colour::Code code, + ColourImpl const* colour ): + m_colourImpl( colour ), m_code( code ) { + } + ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept: + m_colourImpl( rhs.m_colourImpl ), + m_code( rhs.m_code ), + m_engaged( rhs.m_engaged ) { + rhs.m_engaged = false; + } + ColourImpl::ColourGuard& + ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept { + using std::swap; + swap( m_colourImpl, rhs.m_colourImpl ); + swap( m_code, rhs.m_code ); + swap( m_engaged, rhs.m_engaged ); + + return *this; + } + ColourImpl::ColourGuard::~ColourGuard() { + if ( m_engaged ) { + m_colourImpl->use( Colour::None ); + } + } + + ColourImpl::ColourGuard& + ColourImpl::ColourGuard::engage( std::ostream& stream ) & { + engageImpl( stream ); + return *this; + } + + ColourImpl::ColourGuard&& + ColourImpl::ColourGuard::engage( std::ostream& stream ) && { + engageImpl( stream ); + return CATCH_MOVE(*this); + } + + namespace { + //! A do-nothing implementation of colour, used as fallback for unknown + //! platforms, and when the user asks to deactivate all colours. + class NoColourImpl final : public ColourImpl { + public: + NoColourImpl( IStream* stream ): ColourImpl( stream ) {} + + private: + void use( Colour::Code ) const override {} + }; + } // namespace + + +} // namespace Catch + + +#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) ///////////////////////////////////////// + +namespace Catch { +namespace { + + class Win32ColourImpl final : public ColourImpl { + public: + Win32ColourImpl(IStream* stream): + ColourImpl(stream) { + CONSOLE_SCREEN_BUFFER_INFO csbiInfo; + GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), + &csbiInfo ); + originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY ); + originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY ); + } + + static bool useImplementationForStream(IStream const& stream) { + // Win32 text colour APIs can only be used on console streams + // We cannot check that the output hasn't been redirected, + // so we just check that the original stream is console stream. + return stream.isConsole(); + } + + private: + void use( Colour::Code _colourCode ) const override { + switch( _colourCode ) { + case Colour::None: return setTextAttribute( originalForegroundAttributes ); + case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + case Colour::Red: return setTextAttribute( FOREGROUND_RED ); + case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); + case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); + case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); + case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); + case Colour::Grey: return setTextAttribute( 0 ); + + case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); + case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); + case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); + case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN ); + + case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" ); + + default: + CATCH_ERROR( "Unknown colour requested" ); + } + } + + void setTextAttribute( WORD _textAttribute ) const { + SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), + _textAttribute | + originalBackgroundAttributes ); + } + WORD originalForegroundAttributes; + WORD originalBackgroundAttributes; + }; + +} // end anon namespace +} // end namespace Catch + +#endif // Windows/ ANSI/ None + + +#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) +# define CATCH_INTERNAL_HAS_ISATTY +# include +#endif + +namespace Catch { +namespace { + + class ANSIColourImpl final : public ColourImpl { + public: + ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {} + + static bool useImplementationForStream(IStream const& stream) { + // This is kinda messy due to trying to support a bunch of + // different platforms at once. + // The basic idea is that if we are asked to do autodetection (as + // opposed to being told to use posixy colours outright), then we + // only want to use the colours if we are writing to console. + // However, console might be redirected, so we make an attempt at + // checking for that on platforms where we know how to do that. + bool useColour = stream.isConsole(); +#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \ + !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) ) + ErrnoGuard _; // for isatty + useColour = useColour && isatty( STDOUT_FILENO ); +# endif +# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE ) + useColour = useColour && !isDebuggerActive(); +# endif + + return useColour; + } + + private: + void use( Colour::Code _colourCode ) const override { + auto setColour = [&out = + m_stream->stream()]( char const* escapeCode ) { + // The escape sequence must be flushed to console, otherwise + // if stdin and stderr are intermixed, we'd get accidentally + // coloured output. + out << '\033' << escapeCode << std::flush; + }; + switch( _colourCode ) { + case Colour::None: + case Colour::White: return setColour( "[0m" ); + case Colour::Red: return setColour( "[0;31m" ); + case Colour::Green: return setColour( "[0;32m" ); + case Colour::Blue: return setColour( "[0;34m" ); + case Colour::Cyan: return setColour( "[0;36m" ); + case Colour::Yellow: return setColour( "[0;33m" ); + case Colour::Grey: return setColour( "[1;30m" ); + + case Colour::LightGrey: return setColour( "[0;37m" ); + case Colour::BrightRed: return setColour( "[1;31m" ); + case Colour::BrightGreen: return setColour( "[1;32m" ); + case Colour::BrightWhite: return setColour( "[1;37m" ); + case Colour::BrightYellow: return setColour( "[1;33m" ); + + case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" ); + default: CATCH_INTERNAL_ERROR( "Unknown colour requested" ); + } + } + }; + +} // end anon namespace +} // end namespace Catch + +namespace Catch { + + Detail::unique_ptr makeColourImpl( ColourMode colourSelection, + IStream* stream ) { +#if defined( CATCH_CONFIG_COLOUR_WIN32 ) + if ( colourSelection == ColourMode::Win32 ) { + return Detail::make_unique( stream ); + } +#endif + if ( colourSelection == ColourMode::ANSI ) { + return Detail::make_unique( stream ); + } + if ( colourSelection == ColourMode::None ) { + return Detail::make_unique( stream ); + } + + if ( colourSelection == ColourMode::PlatformDefault) { +#if defined( CATCH_CONFIG_COLOUR_WIN32 ) + if ( Win32ColourImpl::useImplementationForStream( *stream ) ) { + return Detail::make_unique( stream ); + } +#endif + if ( ANSIColourImpl::useImplementationForStream( *stream ) ) { + return Detail::make_unique( stream ); + } + return Detail::make_unique( stream ); + } + + CATCH_ERROR( "Could not create colour impl for selection " << static_cast(colourSelection) ); + } + + bool isColourImplAvailable( ColourMode colourSelection ) { + switch ( colourSelection ) { +#if defined( CATCH_CONFIG_COLOUR_WIN32 ) + case ColourMode::Win32: +#endif + case ColourMode::ANSI: + case ColourMode::None: + case ColourMode::PlatformDefault: + return true; + default: + return false; + } + } + + +} // end namespace Catch + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + + + + +namespace Catch { + + Context* Context::currentContext = nullptr; + + void cleanUpContext() { + delete Context::currentContext; + Context::currentContext = nullptr; + } + void Context::createContext() { + currentContext = new Context(); + } + + Context& getCurrentMutableContext() { + if ( !Context::currentContext ) { Context::createContext(); } + // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn) + return *Context::currentContext; + } + + SimplePcg32& sharedRng() { + static SimplePcg32 s_rng; + return s_rng; + } + +} + + + + + +#include + +#if defined(CATCH_CONFIG_ANDROID_LOGWRITE) +#include + + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() ); + } + } + +#elif defined(CATCH_PLATFORM_WINDOWS) + + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + ::OutputDebugStringA( text.c_str() ); + } + } + +#else + + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + // !TBD: Need a version for Mac/ XCode and other IDEs + Catch::cout() << text; + } + } + +#endif // Platform + + + +#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE) + +# include +# include +# include +# include +# include + +#ifdef __apple_build_version__ + // These headers will only compile with AppleClang (XCode) + // For other compilers (Clang, GCC, ... ) we need to exclude them +# include +#endif + + namespace Catch { + #ifdef __apple_build_version__ + // The following function is taken directly from the following technical note: + // https://developer.apple.com/library/archive/qa/qa1361/_index.html + + // Returns true if the current process is being debugged (either + // running under the debugger or has a debugger attached post facto). + bool isDebuggerActive(){ + int mib[4]; + struct kinfo_proc info; + std::size_t size; + + // Initialize the flags so that, if sysctl fails for some bizarre + // reason, we get a predictable result. + + info.kp_proc.p_flag = 0; + + // Initialize mib, which tells sysctl the info we want, in this case + // we're looking for information about a specific process ID. + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PID; + mib[3] = getpid(); + + // Call sysctl. + + size = sizeof(info); + if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) { + Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush; + return false; + } + + // We're being debugged if the P_TRACED flag is set. + + return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); + } + #else + bool isDebuggerActive() { + // We need to find another way to determine this for non-appleclang compilers on macOS + return false; + } + #endif + } // namespace Catch + +#elif defined(CATCH_PLATFORM_LINUX) + #include + #include + + namespace Catch{ + // The standard POSIX way of detecting a debugger is to attempt to + // ptrace() the process, but this needs to be done from a child and not + // this process itself to still allow attaching to this process later + // if wanted, so is rather heavy. Under Linux we have the PID of the + // "debugger" (which doesn't need to be gdb, of course, it could also + // be strace, for example) in /proc/$PID/status, so just get it from + // there instead. + bool isDebuggerActive(){ + // Libstdc++ has a bug, where std::ifstream sets errno to 0 + // This way our users can properly assert over errno values + ErrnoGuard guard; + std::ifstream in("/proc/self/status"); + for( std::string line; std::getline(in, line); ) { + static const int PREFIX_LEN = 11; + if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) { + // We're traced if the PID is not 0 and no other PID starts + // with 0 digit, so it's enough to check for just a single + // character. + return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0'; + } + } + + return false; + } + } // namespace Catch +#elif defined(_MSC_VER) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#else + namespace Catch { + bool isDebuggerActive() { return false; } + } +#endif // Platform + + + + +namespace Catch { + + void ITransientExpression::streamReconstructedExpression( + std::ostream& os ) const { + // We can't make this function pure virtual to keep ITransientExpression + // constexpr, so we write error message instead + os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression"; + } + + void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) { + if( lhs.size() + rhs.size() < 40 && + lhs.find('\n') == std::string::npos && + rhs.find('\n') == std::string::npos ) + os << lhs << ' ' << op << ' ' << rhs; + else + os << lhs << '\n' << op << '\n' << rhs; + } +} + + + +#include + + +namespace Catch { +#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER) + [[noreturn]] + void throw_exception(std::exception const& e) { + Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n" + << "The message was: " << e.what() << '\n'; + std::terminate(); + } +#endif + + [[noreturn]] + void throw_logic_error(std::string const& msg) { + throw_exception(std::logic_error(msg)); + } + + [[noreturn]] + void throw_domain_error(std::string const& msg) { + throw_exception(std::domain_error(msg)); + } + + [[noreturn]] + void throw_runtime_error(std::string const& msg) { + throw_exception(std::runtime_error(msg)); + } + + + +} // namespace Catch; + + + +#include + +namespace Catch { + + IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default; + + namespace Detail { + + namespace { + // Extracts the actual name part of an enum instance + // In other words, it returns the Blue part of Bikeshed::Colour::Blue + StringRef extractInstanceName(StringRef enumInstance) { + // Find last occurrence of ":" + size_t name_start = enumInstance.size(); + while (name_start > 0 && enumInstance[name_start - 1] != ':') { + --name_start; + } + return enumInstance.substr(name_start, enumInstance.size() - name_start); + } + } + + std::vector parseEnums( StringRef enums ) { + auto enumValues = splitStringRef( enums, ',' ); + std::vector parsed; + parsed.reserve( enumValues.size() ); + for( auto const& enumValue : enumValues ) { + parsed.push_back(trim(extractInstanceName(enumValue))); + } + return parsed; + } + + EnumInfo::~EnumInfo() = default; + + StringRef EnumInfo::lookup( int value ) const { + for( auto const& valueToName : m_values ) { + if( valueToName.first == value ) + return valueToName.second; + } + return "{** unexpected enum value **}"_sr; + } + + Catch::Detail::unique_ptr makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector const& values ) { + auto enumInfo = Catch::Detail::make_unique(); + enumInfo->m_name = enumName; + enumInfo->m_values.reserve( values.size() ); + + const auto valueNames = Catch::Detail::parseEnums( allValueNames ); + assert( valueNames.size() == values.size() ); + std::size_t i = 0; + for( auto value : values ) + enumInfo->m_values.emplace_back(value, valueNames[i++]); + + return enumInfo; + } + + EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector const& values ) { + m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values)); + return *m_enumInfos.back(); + } + + } // Detail +} // Catch + + + + + +#include + +namespace Catch { + ErrnoGuard::ErrnoGuard():m_oldErrno(errno){} + ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; } +} + + + +#include + +namespace Catch { + +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + namespace { + static std::string tryTranslators( + std::vector< + Detail::unique_ptr> const& translators ) { + if ( translators.empty() ) { + std::rethrow_exception( std::current_exception() ); + } else { + return translators[0]->translate( translators.begin() + 1, + translators.end() ); + } + } + + } +#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + + ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default; + + void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr&& translator ) { + m_translators.push_back( CATCH_MOVE( translator ) ); + } + +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + std::string ExceptionTranslatorRegistry::translateActiveException() const { + // Compiling a mixed mode project with MSVC means that CLR + // exceptions will be caught in (...) as well. However, these do + // do not fill-in std::current_exception and thus lead to crash + // when attempting rethrow. + // /EHa switch also causes structured exceptions to be caught + // here, but they fill-in current_exception properly, so + // at worst the output should be a little weird, instead of + // causing a crash. + if ( std::current_exception() == nullptr ) { + return "Non C++ exception. Possibly a CLR exception."; + } + + // First we try user-registered translators. If none of them can + // handle the exception, it will be rethrown handled by our defaults. + try { + return tryTranslators(m_translators); + } + // To avoid having to handle TFE explicitly everywhere, we just + // rethrow it so that it goes back up the caller. + catch( TestFailureException& ) { + std::rethrow_exception(std::current_exception()); + } + catch( TestSkipException& ) { + std::rethrow_exception(std::current_exception()); + } + catch( std::exception const& ex ) { + return ex.what(); + } + catch( std::string const& msg ) { + return msg; + } + catch( const char* msg ) { + return msg; + } + catch(...) { + return "Unknown exception"; + } + } + +#else // ^^ Exceptions are enabled // Exceptions are disabled vv + std::string ExceptionTranslatorRegistry::translateActiveException() const { + CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!"); + } +#endif + +} + + + +/** \file + * This file provides platform specific implementations of FatalConditionHandler + * + * This means that there is a lot of conditional compilation, and platform + * specific code. Currently, Catch2 supports a dummy handler (if no + * handler is desired), and 2 platform specific handlers: + * * Windows' SEH + * * POSIX signals + * + * Consequently, various pieces of code below are compiled if either of + * the platform specific handlers is enabled, or if none of them are + * enabled. It is assumed that both cannot be enabled at the same time, + * and doing so should cause a compilation error. + * + * If another platform specific handler is added, the compile guards + * below will need to be updated taking these assumptions into account. + */ + + + +#include + +#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS ) + +namespace Catch { + + // If neither SEH nor signal handling is required, the handler impls + // do not have to do anything, and can be empty. + void FatalConditionHandler::engage_platform() {} + void FatalConditionHandler::disengage_platform() noexcept {} + FatalConditionHandler::FatalConditionHandler() = default; + FatalConditionHandler::~FatalConditionHandler() = default; + +} // end namespace Catch + +#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS + +#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS ) +#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time" +#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS + +#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS ) + +namespace { + //! Signals fatal error message to the run context + void reportFatal( char const * const message ) { + Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message ); + } + + //! Minimal size Catch2 needs for its own fatal error handling. + //! Picked empirically, so it might not be sufficient on all + //! platforms, and for all configurations. + constexpr std::size_t minStackSizeForErrors = 32 * 1024; +} // end unnamed namespace + +#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS + +#if defined( CATCH_CONFIG_WINDOWS_SEH ) + +namespace Catch { + + struct SignalDefs { DWORD id; const char* name; }; + + // There is no 1-1 mapping between signals and windows exceptions. + // Windows can easily distinguish between SO and SigSegV, + // but SigInt, SigTerm, etc are handled differently. + static SignalDefs signalDefs[] = { + { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" }, + { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" }, + { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" }, + { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" }, + }; + + static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) { + for (auto const& def : signalDefs) { + if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) { + reportFatal(def.name); + } + } + // If its not an exception we care about, pass it along. + // This stops us from eating debugger breaks etc. + return EXCEPTION_CONTINUE_SEARCH; + } + + // Since we do not support multiple instantiations, we put these + // into global variables and rely on cleaning them up in outlined + // constructors/destructors + static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr; + + + // For MSVC, we reserve part of the stack memory for handling + // memory overflow structured exception. + FatalConditionHandler::FatalConditionHandler() { + ULONG guaranteeSize = static_cast(minStackSizeForErrors); + if (!SetThreadStackGuarantee(&guaranteeSize)) { + // We do not want to fully error out, because needing + // the stack reserve should be rare enough anyway. + Catch::cerr() + << "Failed to reserve piece of stack." + << " Stack overflows will not be reported successfully."; + } + } + + // We do not attempt to unset the stack guarantee, because + // Windows does not support lowering the stack size guarantee. + FatalConditionHandler::~FatalConditionHandler() = default; + + + void FatalConditionHandler::engage_platform() { + // Register as a the top level exception filter. + previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter); + } + + void FatalConditionHandler::disengage_platform() noexcept { + if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) { + Catch::cerr() + << "Unexpected SEH unhandled exception filter on disengage." + << " The filter was restored, but might be rolled back unexpectedly."; + } + previousTopLevelExceptionFilter = nullptr; + } + +} // end namespace Catch + +#endif // CATCH_CONFIG_WINDOWS_SEH + +#if defined( CATCH_CONFIG_POSIX_SIGNALS ) + +#include + +namespace Catch { + + struct SignalDefs { + int id; + const char* name; + }; + + static SignalDefs signalDefs[] = { + { SIGINT, "SIGINT - Terminal interrupt signal" }, + { SIGILL, "SIGILL - Illegal instruction signal" }, + { SIGFPE, "SIGFPE - Floating point error signal" }, + { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, + { SIGTERM, "SIGTERM - Termination request signal" }, + { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } + }; + +// Older GCCs trigger -Wmissing-field-initializers for T foo = {} +// which is zero initialization, but not explicit. We want to avoid +// that. +#if defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + + static char* altStackMem = nullptr; + static std::size_t altStackSize = 0; + static stack_t oldSigStack{}; + static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{}; + + static void restorePreviousSignalHandlers() noexcept { + // We set signal handlers back to the previous ones. Hopefully + // nobody overwrote them in the meantime, and doesn't expect + // their signal handlers to live past ours given that they + // installed them after ours.. + for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { + sigaction(signalDefs[i].id, &oldSigActions[i], nullptr); + } + // Return the old stack + sigaltstack(&oldSigStack, nullptr); + } + + static void handleSignal( int sig ) { + char const * name = ""; + for (auto const& def : signalDefs) { + if (sig == def.id) { + name = def.name; + break; + } + } + // We need to restore previous signal handlers and let them do + // their thing, so that the users can have the debugger break + // when a signal is raised, and so on. + restorePreviousSignalHandlers(); + reportFatal( name ); + raise( sig ); + } + + FatalConditionHandler::FatalConditionHandler() { + assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists"); + if (altStackSize == 0) { + altStackSize = std::max(static_cast(SIGSTKSZ), minStackSizeForErrors); + } + altStackMem = new char[altStackSize](); + } + + FatalConditionHandler::~FatalConditionHandler() { + delete[] altStackMem; + // We signal that another instance can be constructed by zeroing + // out the pointer. + altStackMem = nullptr; + } + + void FatalConditionHandler::engage_platform() { + stack_t sigStack; + sigStack.ss_sp = altStackMem; + sigStack.ss_size = altStackSize; + sigStack.ss_flags = 0; + sigaltstack(&sigStack, &oldSigStack); + struct sigaction sa = { }; + + sa.sa_handler = handleSignal; + sa.sa_flags = SA_ONSTACK; + for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) { + sigaction(signalDefs[i].id, &sa, &oldSigActions[i]); + } + } + +#if defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + + + void FatalConditionHandler::disengage_platform() noexcept { + restorePreviousSignalHandlers(); + } + +} // end namespace Catch + +#endif // CATCH_CONFIG_POSIX_SIGNALS + + + + +#include + +namespace Catch { + namespace Detail { + + uint32_t convertToBits(float f) { + static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated"); + uint32_t i; + std::memcpy(&i, &f, sizeof(f)); + return i; + } + + uint64_t convertToBits(double d) { + static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated"); + uint64_t i; + std::memcpy(&i, &d, sizeof(d)); + return i; + } + +#if defined( __GNUC__ ) || defined( __clang__ ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wfloat-equal" +#endif + bool directCompare( float lhs, float rhs ) { return lhs == rhs; } + bool directCompare( double lhs, double rhs ) { return lhs == rhs; } +#if defined( __GNUC__ ) || defined( __clang__ ) +# pragma GCC diagnostic pop +#endif + + + } // end namespace Detail +} // end namespace Catch + + + + + + +#include + +namespace Catch { + namespace Detail { + +#if !defined (CATCH_CONFIG_GETENV) + char const* getEnv( char const* ) { return nullptr; } +#else + + char const* getEnv( char const* varName ) { +# if defined( _MSC_VER ) +# pragma warning( push ) +# pragma warning( disable : 4996 ) // use getenv_s instead of getenv +# endif + + return std::getenv( varName ); + +# if defined( _MSC_VER ) +# pragma warning( pop ) +# endif + } +#endif +} // namespace Detail +} // namespace Catch + + + + +#include +#include +#include +#include + +namespace Catch { + + Catch::IStream::~IStream() = default; + +namespace Detail { + namespace { + template + class StreamBufImpl final : public std::streambuf { + char data[bufferSize]; + WriterF m_writer; + + public: + StreamBufImpl() { + setp( data, data + sizeof(data) ); + } + + ~StreamBufImpl() noexcept override { + StreamBufImpl::sync(); + } + + private: + int overflow( int c ) override { + sync(); + + if( c != EOF ) { + if( pbase() == epptr() ) + m_writer( std::string( 1, static_cast( c ) ) ); + else + sputc( static_cast( c ) ); + } + return 0; + } + + int sync() override { + if( pbase() != pptr() ) { + m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); + setp( pbase(), epptr() ); + } + return 0; + } + }; + + /////////////////////////////////////////////////////////////////////////// + + struct OutputDebugWriter { + + void operator()( std::string const& str ) { + if ( !str.empty() ) { + writeToDebugConsole( str ); + } + } + }; + + /////////////////////////////////////////////////////////////////////////// + + class FileStream final : public IStream { + std::ofstream m_ofs; + public: + FileStream( std::string const& filename ) { + m_ofs.open( filename.c_str() ); + CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' ); + m_ofs << std::unitbuf; + } + public: // IStream + std::ostream& stream() override { + return m_ofs; + } + }; + + /////////////////////////////////////////////////////////////////////////// + + class CoutStream final : public IStream { + std::ostream m_os; + public: + // Store the streambuf from cout up-front because + // cout may get redirected when running tests + CoutStream() : m_os( Catch::cout().rdbuf() ) {} + + public: // IStream + std::ostream& stream() override { return m_os; } + bool isConsole() const override { return true; } + }; + + class CerrStream : public IStream { + std::ostream m_os; + + public: + // Store the streambuf from cerr up-front because + // cout may get redirected when running tests + CerrStream(): m_os( Catch::cerr().rdbuf() ) {} + + public: // IStream + std::ostream& stream() override { return m_os; } + bool isConsole() const override { return true; } + }; + + /////////////////////////////////////////////////////////////////////////// + + class DebugOutStream final : public IStream { + Detail::unique_ptr> m_streamBuf; + std::ostream m_os; + public: + DebugOutStream() + : m_streamBuf( Detail::make_unique>() ), + m_os( m_streamBuf.get() ) + {} + + public: // IStream + std::ostream& stream() override { return m_os; } + }; + + } // unnamed namespace +} // namespace Detail + + /////////////////////////////////////////////////////////////////////////// + + auto makeStream( std::string const& filename ) -> Detail::unique_ptr { + if ( filename.empty() || filename == "-" ) { + return Detail::make_unique(); + } + if( filename[0] == '%' ) { + if ( filename == "%debug" ) { + return Detail::make_unique(); + } else if ( filename == "%stderr" ) { + return Detail::make_unique(); + } else if ( filename == "%stdout" ) { + return Detail::make_unique(); + } else { + CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' ); + } + } + return Detail::make_unique( filename ); + } + +} + + + +namespace Catch { + void JsonUtils::indent( std::ostream& os, std::uint64_t level ) { + for ( std::uint64_t i = 0; i < level; ++i ) { + os << " "; + } + } + void JsonUtils::appendCommaNewline( std::ostream& os, + bool& should_comma, + std::uint64_t level ) { + if ( should_comma ) { os << ','; } + should_comma = true; + os << '\n'; + indent( os, level ); + } + + JsonObjectWriter::JsonObjectWriter( std::ostream& os ): + JsonObjectWriter{ os, 0 } {} + + JsonObjectWriter::JsonObjectWriter( std::ostream& os, + std::uint64_t indent_level ): + m_os{ os }, m_indent_level{ indent_level } { + m_os << '{'; + } + JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept: + m_os{ source.m_os }, + m_indent_level{ source.m_indent_level }, + m_should_comma{ source.m_should_comma }, + m_active{ source.m_active } { + source.m_active = false; + } + + JsonObjectWriter::~JsonObjectWriter() { + if ( !m_active ) { return; } + + m_os << '\n'; + JsonUtils::indent( m_os, m_indent_level ); + m_os << '}'; + } + + JsonValueWriter JsonObjectWriter::write( StringRef key ) { + JsonUtils::appendCommaNewline( + m_os, m_should_comma, m_indent_level + 1 ); + + m_os << '"' << key << "\": "; + return JsonValueWriter{ m_os, m_indent_level + 1 }; + } + + JsonArrayWriter::JsonArrayWriter( std::ostream& os ): + JsonArrayWriter{ os, 0 } {} + JsonArrayWriter::JsonArrayWriter( std::ostream& os, + std::uint64_t indent_level ): + m_os{ os }, m_indent_level{ indent_level } { + m_os << '['; + } + JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept: + m_os{ source.m_os }, + m_indent_level{ source.m_indent_level }, + m_should_comma{ source.m_should_comma }, + m_active{ source.m_active } { + source.m_active = false; + } + JsonArrayWriter::~JsonArrayWriter() { + if ( !m_active ) { return; } + + m_os << '\n'; + JsonUtils::indent( m_os, m_indent_level ); + m_os << ']'; + } + + JsonObjectWriter JsonArrayWriter::writeObject() { + JsonUtils::appendCommaNewline( + m_os, m_should_comma, m_indent_level + 1 ); + return JsonObjectWriter{ m_os, m_indent_level + 1 }; + } + + JsonArrayWriter JsonArrayWriter::writeArray() { + JsonUtils::appendCommaNewline( + m_os, m_should_comma, m_indent_level + 1 ); + return JsonArrayWriter{ m_os, m_indent_level + 1 }; + } + + JsonArrayWriter& JsonArrayWriter::write( bool value ) { + return writeImpl( value ); + } + + JsonValueWriter::JsonValueWriter( std::ostream& os ): + JsonValueWriter{ os, 0 } {} + + JsonValueWriter::JsonValueWriter( std::ostream& os, + std::uint64_t indent_level ): + m_os{ os }, m_indent_level{ indent_level } {} + + JsonObjectWriter JsonValueWriter::writeObject() && { + return JsonObjectWriter{ m_os, m_indent_level }; + } + + JsonArrayWriter JsonValueWriter::writeArray() && { + return JsonArrayWriter{ m_os, m_indent_level }; + } + + void JsonValueWriter::write( Catch::StringRef value ) && { + writeImpl( value, true ); + } + + void JsonValueWriter::write( bool value ) && { + writeImpl( value ? "true"_sr : "false"_sr, false ); + } + + void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) { + if ( quote ) { m_os << '"'; } + for (char c : value) { + // Escape list taken from https://www.json.org/json-en.html, + // string definition. + // Note that while forward slash _can_ be escaped, it does + // not have to be, if JSON is not further embedded somewhere + // where forward slash is meaningful. + if ( c == '"' ) { + m_os << "\\\""; + } else if ( c == '\\' ) { + m_os << "\\\\"; + } else if ( c == '\b' ) { + m_os << "\\b"; + } else if ( c == '\f' ) { + m_os << "\\f"; + } else if ( c == '\n' ) { + m_os << "\\n"; + } else if ( c == '\r' ) { + m_os << "\\r"; + } else if ( c == '\t' ) { + m_os << "\\t"; + } else { + m_os << c; + } + } + if ( quote ) { m_os << '"'; } + } + +} // namespace Catch + + + + +namespace Catch { + + auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& { + if (lazyExpr.m_isNegated) + os << '!'; + + if (lazyExpr) { + if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression()) + os << '(' << *lazyExpr.m_transientExpression << ')'; + else + os << *lazyExpr.m_transientExpression; + } else { + os << "{** error - unchecked empty expression requested **}"; + } + return os; + } + +} // namespace Catch + + + + +#ifdef CATCH_CONFIG_WINDOWS_CRTDBG +#include + +namespace Catch { + + LeakDetector::LeakDetector() { + int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); + flag |= _CRTDBG_LEAK_CHECK_DF; + flag |= _CRTDBG_ALLOC_MEM_DF; + _CrtSetDbgFlag(flag); + _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); + _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); + // Change this to leaking allocation's number to break there + _CrtSetBreakAlloc(-1); + } +} + +#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv + + Catch::LeakDetector::LeakDetector() = default; + +#endif // CATCH_CONFIG_WINDOWS_CRTDBG + +Catch::LeakDetector::~LeakDetector() { + Catch::cleanUp(); +} + + + + +namespace Catch { + namespace { + + void listTests(IEventListener& reporter, IConfig const& config) { + auto const& testSpec = config.testSpec(); + auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config); + reporter.listTests(matchedTestCases); + } + + void listTags(IEventListener& reporter, IConfig const& config) { + auto const& testSpec = config.testSpec(); + std::vector matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config); + + std::map tagCounts; + for (auto const& testCase : matchedTestCases) { + for (auto const& tagName : testCase.getTestCaseInfo().tags) { + auto it = tagCounts.find(tagName.original); + if (it == tagCounts.end()) + it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first; + it->second.add(tagName.original); + } + } + + std::vector infos; infos.reserve(tagCounts.size()); + for (auto& tagc : tagCounts) { + infos.push_back(CATCH_MOVE(tagc.second)); + } + + reporter.listTags(infos); + } + + void listReporters(IEventListener& reporter) { + std::vector descriptions; + + auto const& factories = getRegistryHub().getReporterRegistry().getFactories(); + descriptions.reserve(factories.size()); + for (auto const& fac : factories) { + descriptions.push_back({ fac.first, fac.second->getDescription() }); + } + + reporter.listReporters(descriptions); + } + + void listListeners(IEventListener& reporter) { + std::vector descriptions; + + auto const& factories = + getRegistryHub().getReporterRegistry().getListeners(); + descriptions.reserve( factories.size() ); + for ( auto const& fac : factories ) { + descriptions.push_back( { fac->getName(), fac->getDescription() } ); + } + + reporter.listListeners( descriptions ); + } + + } // end anonymous namespace + + void TagInfo::add( StringRef spelling ) { + ++count; + spellings.insert( spelling ); + } + + std::string TagInfo::all() const { + // 2 per tag for brackets '[' and ']' + size_t size = spellings.size() * 2; + for (auto const& spelling : spellings) { + size += spelling.size(); + } + + std::string out; out.reserve(size); + for (auto const& spelling : spellings) { + out += '['; + out += spelling; + out += ']'; + } + return out; + } + + bool list( IEventListener& reporter, Config const& config ) { + bool listed = false; + if (config.listTests()) { + listed = true; + listTests(reporter, config); + } + if (config.listTags()) { + listed = true; + listTags(reporter, config); + } + if (config.listReporters()) { + listed = true; + listReporters(reporter); + } + if ( config.listListeners() ) { + listed = true; + listListeners( reporter ); + } + return listed; + } + +} // end namespace Catch + + + +namespace Catch { + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS + static LeakDetector leakDetector; + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION +} + +// Allow users of amalgamated .cpp file to remove our main and provide their own. +#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN) + +#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN) +// Standard C/C++ Win32 Unicode wmain entry point +extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) { +#else +// Standard C/C++ main entry point +int main (int argc, char * argv[]) { +#endif + + // We want to force the linker not to discard the global variable + // and its constructor, as it (optionally) registers leak detector + (void)&Catch::leakDetector; + + return Catch::Session().run( argc, argv ); +} + +#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN + + + + +namespace Catch { + + MessageInfo::MessageInfo( StringRef _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + type( _type ), + sequence( ++globalCount ) + {} + + // This may need protecting if threading support is added + unsigned int MessageInfo::globalCount = 0; + +} // end namespace Catch + + + +#include +#include +#include +#include + +#if defined( CATCH_CONFIG_NEW_CAPTURE ) +# if defined( _MSC_VER ) +# include //_dup and _dup2 +# define dup _dup +# define dup2 _dup2 +# define fileno _fileno +# else +# include // dup and dup2 +# endif +#endif + +namespace Catch { + + namespace { + //! A no-op implementation, used if no reporter wants output + //! redirection. + class NoopRedirect : public OutputRedirect { + void activateImpl() override {} + void deactivateImpl() override {} + std::string getStdout() override { return {}; } + std::string getStderr() override { return {}; } + void clearBuffers() override {} + }; + + /** + * Redirects specific stream's rdbuf with another's. + * + * Redirection can be stopped and started on-demand, assumes + * that the underlying stream's rdbuf aren't changed by other + * users. + */ + class RedirectedStreamNew { + std::ostream& m_originalStream; + std::ostream& m_redirectionStream; + std::streambuf* m_prevBuf; + + public: + RedirectedStreamNew( std::ostream& originalStream, + std::ostream& redirectionStream ): + m_originalStream( originalStream ), + m_redirectionStream( redirectionStream ), + m_prevBuf( m_originalStream.rdbuf() ) {} + + void startRedirect() { + m_originalStream.rdbuf( m_redirectionStream.rdbuf() ); + } + void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); } + }; + + /** + * Redirects the `std::cout`, `std::cerr`, `std::clog` streams, + * but does not touch the actual `stdout`/`stderr` file descriptors. + */ + class StreamRedirect : public OutputRedirect { + ReusableStringStream m_redirectedOut, m_redirectedErr; + RedirectedStreamNew m_cout, m_cerr, m_clog; + + public: + StreamRedirect(): + m_cout( Catch::cout(), m_redirectedOut.get() ), + m_cerr( Catch::cerr(), m_redirectedErr.get() ), + m_clog( Catch::clog(), m_redirectedErr.get() ) {} + + void activateImpl() override { + m_cout.startRedirect(); + m_cerr.startRedirect(); + m_clog.startRedirect(); + } + void deactivateImpl() override { + m_cout.stopRedirect(); + m_cerr.stopRedirect(); + m_clog.stopRedirect(); + } + std::string getStdout() override { return m_redirectedOut.str(); } + std::string getStderr() override { return m_redirectedErr.str(); } + void clearBuffers() override { + m_redirectedOut.str( "" ); + m_redirectedErr.str( "" ); + } + }; + +#if defined( CATCH_CONFIG_NEW_CAPTURE ) + + // Windows's implementation of std::tmpfile is terrible (it tries + // to create a file inside system folder, thus requiring elevated + // privileges for the binary), so we have to use tmpnam(_s) and + // create the file ourselves there. + class TempFile { + public: + TempFile( TempFile const& ) = delete; + TempFile& operator=( TempFile const& ) = delete; + TempFile( TempFile&& ) = delete; + TempFile& operator=( TempFile&& ) = delete; + +# if defined( _MSC_VER ) + TempFile() { + if ( tmpnam_s( m_buffer ) ) { + CATCH_RUNTIME_ERROR( "Could not get a temp filename" ); + } + if ( fopen_s( &m_file, m_buffer, "wb+" ) ) { + char buffer[100]; + if ( strerror_s( buffer, errno ) ) { + CATCH_RUNTIME_ERROR( + "Could not translate errno to a string" ); + } + CATCH_RUNTIME_ERROR( "Could not open the temp file: '" + << m_buffer + << "' because: " << buffer ); + } + } +# else + TempFile() { + m_file = std::tmpfile(); + if ( !m_file ) { + CATCH_RUNTIME_ERROR( "Could not create a temp file." ); + } + } +# endif + + ~TempFile() { + // TBD: What to do about errors here? + std::fclose( m_file ); + // We manually create the file on Windows only, on Linux + // it will be autodeleted +# if defined( _MSC_VER ) + std::remove( m_buffer ); +# endif + } + + std::FILE* getFile() { return m_file; } + std::string getContents() { + ReusableStringStream sstr; + constexpr long buffer_size = 100; + char buffer[buffer_size + 1] = {}; + long current_pos = ftell( m_file ); + CATCH_ENFORCE( current_pos >= 0, + "ftell failed, errno: " << errno ); + std::rewind( m_file ); + while ( current_pos > 0 ) { + auto read_characters = + std::fread( buffer, + 1, + std::min( buffer_size, current_pos ), + m_file ); + buffer[read_characters] = '\0'; + sstr << buffer; + current_pos -= static_cast( read_characters ); + } + return sstr.str(); + } + + void clear() { std::rewind( m_file ); } + + private: + std::FILE* m_file = nullptr; + char m_buffer[L_tmpnam] = { 0 }; + }; + + /** + * Redirects the actual `stdout`/`stderr` file descriptors. + * + * Works by replacing the file descriptors numbered 1 and 2 + * with an open temporary file. + */ + class FileRedirect : public OutputRedirect { + TempFile m_outFile, m_errFile; + int m_originalOut = -1; + int m_originalErr = -1; + + // Flushes cout/cerr/clog streams and stdout/stderr FDs + void flushEverything() { + Catch::cout() << std::flush; + fflush( stdout ); + // Since we support overriding these streams, we flush cerr + // even though std::cerr is unbuffered + Catch::cerr() << std::flush; + Catch::clog() << std::flush; + fflush( stderr ); + } + + public: + FileRedirect(): + m_originalOut( dup( fileno( stdout ) ) ), + m_originalErr( dup( fileno( stderr ) ) ) { + CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" ); + CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" ); + } + + std::string getStdout() override { return m_outFile.getContents(); } + std::string getStderr() override { return m_errFile.getContents(); } + void clearBuffers() override { + m_outFile.clear(); + m_errFile.clear(); + } + + void activateImpl() override { + // We flush before starting redirect, to ensure that we do + // not capture the end of message sent before activation. + flushEverything(); + + int ret; + ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) ); + CATCH_ENFORCE( ret >= 0, + "dup2 to stdout has failed, errno: " << errno ); + ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) ); + CATCH_ENFORCE( ret >= 0, + "dup2 to stderr has failed, errno: " << errno ); + } + void deactivateImpl() override { + // We flush before ending redirect, to ensure that we + // capture all messages sent while the redirect was active. + flushEverything(); + + int ret; + ret = dup2( m_originalOut, fileno( stdout ) ); + CATCH_ENFORCE( + ret >= 0, + "dup2 of original stdout has failed, errno: " << errno ); + ret = dup2( m_originalErr, fileno( stderr ) ); + CATCH_ENFORCE( + ret >= 0, + "dup2 of original stderr has failed, errno: " << errno ); + } + }; + +#endif // CATCH_CONFIG_NEW_CAPTURE + + } // end namespace + + bool isRedirectAvailable( OutputRedirect::Kind kind ) { + switch ( kind ) { + // These two are always available + case OutputRedirect::None: + case OutputRedirect::Streams: + return true; +#if defined( CATCH_CONFIG_NEW_CAPTURE ) + case OutputRedirect::FileDescriptors: + return true; +#endif + default: + return false; + } + } + + Detail::unique_ptr makeOutputRedirect( bool actual ) { + if ( actual ) { + // TODO: Clean this up later +#if defined( CATCH_CONFIG_NEW_CAPTURE ) + return Detail::make_unique(); +#else + return Detail::make_unique(); +#endif + } else { + return Detail::make_unique(); + } + } + + RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) { + return RedirectGuard( true, redirectImpl ); + } + + RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) { + return RedirectGuard( false, redirectImpl ); + } + + OutputRedirect::~OutputRedirect() = default; + + RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ): + m_redirect( &redirectImpl ), + m_activate( activate ), + m_previouslyActive( redirectImpl.isActive() ) { + + // Skip cases where there is no actual state change. + if ( m_activate == m_previouslyActive ) { return; } + + if ( m_activate ) { + m_redirect->activate(); + } else { + m_redirect->deactivate(); + } + } + + RedirectGuard::~RedirectGuard() noexcept( false ) { + if ( m_moved ) { return; } + // Skip cases where there is no actual state change. + if ( m_activate == m_previouslyActive ) { return; } + + if ( m_activate ) { + m_redirect->deactivate(); + } else { + m_redirect->activate(); + } + } + + RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept: + m_redirect( rhs.m_redirect ), + m_activate( rhs.m_activate ), + m_previouslyActive( rhs.m_previouslyActive ), + m_moved( false ) { + rhs.m_moved = true; + } + + RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept { + m_redirect = rhs.m_redirect; + m_activate = rhs.m_activate; + m_previouslyActive = rhs.m_previouslyActive; + m_moved = false; + rhs.m_moved = true; + return *this; + } + +} // namespace Catch + +#if defined( CATCH_CONFIG_NEW_CAPTURE ) +# if defined( _MSC_VER ) +# undef dup +# undef dup2 +# undef fileno +# endif +#endif + + + + +#include +#include + +namespace Catch { + + Optional parseUInt(std::string const& input, int base) { + auto trimmed = trim( input ); + // std::stoull is annoying and accepts numbers starting with '-', + // it just negates them into unsigned int + if ( trimmed.empty() || trimmed[0] == '-' ) { + return {}; + } + + CATCH_TRY { + size_t pos = 0; + const auto ret = std::stoull( trimmed, &pos, base ); + + // We did not consume the whole input, so there is an issue + // This can be bunch of different stuff, like multiple numbers + // in the input, or invalid digits/characters and so on. Either + // way, we do not want to return the partially parsed result. + if ( pos != trimmed.size() ) { + return {}; + } + // Too large + if ( ret > std::numeric_limits::max() ) { + return {}; + } + return static_cast(ret); + } + CATCH_CATCH_ANON( std::invalid_argument const& ) { + // no conversion could be performed + } + CATCH_CATCH_ANON( std::out_of_range const& ) { + // the input does not fit into an unsigned long long + } + return {}; + } + +} // namespace Catch + + + + +#include + +namespace Catch { + +#if !defined(CATCH_CONFIG_POLYFILL_ISNAN) + bool isnan(float f) { + return std::isnan(f); + } + bool isnan(double d) { + return std::isnan(d); + } +#else + // For now we only use this for embarcadero + bool isnan(float f) { + return std::_isnan(f); + } + bool isnan(double d) { + return std::_isnan(d); + } +#endif + +#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER ) + float nextafter( float x, float y ) { return std::nextafter( x, y ); } + double nextafter( double x, double y ) { return std::nextafter( x, y ); } +#else + float nextafter( float x, float y ) { return ::nextafterf( x, y ); } + double nextafter( double x, double y ) { return ::nextafter( x, y ); } +#endif + +} // end namespace Catch + + + +namespace Catch { + +namespace { + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4146) // we negate uint32 during the rotate +#endif + // Safe rotr implementation thanks to John Regehr + uint32_t rotate_right(uint32_t val, uint32_t count) { + const uint32_t mask = 31; + count &= mask; + return (val >> count) | (val << (-count & mask)); + } + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +} + + + SimplePcg32::SimplePcg32(result_type seed_) { + seed(seed_); + } + + + void SimplePcg32::seed(result_type seed_) { + m_state = 0; + (*this)(); + m_state += seed_; + (*this)(); + } + + void SimplePcg32::discard(uint64_t skip) { + // We could implement this to run in O(log n) steps, but this + // should suffice for our use case. + for (uint64_t s = 0; s < skip; ++s) { + static_cast((*this)()); + } + } + + SimplePcg32::result_type SimplePcg32::operator()() { + // prepare the output value + const uint32_t xorshifted = static_cast(((m_state >> 18u) ^ m_state) >> 27u); + const auto output = rotate_right(xorshifted, m_state >> 59u); + + // advance state + m_state = m_state * 6364136223846793005ULL + s_inc; + + return output; + } + + bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) { + return lhs.m_state == rhs.m_state; + } + + bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) { + return lhs.m_state != rhs.m_state; + } +} + + + + + +#include +#include + +namespace Catch { + + std::uint32_t generateRandomSeed( GenerateFrom from ) { + switch ( from ) { + case GenerateFrom::Time: + return static_cast( std::time( nullptr ) ); + + case GenerateFrom::Default: + case GenerateFrom::RandomDevice: { + std::random_device rd; + return Detail::fillBitsFrom( rd ); + } + + default: + CATCH_ERROR("Unknown generation method"); + } + } + +} // end namespace Catch + + + + +namespace Catch { + struct ReporterRegistry::ReporterRegistryImpl { + std::vector> listeners; + std::map + factories; + }; + + ReporterRegistry::ReporterRegistry(): + m_impl( Detail::make_unique() ) { + // Because it is impossible to move out of initializer list, + // we have to add the elements manually + m_impl->factories["Automake"] = + Detail::make_unique>(); + m_impl->factories["compact"] = + Detail::make_unique>(); + m_impl->factories["console"] = + Detail::make_unique>(); + m_impl->factories["JUnit"] = + Detail::make_unique>(); + m_impl->factories["SonarQube"] = + Detail::make_unique>(); + m_impl->factories["TAP"] = + Detail::make_unique>(); + m_impl->factories["TeamCity"] = + Detail::make_unique>(); + m_impl->factories["XML"] = + Detail::make_unique>(); + m_impl->factories["JSON"] = + Detail::make_unique>(); + } + + ReporterRegistry::~ReporterRegistry() = default; + + IEventListenerPtr + ReporterRegistry::create( std::string const& name, + ReporterConfig&& config ) const { + auto it = m_impl->factories.find( name ); + if ( it == m_impl->factories.end() ) return nullptr; + return it->second->create( CATCH_MOVE( config ) ); + } + + void ReporterRegistry::registerReporter( std::string const& name, + IReporterFactoryPtr factory ) { + CATCH_ENFORCE( name.find( "::" ) == name.npos, + "'::' is not allowed in reporter name: '" + name + + '\'' ); + auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) ); + CATCH_ENFORCE( ret.second, + "reporter using '" + name + + "' as name was already registered" ); + } + void ReporterRegistry::registerListener( + Detail::unique_ptr factory ) { + m_impl->listeners.push_back( CATCH_MOVE( factory ) ); + } + + std::map const& + ReporterRegistry::getFactories() const { + return m_impl->factories; + } + + std::vector> const& + ReporterRegistry::getListeners() const { + return m_impl->listeners; + } +} // namespace Catch + + + + + +#include + +namespace Catch { + + namespace { + struct kvPair { + StringRef key, value; + }; + + kvPair splitKVPair(StringRef kvString) { + auto splitPos = static_cast( + std::find( kvString.begin(), kvString.end(), '=' ) - + kvString.begin() ); + + return { kvString.substr( 0, splitPos ), + kvString.substr( splitPos + 1, kvString.size() ) }; + } + } + + namespace Detail { + std::vector splitReporterSpec( StringRef reporterSpec ) { + static constexpr auto separator = "::"; + static constexpr size_t separatorSize = 2; + + size_t separatorPos = 0; + auto findNextSeparator = [&reporterSpec]( size_t startPos ) { + static_assert( + separatorSize == 2, + "The code below currently assumes 2 char separator" ); + + auto currentPos = startPos; + do { + while ( currentPos < reporterSpec.size() && + reporterSpec[currentPos] != separator[0] ) { + ++currentPos; + } + if ( currentPos + 1 < reporterSpec.size() && + reporterSpec[currentPos + 1] == separator[1] ) { + return currentPos; + } + ++currentPos; + } while ( currentPos < reporterSpec.size() ); + + return static_cast( -1 ); + }; + + std::vector parts; + + while ( separatorPos < reporterSpec.size() ) { + const auto nextSeparator = findNextSeparator( separatorPos ); + parts.push_back( static_cast( reporterSpec.substr( + separatorPos, nextSeparator - separatorPos ) ) ); + + if ( nextSeparator == static_cast( -1 ) ) { + break; + } + separatorPos = nextSeparator + separatorSize; + } + + // Handle a separator at the end. + // This is not a valid spec, but we want to do validation in a + // centralized place + if ( separatorPos == reporterSpec.size() ) { + parts.emplace_back(); + } + + return parts; + } + + Optional stringToColourMode( StringRef colourMode ) { + if ( colourMode == "default" ) { + return ColourMode::PlatformDefault; + } else if ( colourMode == "ansi" ) { + return ColourMode::ANSI; + } else if ( colourMode == "win32" ) { + return ColourMode::Win32; + } else if ( colourMode == "none" ) { + return ColourMode::None; + } else { + return {}; + } + } + } // namespace Detail + + + bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) { + return lhs.m_name == rhs.m_name && + lhs.m_outputFileName == rhs.m_outputFileName && + lhs.m_colourMode == rhs.m_colourMode && + lhs.m_customOptions == rhs.m_customOptions; + } + + Optional parseReporterSpec( StringRef reporterSpec ) { + auto parts = Detail::splitReporterSpec( reporterSpec ); + + assert( parts.size() > 0 && "Split should never return empty vector" ); + + std::map kvPairs; + Optional outputFileName; + Optional colourMode; + + // First part is always reporter name, so we skip it + for ( size_t i = 1; i < parts.size(); ++i ) { + auto kv = splitKVPair( parts[i] ); + auto key = kv.key, value = kv.value; + + if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone) + return {}; + } else if ( key[0] == 'X' ) { + // This is a reporter-specific option, we don't check these + // apart from basic sanity checks + if ( key.size() == 1 ) { + return {}; + } + + auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) ); + if ( !ret.second ) { + // Duplicated key. We might want to handle this differently, + // e.g. by overwriting the existing value? + return {}; + } + } else if ( key == "out" ) { + // Duplicated key + if ( outputFileName ) { + return {}; + } + outputFileName = static_cast( value ); + } else if ( key == "colour-mode" ) { + // Duplicated key + if ( colourMode ) { + return {}; + } + colourMode = Detail::stringToColourMode( value ); + // Parsing failed + if ( !colourMode ) { + return {}; + } + } else { + // Unrecognized option + return {}; + } + } + + return ReporterSpec{ CATCH_MOVE( parts[0] ), + CATCH_MOVE( outputFileName ), + CATCH_MOVE( colourMode ), + CATCH_MOVE( kvPairs ) }; + } + +ReporterSpec::ReporterSpec( + std::string name, + Optional outputFileName, + Optional colourMode, + std::map customOptions ): + m_name( CATCH_MOVE( name ) ), + m_outputFileName( CATCH_MOVE( outputFileName ) ), + m_colourMode( CATCH_MOVE( colourMode ) ), + m_customOptions( CATCH_MOVE( customOptions ) ) {} + +} // namespace Catch + + + +#include +#include +#include + +namespace Catch { + + // This class encapsulates the idea of a pool of ostringstreams that can be reused. + struct StringStreams { + std::vector> m_streams; + std::vector m_unused; + std::ostringstream m_referenceStream; // Used for copy state/ flags from + + auto add() -> std::size_t { + if( m_unused.empty() ) { + m_streams.push_back( Detail::make_unique() ); + return m_streams.size()-1; + } + else { + auto index = m_unused.back(); + m_unused.pop_back(); + return index; + } + } + + void release( std::size_t index ) { + m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state + m_unused.push_back(index); + } + }; + + ReusableStringStream::ReusableStringStream() + : m_index( Singleton::getMutable().add() ), + m_oss( Singleton::getMutable().m_streams[m_index].get() ) + {} + + ReusableStringStream::~ReusableStringStream() { + static_cast( m_oss )->str(""); + m_oss->clear(); + Singleton::getMutable().release( m_index ); + } + + std::string ReusableStringStream::str() const { + return static_cast( m_oss )->str(); + } + + void ReusableStringStream::str( std::string const& str ) { + static_cast( m_oss )->str( str ); + } + + +} + + + + +#include +#include + +namespace Catch { + + namespace Generators { + namespace { + struct GeneratorTracker final : TestCaseTracking::TrackerBase, + IGeneratorTracker { + GeneratorBasePtr m_generator; + + GeneratorTracker( + TestCaseTracking::NameAndLocation&& nameAndLocation, + TrackerContext& ctx, + ITracker* parent ): + TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {} + + static GeneratorTracker* + acquire( TrackerContext& ctx, + TestCaseTracking::NameAndLocationRef const& + nameAndLocation ) { + GeneratorTracker* tracker; + + ITracker& currentTracker = ctx.currentTracker(); + // Under specific circumstances, the generator we want + // to acquire is also the current tracker. If this is + // the case, we have to avoid looking through current + // tracker's children, and instead return the current + // tracker. + // A case where this check is important is e.g. + // for (int i = 0; i < 5; ++i) { + // int n = GENERATE(1, 2); + // } + // + // without it, the code above creates 5 nested generators. + if ( currentTracker.nameAndLocation() == nameAndLocation ) { + auto thisTracker = currentTracker.parent()->findChild( + nameAndLocation ); + assert( thisTracker ); + assert( thisTracker->isGeneratorTracker() ); + tracker = static_cast( thisTracker ); + } else if ( ITracker* childTracker = + currentTracker.findChild( + nameAndLocation ) ) { + assert( childTracker ); + assert( childTracker->isGeneratorTracker() ); + tracker = + static_cast( childTracker ); + } else { + return nullptr; + } + + if ( !tracker->isComplete() ) { tracker->open(); } + + return tracker; + } + + // TrackerBase interface + bool isGeneratorTracker() const override { return true; } + auto hasGenerator() const -> bool override { + return !!m_generator; + } + void close() override { + TrackerBase::close(); + // If a generator has a child (it is followed by a section) + // and none of its children have started, then we must wait + // until later to start consuming its values. + // This catches cases where `GENERATE` is placed between two + // `SECTION`s. + // **The check for m_children.empty cannot be removed**. + // doing so would break `GENERATE` _not_ followed by + // `SECTION`s. + const bool should_wait_for_child = [&]() { + // No children -> nobody to wait for + if ( m_children.empty() ) { return false; } + // If at least one child started executing, don't wait + if ( std::find_if( + m_children.begin(), + m_children.end(), + []( TestCaseTracking::ITrackerPtr const& + tracker ) { + return tracker->hasStarted(); + } ) != m_children.end() ) { + return false; + } + + // No children have started. We need to check if they + // _can_ start, and thus we should wait for them, or + // they cannot start (due to filters), and we shouldn't + // wait for them + ITracker* parent = m_parent; + // This is safe: there is always at least one section + // tracker in a test case tracking tree + while ( !parent->isSectionTracker() ) { + parent = parent->parent(); + } + assert( parent && + "Missing root (test case) level section" ); + + auto const& parentSection = + static_cast( *parent ); + auto const& filters = parentSection.getFilters(); + // No filters -> no restrictions on running sections + if ( filters.empty() ) { return true; } + + for ( auto const& child : m_children ) { + if ( child->isSectionTracker() && + std::find( filters.begin(), + filters.end(), + static_cast( + *child ) + .trimmedName() ) != + filters.end() ) { + return true; + } + } + return false; + }(); + + // This check is a bit tricky, because m_generator->next() + // has a side-effect, where it consumes generator's current + // value, but we do not want to invoke the side-effect if + // this generator is still waiting for any child to start. + assert( m_generator && "Tracker without generator" ); + if ( should_wait_for_child || + ( m_runState == CompletedSuccessfully && + m_generator->countedNext() ) ) { + m_children.clear(); + m_runState = Executing; + } + } + + // IGeneratorTracker interface + auto getGenerator() const -> GeneratorBasePtr const& override { + return m_generator; + } + void setGenerator( GeneratorBasePtr&& generator ) override { + m_generator = CATCH_MOVE( generator ); + } + }; + } // namespace + } + + RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter) + : m_runInfo(_config->name()), + m_config(_config), + m_reporter(CATCH_MOVE(reporter)), + m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal }, + m_outputRedirect( makeOutputRedirect( m_reporter->getPreferences().shouldRedirectStdOut ) ), + m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions ) + { + getCurrentMutableContext().setResultCapture( this ); + m_reporter->testRunStarting(m_runInfo); + } + + RunContext::~RunContext() { + m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting())); + } + + Totals RunContext::runTest(TestCaseHandle const& testCase) { + const Totals prevTotals = m_totals; + + auto const& testInfo = testCase.getTestCaseInfo(); + m_reporter->testCaseStarting(testInfo); + testCase.prepareTestCase(); + m_activeTestCase = &testCase; + + + ITracker& rootTracker = m_trackerContext.startRun(); + assert(rootTracker.isSectionTracker()); + static_cast(rootTracker).addInitialFilters(m_config->getSectionsToRun()); + + // We intentionally only seed the internal RNG once per test case, + // before it is first invoked. The reason for that is a complex + // interplay of generator/section implementation details and the + // Random*Generator types. + // + // The issue boils down to us needing to seed the Random*Generators + // with different seed each, so that they return different sequences + // of random numbers. We do this by giving them a number from the + // shared RNG instance as their seed. + // + // However, this runs into an issue if the reseeding happens each + // time the test case is entered (as opposed to first time only), + // because multiple generators could get the same seed, e.g. in + // ```cpp + // TEST_CASE() { + // auto i = GENERATE(take(10, random(0, 100)); + // SECTION("A") { + // auto j = GENERATE(take(10, random(0, 100)); + // } + // SECTION("B") { + // auto k = GENERATE(take(10, random(0, 100)); + // } + // } + // ``` + // `i` and `j` would properly return values from different sequences, + // but `i` and `k` would return the same sequence, because their seed + // would be the same. + // (The reason their seeds would be the same is that the generator + // for k would be initialized when the test case is entered the second + // time, after the shared RNG instance was reset to the same value + // it had when the generator for i was initialized.) + seedRng( *m_config ); + + uint64_t testRuns = 0; + std::string redirectedCout; + std::string redirectedCerr; + do { + m_trackerContext.startCycle(); + m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo)); + + m_reporter->testCasePartialStarting(testInfo, testRuns); + + const auto beforeRunTotals = m_totals; + runCurrentTest(); + std::string oneRunCout = m_outputRedirect->getStdout(); + std::string oneRunCerr = m_outputRedirect->getStderr(); + m_outputRedirect->clearBuffers(); + redirectedCout += oneRunCout; + redirectedCerr += oneRunCerr; + + const auto singleRunTotals = m_totals.delta(beforeRunTotals); + auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting()); + m_reporter->testCasePartialEnded(statsForOneRun, testRuns); + + ++testRuns; + } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting()); + + Totals deltaTotals = m_totals.delta(prevTotals); + if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) { + deltaTotals.assertions.failed++; + deltaTotals.testCases.passed--; + deltaTotals.testCases.failed++; + } + m_totals.testCases += deltaTotals.testCases; + testCase.tearDownTestCase(); + m_reporter->testCaseEnded(TestCaseStats(testInfo, + deltaTotals, + CATCH_MOVE(redirectedCout), + CATCH_MOVE(redirectedCerr), + aborting())); + + m_activeTestCase = nullptr; + m_testCaseTracker = nullptr; + + return deltaTotals; + } + + + void RunContext::assertionEnded(AssertionResult&& result) { + if (result.getResultType() == ResultWas::Ok) { + m_totals.assertions.passed++; + m_lastAssertionPassed = true; + } else if (result.getResultType() == ResultWas::ExplicitSkip) { + m_totals.assertions.skipped++; + m_lastAssertionPassed = true; + } else if (!result.succeeded()) { + m_lastAssertionPassed = false; + if (result.isOk()) { + } + else if( m_activeTestCase->getTestCaseInfo().okToFail() ) + m_totals.assertions.failedButOk++; + else + m_totals.assertions.failed++; + } + else { + m_lastAssertionPassed = true; + } + + { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ); + } + + if ( result.getResultType() != ResultWas::Warning ) { + m_messageScopes.clear(); + } + + // Reset working state. assertion info will be reset after + // populateReaction is run if it is needed + m_lastResult = CATCH_MOVE( result ); + } + void RunContext::resetAssertionInfo() { + m_lastAssertionInfo.macroName = StringRef(); + m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr; + m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal; + } + + void RunContext::notifyAssertionStarted( AssertionInfo const& info ) { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->assertionStarting( info ); + } + + bool RunContext::sectionStarted( StringRef sectionName, + SourceLineInfo const& sectionLineInfo, + Counts& assertions ) { + ITracker& sectionTracker = + SectionTracker::acquire( m_trackerContext, + TestCaseTracking::NameAndLocationRef( + sectionName, sectionLineInfo ) ); + + if (!sectionTracker.isOpen()) + return false; + m_activeSections.push_back(§ionTracker); + + SectionInfo sectionInfo( sectionLineInfo, static_cast(sectionName) ); + m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; + + { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->sectionStarting( sectionInfo ); + } + + assertions = m_totals.assertions; + + return true; + } + IGeneratorTracker* + RunContext::acquireGeneratorTracker( StringRef generatorName, + SourceLineInfo const& lineInfo ) { + using namespace Generators; + GeneratorTracker* tracker = GeneratorTracker::acquire( + m_trackerContext, + TestCaseTracking::NameAndLocationRef( + generatorName, lineInfo ) ); + m_lastAssertionInfo.lineInfo = lineInfo; + return tracker; + } + + IGeneratorTracker* RunContext::createGeneratorTracker( + StringRef generatorName, + SourceLineInfo lineInfo, + Generators::GeneratorBasePtr&& generator ) { + + auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast( generatorName ), lineInfo ); + auto& currentTracker = m_trackerContext.currentTracker(); + assert( + currentTracker.nameAndLocation() != nameAndLoc && + "Trying to create tracker for a genreator that already has one" ); + + auto newTracker = Catch::Detail::make_unique( + CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker ); + auto ret = newTracker.get(); + currentTracker.addChild( CATCH_MOVE( newTracker ) ); + + ret->setGenerator( CATCH_MOVE( generator ) ); + ret->open(); + return ret; + } + + bool RunContext::testForMissingAssertions(Counts& assertions) { + if (assertions.total() != 0) + return false; + if (!m_config->warnAboutMissingAssertions()) + return false; + if (m_trackerContext.currentTracker().hasChildren()) + return false; + m_totals.assertions.failed++; + assertions.failed++; + return true; + } + + void RunContext::sectionEnded(SectionEndInfo&& endInfo) { + Counts assertions = m_totals.assertions - endInfo.prevAssertions; + bool missingAssertions = testForMissingAssertions(assertions); + + if (!m_activeSections.empty()) { + m_activeSections.back()->close(); + m_activeSections.pop_back(); + } + + { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->sectionEnded( + SectionStats( CATCH_MOVE( endInfo.sectionInfo ), + assertions, + endInfo.durationInSeconds, + missingAssertions ) ); + } + + m_messages.clear(); + m_messageScopes.clear(); + } + + void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) { + if ( m_unfinishedSections.empty() ) { + m_activeSections.back()->fail(); + } else { + m_activeSections.back()->close(); + } + m_activeSections.pop_back(); + + m_unfinishedSections.push_back(CATCH_MOVE(endInfo)); + } + + void RunContext::benchmarkPreparing( StringRef name ) { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->benchmarkPreparing( name ); + } + void RunContext::benchmarkStarting( BenchmarkInfo const& info ) { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->benchmarkStarting( info ); + } + void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->benchmarkEnded( stats ); + } + void RunContext::benchmarkFailed( StringRef error ) { + auto _ = scopedDeactivate( *m_outputRedirect ); + m_reporter->benchmarkFailed( error ); + } + + void RunContext::pushScopedMessage(MessageInfo const & message) { + m_messages.push_back(message); + } + + void RunContext::popScopedMessage(MessageInfo const & message) { + m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end()); + } + + void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) { + m_messageScopes.emplace_back( CATCH_MOVE(builder) ); + } + + std::string RunContext::getCurrentTestName() const { + return m_activeTestCase + ? m_activeTestCase->getTestCaseInfo().name + : std::string(); + } + + const AssertionResult * RunContext::getLastResult() const { + return &(*m_lastResult); + } + + void RunContext::exceptionEarlyReported() { + m_shouldReportUnexpected = false; + } + + void RunContext::handleFatalErrorCondition( StringRef message ) { + // TODO: scoped deactivate here? Just give up and do best effort? + // the deactivation can break things further, OTOH so can the + // capture + auto _ = scopedDeactivate( *m_outputRedirect ); + + // First notify reporter that bad things happened + m_reporter->fatalErrorEncountered( message ); + + // Don't rebuild the result -- the stringification itself can cause more fatal errors + // Instead, fake a result data. + AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } ); + tempResult.message = static_cast(message); + AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult)); + + assertionEnded(CATCH_MOVE(result) ); + resetAssertionInfo(); + + // Best effort cleanup for sections that have not been destructed yet + // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly + while (!m_activeSections.empty()) { + auto nl = m_activeSections.back()->nameAndLocation(); + SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 }; + sectionEndedEarly(CATCH_MOVE(endInfo)); + } + handleUnfinishedSections(); + + // Recreate section for test case (as we will lose the one that was in scope) + auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name); + + Counts assertions; + assertions.failed = 1; + SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false); + m_reporter->sectionEnded( testCaseSectionStats ); + + auto const& testInfo = m_activeTestCase->getTestCaseInfo(); + + Totals deltaTotals; + deltaTotals.testCases.failed = 1; + deltaTotals.assertions.failed = 1; + m_reporter->testCaseEnded(TestCaseStats(testInfo, + deltaTotals, + std::string(), + std::string(), + false)); + m_totals.testCases.failed++; + m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false)); + } + + bool RunContext::lastAssertionPassed() { + return m_lastAssertionPassed; + } + + void RunContext::assertionPassed() { + m_lastAssertionPassed = true; + ++m_totals.assertions.passed; + resetAssertionInfo(); + m_messageScopes.clear(); + } + + bool RunContext::aborting() const { + return m_totals.assertions.failed >= static_cast(m_config->abortAfter()); + } + + void RunContext::runCurrentTest() { + auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name); + m_reporter->sectionStarting(testCaseSection); + Counts prevAssertions = m_totals.assertions; + double duration = 0; + m_shouldReportUnexpected = true; + m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal }; + + Timer timer; + CATCH_TRY { + { + auto _ = scopedActivate( *m_outputRedirect ); + timer.start(); + invokeActiveTestCase(); + } + duration = timer.getElapsedSeconds(); + } CATCH_CATCH_ANON (TestFailureException&) { + // This just means the test was aborted due to failure + } CATCH_CATCH_ANON (TestSkipException&) { + // This just means the test was explicitly skipped + } CATCH_CATCH_ALL { + // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions + // are reported without translation at the point of origin. + if( m_shouldReportUnexpected ) { + AssertionReaction dummyReaction; + handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction ); + } + } + Counts assertions = m_totals.assertions - prevAssertions; + bool missingAssertions = testForMissingAssertions(assertions); + + m_testCaseTracker->close(); + handleUnfinishedSections(); + m_messages.clear(); + m_messageScopes.clear(); + + SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions); + m_reporter->sectionEnded(testCaseSectionStats); + } + + void RunContext::invokeActiveTestCase() { + // We need to engage a handler for signals/structured exceptions + // before running the tests themselves, or the binary can crash + // without failed test being reported. + FatalConditionHandlerGuard _(&m_fatalConditionhandler); + // We keep having issue where some compilers warn about an unused + // variable, even though the type has non-trivial constructor and + // destructor. This is annoying and ugly, but it makes them stfu. + (void)_; + + m_activeTestCase->invoke(); + } + + void RunContext::handleUnfinishedSections() { + // If sections ended prematurely due to an exception we stored their + // infos here so we can tear them down outside the unwind process. + for ( auto it = m_unfinishedSections.rbegin(), + itEnd = m_unfinishedSections.rend(); + it != itEnd; + ++it ) { + sectionEnded( CATCH_MOVE( *it ) ); + } + m_unfinishedSections.clear(); + } + + void RunContext::handleExpr( + AssertionInfo const& info, + ITransientExpression const& expr, + AssertionReaction& reaction + ) { + bool negated = isFalseTest( info.resultDisposition ); + bool result = expr.getResult() != negated; + + if( result ) { + if (!m_includeSuccessfulResults) { + assertionPassed(); + } + else { + reportExpr(info, ResultWas::Ok, &expr, negated); + } + } + else { + reportExpr(info, ResultWas::ExpressionFailed, &expr, negated ); + populateReaction( reaction ); + } + resetAssertionInfo(); + } + void RunContext::reportExpr( + AssertionInfo const &info, + ResultWas::OfType resultType, + ITransientExpression const *expr, + bool negated ) { + + m_lastAssertionInfo = info; + AssertionResultData data( resultType, LazyExpression( negated ) ); + + AssertionResult assertionResult{ info, CATCH_MOVE( data ) }; + assertionResult.m_resultData.lazyExpression.m_transientExpression = expr; + + assertionEnded( CATCH_MOVE(assertionResult) ); + } + + void RunContext::handleMessage( + AssertionInfo const& info, + ResultWas::OfType resultType, + std::string&& message, + AssertionReaction& reaction + ) { + m_lastAssertionInfo = info; + + AssertionResultData data( resultType, LazyExpression( false ) ); + data.message = CATCH_MOVE( message ); + AssertionResult assertionResult{ m_lastAssertionInfo, + CATCH_MOVE( data ) }; + + const auto isOk = assertionResult.isOk(); + assertionEnded( CATCH_MOVE(assertionResult) ); + if ( !isOk ) { + populateReaction( reaction ); + } else if ( resultType == ResultWas::ExplicitSkip ) { + // TODO: Need to handle this explicitly, as ExplicitSkip is + // considered "OK" + reaction.shouldSkip = true; + } + resetAssertionInfo(); + } + void RunContext::handleUnexpectedExceptionNotThrown( + AssertionInfo const& info, + AssertionReaction& reaction + ) { + handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction); + } + + void RunContext::handleUnexpectedInflightException( + AssertionInfo const& info, + std::string&& message, + AssertionReaction& reaction + ) { + m_lastAssertionInfo = info; + + AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) ); + data.message = CATCH_MOVE(message); + AssertionResult assertionResult{ info, CATCH_MOVE(data) }; + assertionEnded( CATCH_MOVE(assertionResult) ); + populateReaction( reaction ); + resetAssertionInfo(); + } + + void RunContext::populateReaction( AssertionReaction& reaction ) { + reaction.shouldDebugBreak = m_config->shouldDebugBreak(); + reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal); + } + + void RunContext::handleIncomplete( + AssertionInfo const& info + ) { + using namespace std::string_literals; + m_lastAssertionInfo = info; + + AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) ); + data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s; + AssertionResult assertionResult{ info, CATCH_MOVE( data ) }; + assertionEnded( CATCH_MOVE(assertionResult) ); + resetAssertionInfo(); + } + void RunContext::handleNonExpr( + AssertionInfo const &info, + ResultWas::OfType resultType, + AssertionReaction &reaction + ) { + m_lastAssertionInfo = info; + + AssertionResultData data( resultType, LazyExpression( false ) ); + AssertionResult assertionResult{ info, CATCH_MOVE( data ) }; + + const auto isOk = assertionResult.isOk(); + assertionEnded( CATCH_MOVE(assertionResult) ); + if ( !isOk ) { populateReaction( reaction ); } + resetAssertionInfo(); + } + + + IResultCapture& getResultCapture() { + if (auto* capture = getCurrentContext().getResultCapture()) + return *capture; + else + CATCH_INTERNAL_ERROR("No result capture instance"); + } + + void seedRng(IConfig const& config) { + sharedRng().seed(config.rngSeed()); + } + + unsigned int rngSeed() { + return getCurrentContext().getConfig()->rngSeed(); + } + +} + + + +namespace Catch { + + Section::Section( SectionInfo&& info ): + m_info( CATCH_MOVE( info ) ), + m_sectionIncluded( + getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) { + // Non-"included" sections will not use the timing information + // anyway, so don't bother with the potential syscall. + if (m_sectionIncluded) { + m_timer.start(); + } + } + + Section::Section( SourceLineInfo const& _lineInfo, + StringRef _name, + const char* const ): + m_info( { "invalid", static_cast( -1 ) }, std::string{} ), + m_sectionIncluded( + getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) { + // We delay initialization the SectionInfo member until we know + // this section needs it, so we avoid allocating std::string for name. + // We also delay timer start to avoid the potential syscall unless we + // will actually use the result. + if ( m_sectionIncluded ) { + m_info.name = static_cast( _name ); + m_info.lineInfo = _lineInfo; + m_timer.start(); + } + } + + Section::~Section() { + if( m_sectionIncluded ) { + SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() }; + if ( uncaught_exceptions() ) { + getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) ); + } else { + getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) ); + } + } + } + + // This indicates whether the section should be executed or not + Section::operator bool() const { + return m_sectionIncluded; + } + + +} // end namespace Catch + + + +#include + +namespace Catch { + + namespace { + static auto getSingletons() -> std::vector*& { + static std::vector* g_singletons = nullptr; + if( !g_singletons ) + g_singletons = new std::vector(); + return g_singletons; + } + } + + ISingleton::~ISingleton() = default; + + void addSingleton(ISingleton* singleton ) { + getSingletons()->push_back( singleton ); + } + void cleanupSingletons() { + auto& singletons = getSingletons(); + for( auto singleton : *singletons ) + delete singleton; + delete singletons; + singletons = nullptr; + } + +} // namespace Catch + + + +#include +#include + +namespace Catch { + + bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept { + return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0); + } + bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept { + // We can assume that the same file will usually have the same pointer. + // Thus, if the pointers are the same, there is no point in calling the strcmp + return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0)); + } + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { +#ifndef __GNUG__ + os << info.file << '(' << info.line << ')'; +#else + os << info.file << ':' << info.line; +#endif + return os; + } + +} // end namespace Catch + + + + +namespace Catch { +#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept { + CATCH_TRY { + m_exceptions.push_back(exception); + } CATCH_CATCH_ALL { + // If we run out of memory during start-up there's really not a lot more we can do about it + std::terminate(); + } + } + + std::vector const& StartupExceptionRegistry::getExceptions() const noexcept { + return m_exceptions; + } +#endif + +} // end namespace Catch + + + + + +#include + +namespace Catch { + +// If you #define this you must implement these functions +#if !defined( CATCH_CONFIG_NOSTDOUT ) + std::ostream& cout() { return std::cout; } + std::ostream& cerr() { return std::cerr; } + std::ostream& clog() { return std::clog; } +#endif + +} // namespace Catch + + + +#include +#include +#include +#include + +namespace Catch { + + bool startsWith( std::string const& s, std::string const& prefix ) { + return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin()); + } + bool startsWith( StringRef s, char prefix ) { + return !s.empty() && s[0] == prefix; + } + bool endsWith( std::string const& s, std::string const& suffix ) { + return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin()); + } + bool endsWith( std::string const& s, char suffix ) { + return !s.empty() && s[s.size()-1] == suffix; + } + bool contains( std::string const& s, std::string const& infix ) { + return s.find( infix ) != std::string::npos; + } + void toLowerInPlace( std::string& s ) { + for ( char& c : s ) { + c = toLower( c ); + } + } + std::string toLower( std::string const& s ) { + std::string lc = s; + toLowerInPlace( lc ); + return lc; + } + char toLower(char c) { + return static_cast(std::tolower(static_cast(c))); + } + + std::string trim( std::string const& str ) { + static char const* whitespaceChars = "\n\r\t "; + std::string::size_type start = str.find_first_not_of( whitespaceChars ); + std::string::size_type end = str.find_last_not_of( whitespaceChars ); + + return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string(); + } + + StringRef trim(StringRef ref) { + const auto is_ws = [](char c) { + return c == ' ' || c == '\t' || c == '\n' || c == '\r'; + }; + size_t real_begin = 0; + while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; } + size_t real_end = ref.size(); + while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; } + + return ref.substr(real_begin, real_end - real_begin); + } + + bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { + std::size_t i = str.find( replaceThis ); + if (i == std::string::npos) { + return false; + } + std::size_t copyBegin = 0; + std::string origStr = CATCH_MOVE(str); + str.clear(); + // There is at least one replacement, so reserve with the best guess + // we can make without actually counting the number of occurences. + str.reserve(origStr.size() - replaceThis.size() + withThis.size()); + do { + str.append(origStr, copyBegin, i-copyBegin ); + str += withThis; + copyBegin = i + replaceThis.size(); + if( copyBegin < origStr.size() ) + i = origStr.find( replaceThis, copyBegin ); + else + i = std::string::npos; + } while( i != std::string::npos ); + if ( copyBegin < origStr.size() ) { + str.append(origStr, copyBegin, origStr.size() ); + } + return true; + } + + std::vector splitStringRef( StringRef str, char delimiter ) { + std::vector subStrings; + std::size_t start = 0; + for(std::size_t pos = 0; pos < str.size(); ++pos ) { + if( str[pos] == delimiter ) { + if( pos - start > 1 ) + subStrings.push_back( str.substr( start, pos-start ) ); + start = pos+1; + } + } + if( start < str.size() ) + subStrings.push_back( str.substr( start, str.size()-start ) ); + return subStrings; + } + + std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { + os << pluraliser.m_count << ' ' << pluraliser.m_label; + if( pluraliser.m_count != 1 ) + os << 's'; + return os; + } + +} + + + +#include +#include +#include +#include + +namespace Catch { + StringRef::StringRef( char const* rawChars ) noexcept + : StringRef( rawChars, std::strlen(rawChars) ) + {} + + + bool StringRef::operator<(StringRef rhs) const noexcept { + if (m_size < rhs.m_size) { + return strncmp(m_start, rhs.m_start, m_size) <= 0; + } + return strncmp(m_start, rhs.m_start, rhs.m_size) < 0; + } + + int StringRef::compare( StringRef rhs ) const { + auto cmpResult = + strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) ); + + // This means that strncmp found a difference before the strings + // ended, and we can return it directly + if ( cmpResult != 0 ) { + return cmpResult; + } + + // If strings are equal up to length, then their comparison results on + // their size + if ( m_size < rhs.m_size ) { + return -1; + } else if ( m_size > rhs.m_size ) { + return 1; + } else { + return 0; + } + } + + auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& { + return os.write(str.data(), static_cast(str.size())); + } + + std::string operator+(StringRef lhs, StringRef rhs) { + std::string ret; + ret.reserve(lhs.size() + rhs.size()); + ret += lhs; + ret += rhs; + return ret; + } + + auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& { + lhs.append(rhs.data(), rhs.size()); + return lhs; + } + +} // namespace Catch + + + +namespace Catch { + + TagAliasRegistry::~TagAliasRegistry() = default; + + TagAlias const* TagAliasRegistry::find( std::string const& alias ) const { + auto it = m_registry.find( alias ); + if( it != m_registry.end() ) + return &(it->second); + else + return nullptr; + } + + std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { + std::string expandedTestSpec = unexpandedTestSpec; + for( auto const& registryKvp : m_registry ) { + std::size_t pos = expandedTestSpec.find( registryKvp.first ); + if( pos != std::string::npos ) { + expandedTestSpec = expandedTestSpec.substr( 0, pos ) + + registryKvp.second.tag + + expandedTestSpec.substr( pos + registryKvp.first.size() ); + } + } + return expandedTestSpec; + } + + void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) { + CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'), + "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo ); + + CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second, + "error: tag alias, '" << alias << "' already registered.\n" + << "\tFirst seen at: " << find(alias)->lineInfo << "\n" + << "\tRedefined at: " << lineInfo ); + } + + ITagAliasRegistry::~ITagAliasRegistry() = default; + + ITagAliasRegistry const& ITagAliasRegistry::get() { + return getRegistryHub().getTagAliasRegistry(); + } + +} // end namespace Catch + + + + +namespace Catch { + TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {} + + uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const { + // FNV-1a hash algorithm that is designed for uniqueness: + const hash_t prime = 1099511628211u; + hash_t hash = 14695981039346656037u; + for ( const char c : t.name ) { + hash ^= c; + hash *= prime; + } + for ( const char c : t.className ) { + hash ^= c; + hash *= prime; + } + for ( const Tag& tag : t.tags ) { + for ( const char c : tag.original ) { + hash ^= c; + hash *= prime; + } + } + hash ^= m_seed; + hash *= prime; + const uint32_t low{ static_cast( hash ) }; + const uint32_t high{ static_cast( hash >> 32 ) }; + return low * high; + } +} // namespace Catch + + + + +#include +#include + +namespace Catch { + + namespace { + static void enforceNoDuplicateTestCases( + std::vector const& tests ) { + auto testInfoCmp = []( TestCaseInfo const* lhs, + TestCaseInfo const* rhs ) { + return *lhs < *rhs; + }; + std::set seenTests( + testInfoCmp ); + for ( auto const& test : tests ) { + const auto infoPtr = &test.getTestCaseInfo(); + const auto prev = seenTests.insert( infoPtr ); + CATCH_ENFORCE( prev.second, + "error: test case \"" + << infoPtr->name << "\", with tags \"" + << infoPtr->tagsAsString() + << "\" already defined.\n" + << "\tFirst seen at " + << ( *prev.first )->lineInfo << "\n" + << "\tRedefined at " << infoPtr->lineInfo ); + } + } + + static bool matchTest( TestCaseHandle const& testCase, + TestSpec const& testSpec, + IConfig const& config ) { + return testSpec.matches( testCase.getTestCaseInfo() ) && + isThrowSafe( testCase, config ); + } + + } // end unnamed namespace + + std::vector sortTests( IConfig const& config, std::vector const& unsortedTestCases ) { + switch (config.runOrder()) { + case TestRunOrder::Declared: + return unsortedTestCases; + + case TestRunOrder::LexicographicallySorted: { + std::vector sorted = unsortedTestCases; + std::sort( + sorted.begin(), + sorted.end(), + []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) { + return lhs.getTestCaseInfo() < rhs.getTestCaseInfo(); + } + ); + return sorted; + } + case TestRunOrder::Randomized: { + using TestWithHash = std::pair; + + TestCaseInfoHasher h{ config.rngSeed() }; + std::vector indexed_tests; + indexed_tests.reserve(unsortedTestCases.size()); + + for (auto const& handle : unsortedTestCases) { + indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle); + } + + std::sort( indexed_tests.begin(), + indexed_tests.end(), + []( TestWithHash const& lhs, TestWithHash const& rhs ) { + if ( lhs.first == rhs.first ) { + return lhs.second.getTestCaseInfo() < + rhs.second.getTestCaseInfo(); + } + return lhs.first < rhs.first; + } ); + + std::vector randomized; + randomized.reserve(indexed_tests.size()); + + for (auto const& indexed : indexed_tests) { + randomized.push_back(indexed.second); + } + + return randomized; + } + } + + CATCH_INTERNAL_ERROR("Unknown test order value!"); + } + + bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) { + return !testCase.getTestCaseInfo().throws() || config.allowThrows(); + } + + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ) { + std::vector filtered; + filtered.reserve( testCases.size() ); + for (auto const& testCase : testCases) { + if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) || + (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) { + filtered.push_back(testCase); + } + } + return createShard(filtered, config.shardCount(), config.shardIndex()); + } + std::vector const& getAllTestCasesSorted( IConfig const& config ) { + return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config ); + } + + TestRegistry::~TestRegistry() = default; + + void TestRegistry::registerTest(Detail::unique_ptr testInfo, Detail::unique_ptr testInvoker) { + m_handles.emplace_back(testInfo.get(), testInvoker.get()); + m_viewed_test_infos.push_back(testInfo.get()); + m_owned_test_infos.push_back(CATCH_MOVE(testInfo)); + m_invokers.push_back(CATCH_MOVE(testInvoker)); + } + + std::vector const& TestRegistry::getAllInfos() const { + return m_viewed_test_infos; + } + + std::vector const& TestRegistry::getAllTests() const { + return m_handles; + } + std::vector const& TestRegistry::getAllTestsSorted( IConfig const& config ) const { + if( m_sortedFunctions.empty() ) + enforceNoDuplicateTestCases( m_handles ); + + if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) { + m_sortedFunctions = sortTests( config, m_handles ); + m_currentSortOrder = config.runOrder(); + } + return m_sortedFunctions; + } + +} // end namespace Catch + + + + +#include +#include + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wexit-time-destructors" +#endif + +namespace Catch { +namespace TestCaseTracking { + + NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location ) + : name( CATCH_MOVE(_name) ), + location( _location ) + {} + + + ITracker::~ITracker() = default; + + void ITracker::markAsNeedingAnotherRun() { + m_runState = NeedsAnotherRun; + } + + void ITracker::addChild( ITrackerPtr&& child ) { + m_children.push_back( CATCH_MOVE(child) ); + } + + ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) { + auto it = std::find_if( + m_children.begin(), + m_children.end(), + [&nameAndLocation]( ITrackerPtr const& tracker ) { + auto const& tnameAndLoc = tracker->nameAndLocation(); + if ( tnameAndLoc.location.line != + nameAndLocation.location.line ) { + return false; + } + return tnameAndLoc == nameAndLocation; + } ); + return ( it != m_children.end() ) ? it->get() : nullptr; + } + + bool ITracker::isSectionTracker() const { return false; } + bool ITracker::isGeneratorTracker() const { return false; } + + bool ITracker::isOpen() const { + return m_runState != NotStarted && !isComplete(); + } + + bool ITracker::hasStarted() const { return m_runState != NotStarted; } + + void ITracker::openChild() { + if (m_runState != ExecutingChildren) { + m_runState = ExecutingChildren; + if (m_parent) { + m_parent->openChild(); + } + } + } + + ITracker& TrackerContext::startRun() { + using namespace std::string_literals; + m_rootTracker = Catch::Detail::make_unique( + NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ), + *this, + nullptr ); + m_currentTracker = nullptr; + m_runState = Executing; + return *m_rootTracker; + } + + void TrackerContext::completeCycle() { + m_runState = CompletedCycle; + } + + bool TrackerContext::completedCycle() const { + return m_runState == CompletedCycle; + } + void TrackerContext::setCurrentTracker( ITracker* tracker ) { + m_currentTracker = tracker; + } + + + TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ): + ITracker(CATCH_MOVE(nameAndLocation), parent), + m_ctx( ctx ) + {} + + bool TrackerBase::isComplete() const { + return m_runState == CompletedSuccessfully || m_runState == Failed; + } + + void TrackerBase::open() { + m_runState = Executing; + moveToThis(); + if( m_parent ) + m_parent->openChild(); + } + + void TrackerBase::close() { + + // Close any still open children (e.g. generators) + while( &m_ctx.currentTracker() != this ) + m_ctx.currentTracker().close(); + + switch( m_runState ) { + case NeedsAnotherRun: + break; + + case Executing: + m_runState = CompletedSuccessfully; + break; + case ExecutingChildren: + if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) ) + m_runState = CompletedSuccessfully; + break; + + case NotStarted: + case CompletedSuccessfully: + case Failed: + CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState ); + + default: + CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState ); + } + moveToParent(); + m_ctx.completeCycle(); + } + void TrackerBase::fail() { + m_runState = Failed; + if( m_parent ) + m_parent->markAsNeedingAnotherRun(); + moveToParent(); + m_ctx.completeCycle(); + } + + void TrackerBase::moveToParent() { + assert( m_parent ); + m_ctx.setCurrentTracker( m_parent ); + } + void TrackerBase::moveToThis() { + m_ctx.setCurrentTracker( this ); + } + + SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ) + : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ), + m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name))) + { + if( parent ) { + while ( !parent->isSectionTracker() ) { + parent = parent->parent(); + } + + SectionTracker& parentSection = static_cast( *parent ); + addNextFilters( parentSection.m_filters ); + } + } + + bool SectionTracker::isComplete() const { + bool complete = true; + + if (m_filters.empty() + || m_filters[0].empty() + || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) { + complete = TrackerBase::isComplete(); + } + return complete; + } + + bool SectionTracker::isSectionTracker() const { return true; } + + SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) { + SectionTracker* tracker; + + ITracker& currentTracker = ctx.currentTracker(); + if ( ITracker* childTracker = + currentTracker.findChild( nameAndLocation ) ) { + assert( childTracker ); + assert( childTracker->isSectionTracker() ); + tracker = static_cast( childTracker ); + } else { + auto newTracker = Catch::Detail::make_unique( + NameAndLocation{ static_cast(nameAndLocation.name), + nameAndLocation.location }, + ctx, + ¤tTracker ); + tracker = newTracker.get(); + currentTracker.addChild( CATCH_MOVE( newTracker ) ); + } + + if ( !ctx.completedCycle() ) { + tracker->tryOpen(); + } + + return *tracker; + } + + void SectionTracker::tryOpen() { + if( !isComplete() ) + open(); + } + + void SectionTracker::addInitialFilters( std::vector const& filters ) { + if( !filters.empty() ) { + m_filters.reserve( m_filters.size() + filters.size() + 2 ); + m_filters.emplace_back(StringRef{}); // Root - should never be consulted + m_filters.emplace_back(StringRef{}); // Test Case - not a section filter + m_filters.insert( m_filters.end(), filters.begin(), filters.end() ); + } + } + void SectionTracker::addNextFilters( std::vector const& filters ) { + if( filters.size() > 1 ) + m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() ); + } + + StringRef SectionTracker::trimmedName() const { + return m_trimmed_name; + } + +} // namespace TestCaseTracking + +} // namespace Catch + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + + + + +namespace Catch { + + void throw_test_failure_exception() { +#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) + throw TestFailureException{}; +#else + CATCH_ERROR( "Test failure requires aborting test!" ); +#endif + } + + void throw_test_skip_exception() { +#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) + throw Catch::TestSkipException(); +#else + CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" ); +#endif + } + +} // namespace Catch + + + +#include +#include + +namespace Catch { + void ITestInvoker::prepareTestCase() {} + void ITestInvoker::tearDownTestCase() {} + ITestInvoker::~ITestInvoker() = default; + + namespace { + static StringRef extractClassName( StringRef classOrMethodName ) { + if ( !startsWith( classOrMethodName, '&' ) ) { + return classOrMethodName; + } + + // Remove the leading '&' to avoid having to special case it later + const auto methodName = + classOrMethodName.substr( 1, classOrMethodName.size() ); + + auto reverseStart = std::make_reverse_iterator( methodName.end() ); + auto reverseEnd = std::make_reverse_iterator( methodName.begin() ); + + // We make a simplifying assumption that ":" is only present + // in the input as part of "::" from C++ typenames (this is + // relatively safe assumption because the input is generated + // as stringification of type through preprocessor). + auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1; + auto secondLastColons = + std::find( lastColons + 1, reverseEnd, ':' ); + + auto const startIdx = reverseEnd - secondLastColons; + auto const classNameSize = secondLastColons - lastColons - 1; + + return methodName.substr( + static_cast( startIdx ), + static_cast( classNameSize ) ); + } + + class TestInvokerAsFunction final : public ITestInvoker { + using TestType = void ( * )(); + TestType m_testAsFunction; + + public: + constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept: + m_testAsFunction( testAsFunction ) {} + + void invoke() const override { m_testAsFunction(); } + }; + + } // namespace + + Detail::unique_ptr makeTestInvoker( void(*testAsFunction)() ) { + return Detail::make_unique( testAsFunction ); + } + + AutoReg::AutoReg( Detail::unique_ptr invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept { + CATCH_TRY { + getMutableRegistryHub() + .registerTest( + makeTestCaseInfo( + extractClassName( classOrMethod ), + nameAndTags, + lineInfo), + CATCH_MOVE(invoker) + ); + } CATCH_CATCH_ALL { + // Do not throw when constructing global objects, instead register the exception to be processed later + getMutableRegistryHub().registerStartupException(); + } + } +} + + + + + +namespace Catch { + + TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {} + + TestSpecParser& TestSpecParser::parse( std::string const& arg ) { + m_mode = None; + m_exclusion = false; + m_arg = m_tagAliases->expandAliases( arg ); + m_escapeChars.clear(); + m_substring.reserve(m_arg.size()); + m_patternName.reserve(m_arg.size()); + m_realPatternPos = 0; + + for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) + //if visitChar fails + if( !visitChar( m_arg[m_pos] ) ){ + m_testSpec.m_invalidSpecs.push_back(arg); + break; + } + endMode(); + return *this; + } + TestSpec TestSpecParser::testSpec() { + addFilter(); + return CATCH_MOVE(m_testSpec); + } + bool TestSpecParser::visitChar( char c ) { + if( (m_mode != EscapedName) && (c == '\\') ) { + escape(); + addCharToPattern(c); + return true; + }else if((m_mode != EscapedName) && (c == ',') ) { + return separate(); + } + + switch( m_mode ) { + case None: + if( processNoneChar( c ) ) + return true; + break; + case Name: + processNameChar( c ); + break; + case EscapedName: + endMode(); + addCharToPattern(c); + return true; + default: + case Tag: + case QuotedName: + if( processOtherChar( c ) ) + return true; + break; + } + + m_substring += c; + if( !isControlChar( c ) ) { + m_patternName += c; + m_realPatternPos++; + } + return true; + } + // Two of the processing methods return true to signal the caller to return + // without adding the given character to the current pattern strings + bool TestSpecParser::processNoneChar( char c ) { + switch( c ) { + case ' ': + return true; + case '~': + m_exclusion = true; + return false; + case '[': + startNewMode( Tag ); + return false; + case '"': + startNewMode( QuotedName ); + return false; + default: + startNewMode( Name ); + return false; + } + } + void TestSpecParser::processNameChar( char c ) { + if( c == '[' ) { + if( m_substring == "exclude:" ) + m_exclusion = true; + else + endMode(); + startNewMode( Tag ); + } + } + bool TestSpecParser::processOtherChar( char c ) { + if( !isControlChar( c ) ) + return false; + m_substring += c; + endMode(); + return true; + } + void TestSpecParser::startNewMode( Mode mode ) { + m_mode = mode; + } + void TestSpecParser::endMode() { + switch( m_mode ) { + case Name: + case QuotedName: + return addNamePattern(); + case Tag: + return addTagPattern(); + case EscapedName: + revertBackToLastMode(); + return; + case None: + default: + return startNewMode( None ); + } + } + void TestSpecParser::escape() { + saveLastMode(); + m_mode = EscapedName; + m_escapeChars.push_back(m_realPatternPos); + } + bool TestSpecParser::isControlChar( char c ) const { + switch( m_mode ) { + default: + return false; + case None: + return c == '~'; + case Name: + return c == '['; + case EscapedName: + return true; + case QuotedName: + return c == '"'; + case Tag: + return c == '[' || c == ']'; + } + } + + void TestSpecParser::addFilter() { + if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) { + m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) ); + m_currentFilter = TestSpec::Filter(); + } + } + + void TestSpecParser::saveLastMode() { + lastMode = m_mode; + } + + void TestSpecParser::revertBackToLastMode() { + m_mode = lastMode; + } + + bool TestSpecParser::separate() { + if( (m_mode==QuotedName) || (m_mode==Tag) ){ + //invalid argument, signal failure to previous scope. + m_mode = None; + m_pos = m_arg.size(); + m_substring.clear(); + m_patternName.clear(); + m_realPatternPos = 0; + return false; + } + endMode(); + addFilter(); + return true; //success + } + + std::string TestSpecParser::preprocessPattern() { + std::string token = m_patternName; + for (std::size_t i = 0; i < m_escapeChars.size(); ++i) + token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1); + m_escapeChars.clear(); + if (startsWith(token, "exclude:")) { + m_exclusion = true; + token = token.substr(8); + } + + m_patternName.clear(); + m_realPatternPos = 0; + + return token; + } + + void TestSpecParser::addNamePattern() { + auto token = preprocessPattern(); + + if (!token.empty()) { + if (m_exclusion) { + m_currentFilter.m_forbidden.emplace_back(Detail::make_unique(token, m_substring)); + } else { + m_currentFilter.m_required.emplace_back(Detail::make_unique(token, m_substring)); + } + } + m_substring.clear(); + m_exclusion = false; + m_mode = None; + } + + void TestSpecParser::addTagPattern() { + auto token = preprocessPattern(); + + if (!token.empty()) { + // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo]) + // we have to create a separate hide tag and shorten the real one + if (token.size() > 1 && token[0] == '.') { + token.erase(token.begin()); + if (m_exclusion) { + m_currentFilter.m_forbidden.emplace_back(Detail::make_unique(".", m_substring)); + } else { + m_currentFilter.m_required.emplace_back(Detail::make_unique(".", m_substring)); + } + } + if (m_exclusion) { + m_currentFilter.m_forbidden.emplace_back(Detail::make_unique(token, m_substring)); + } else { + m_currentFilter.m_required.emplace_back(Detail::make_unique(token, m_substring)); + } + } + m_substring.clear(); + m_exclusion = false; + m_mode = None; + } + +} // namespace Catch + + + +#include +#include +#include + +namespace { + bool isWhitespace( char c ) { + return c == ' ' || c == '\t' || c == '\n' || c == '\r'; + } + + bool isBreakableBefore( char c ) { + static const char chars[] = "[({<|"; + return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr; + } + + bool isBreakableAfter( char c ) { + static const char chars[] = "])}>.,:;*+-=&/\\"; + return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr; + } + +} // namespace + +namespace Catch { + namespace TextFlow { + void AnsiSkippingString::preprocessString() { + for ( auto it = m_string.begin(); it != m_string.end(); ) { + // try to read through an ansi sequence + while ( it != m_string.end() && *it == '\033' && + it + 1 != m_string.end() && *( it + 1 ) == '[' ) { + auto cursor = it + 2; + while ( cursor != m_string.end() && + ( isdigit( *cursor ) || *cursor == ';' ) ) { + ++cursor; + } + if ( cursor == m_string.end() || *cursor != 'm' ) { + break; + } + // 'm' -> 0xff + *cursor = AnsiSkippingString::sentinel; + // if we've read an ansi sequence, set the iterator and + // return to the top of the loop + it = cursor + 1; + } + if ( it != m_string.end() ) { + ++m_size; + ++it; + } + } + } + + AnsiSkippingString::AnsiSkippingString( std::string const& text ): + m_string( text ) { + preprocessString(); + } + + AnsiSkippingString::AnsiSkippingString( std::string&& text ): + m_string( CATCH_MOVE( text ) ) { + preprocessString(); + } + + AnsiSkippingString::const_iterator AnsiSkippingString::begin() const { + return const_iterator( m_string ); + } + + AnsiSkippingString::const_iterator AnsiSkippingString::end() const { + return const_iterator( m_string, const_iterator::EndTag{} ); + } + + std::string AnsiSkippingString::substring( const_iterator begin, + const_iterator end ) const { + // There's one caveat here to an otherwise simple substring: when + // making a begin iterator we might have skipped ansi sequences at + // the start. If `begin` here is a begin iterator, skipped over + // initial ansi sequences, we'll use the true beginning of the + // string. Lastly: We need to transform any chars we replaced with + // 0xff back to 'm' + auto str = std::string( begin == this->begin() ? m_string.begin() + : begin.m_it, + end.m_it ); + std::transform( str.begin(), str.end(), str.begin(), []( char c ) { + return c == AnsiSkippingString::sentinel ? 'm' : c; + } ); + return str; + } + + void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() { + // check if we've landed on an ansi sequence, and if so read through + // it + while ( m_it != m_string->end() && *m_it == '\033' && + m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) { + auto cursor = m_it + 2; + while ( cursor != m_string->end() && + ( isdigit( *cursor ) || *cursor == ';' ) ) { + ++cursor; + } + if ( cursor == m_string->end() || + *cursor != AnsiSkippingString::sentinel ) { + break; + } + // if we've read an ansi sequence, set the iterator and + // return to the top of the loop + m_it = cursor + 1; + } + } + + void AnsiSkippingString::const_iterator::advance() { + assert( m_it != m_string->end() ); + m_it++; + tryParseAnsiEscapes(); + } + + void AnsiSkippingString::const_iterator::unadvance() { + assert( m_it != m_string->begin() ); + m_it--; + // if *m_it is 0xff, scan back to the \033 and then m_it-- once more + // (and repeat check) + while ( *m_it == AnsiSkippingString::sentinel ) { + while ( *m_it != '\033' ) { + assert( m_it != m_string->begin() ); + m_it--; + } + // if this happens, we must have been a begin iterator that had + // skipped over ansi sequences at the start of a string + assert( m_it != m_string->begin() ); + assert( *m_it == '\033' ); + m_it--; + } + } + + static bool isBoundary( AnsiSkippingString const& line, + AnsiSkippingString::const_iterator it ) { + return it == line.end() || + ( isWhitespace( *it ) && + !isWhitespace( *it.oneBefore() ) ) || + isBreakableBefore( *it ) || + isBreakableAfter( *it.oneBefore() ); + } + + void Column::const_iterator::calcLength() { + m_addHyphen = false; + m_parsedTo = m_lineStart; + AnsiSkippingString const& current_line = m_column.m_string; + + if ( m_parsedTo == current_line.end() ) { + m_lineEnd = m_parsedTo; + return; + } + + assert( m_lineStart != current_line.end() ); + if ( *m_lineStart == '\n' ) { ++m_parsedTo; } + + const auto maxLineLength = m_column.m_width - indentSize(); + std::size_t lineLength = 0; + while ( m_parsedTo != current_line.end() && + lineLength < maxLineLength && *m_parsedTo != '\n' ) { + ++m_parsedTo; + ++lineLength; + } + + // If we encountered a newline before the column is filled, + // then we linebreak at the newline and consider this line + // finished. + if ( lineLength < maxLineLength ) { + m_lineEnd = m_parsedTo; + } else { + // Look for a natural linebreak boundary in the column + // (We look from the end, so that the first found boundary is + // the right one) + m_lineEnd = m_parsedTo; + while ( lineLength > 0 && + !isBoundary( current_line, m_lineEnd ) ) { + --lineLength; + --m_lineEnd; + } + while ( lineLength > 0 && + isWhitespace( *m_lineEnd.oneBefore() ) ) { + --lineLength; + --m_lineEnd; + } + + // If we found one, then that is where we linebreak, otherwise + // we have to split text with a hyphen + if ( lineLength == 0 ) { + m_addHyphen = true; + m_lineEnd = m_parsedTo.oneBefore(); + } + } + } + + size_t Column::const_iterator::indentSize() const { + auto initial = m_lineStart == m_column.m_string.begin() + ? m_column.m_initialIndent + : std::string::npos; + return initial == std::string::npos ? m_column.m_indent : initial; + } + + std::string Column::const_iterator::addIndentAndSuffix( + AnsiSkippingString::const_iterator start, + AnsiSkippingString::const_iterator end ) const { + std::string ret; + const auto desired_indent = indentSize(); + // ret.reserve( desired_indent + (end - start) + m_addHyphen ); + ret.append( desired_indent, ' ' ); + // ret.append( start, end ); + ret += m_column.m_string.substring( start, end ); + if ( m_addHyphen ) { ret.push_back( '-' ); } + + return ret; + } + + Column::const_iterator::const_iterator( Column const& column ): + m_column( column ), + m_lineStart( column.m_string.begin() ), + m_lineEnd( column.m_string.begin() ), + m_parsedTo( column.m_string.begin() ) { + assert( m_column.m_width > m_column.m_indent ); + assert( m_column.m_initialIndent == std::string::npos || + m_column.m_width > m_column.m_initialIndent ); + calcLength(); + if ( m_lineStart == m_lineEnd ) { + m_lineStart = m_column.m_string.end(); + } + } + + std::string Column::const_iterator::operator*() const { + assert( m_lineStart <= m_parsedTo ); + return addIndentAndSuffix( m_lineStart, m_lineEnd ); + } + + Column::const_iterator& Column::const_iterator::operator++() { + m_lineStart = m_lineEnd; + AnsiSkippingString const& current_line = m_column.m_string; + if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) { + m_lineStart++; + } else { + while ( m_lineStart != current_line.end() && + isWhitespace( *m_lineStart ) ) { + ++m_lineStart; + } + } + + if ( m_lineStart != current_line.end() ) { calcLength(); } + return *this; + } + + Column::const_iterator Column::const_iterator::operator++( int ) { + const_iterator prev( *this ); + operator++(); + return prev; + } + + std::ostream& operator<<( std::ostream& os, Column const& col ) { + bool first = true; + for ( auto line : col ) { + if ( first ) { + first = false; + } else { + os << '\n'; + } + os << line; + } + return os; + } + + Column Spacer( size_t spaceWidth ) { + Column ret{ "" }; + ret.width( spaceWidth ); + return ret; + } + + Columns::iterator::iterator( Columns const& columns, EndTag ): + m_columns( columns.m_columns ), m_activeIterators( 0 ) { + + m_iterators.reserve( m_columns.size() ); + for ( auto const& col : m_columns ) { + m_iterators.push_back( col.end() ); + } + } + + Columns::iterator::iterator( Columns const& columns ): + m_columns( columns.m_columns ), + m_activeIterators( m_columns.size() ) { + + m_iterators.reserve( m_columns.size() ); + for ( auto const& col : m_columns ) { + m_iterators.push_back( col.begin() ); + } + } + + std::string Columns::iterator::operator*() const { + std::string row, padding; + + for ( size_t i = 0; i < m_columns.size(); ++i ) { + const auto width = m_columns[i].width(); + if ( m_iterators[i] != m_columns[i].end() ) { + std::string col = *m_iterators[i]; + row += padding; + row += col; + + padding.clear(); + if ( col.size() < width ) { + padding.append( width - col.size(), ' ' ); + } + } else { + padding.append( width, ' ' ); + } + } + return row; + } + + Columns::iterator& Columns::iterator::operator++() { + for ( size_t i = 0; i < m_columns.size(); ++i ) { + if ( m_iterators[i] != m_columns[i].end() ) { + ++m_iterators[i]; + } + } + return *this; + } + + Columns::iterator Columns::iterator::operator++( int ) { + iterator prev( *this ); + operator++(); + return prev; + } + + std::ostream& operator<<( std::ostream& os, Columns const& cols ) { + bool first = true; + for ( auto line : cols ) { + if ( first ) { + first = false; + } else { + os << '\n'; + } + os << line; + } + return os; + } + + Columns operator+( Column const& lhs, Column const& rhs ) { + Columns cols; + cols += lhs; + cols += rhs; + return cols; + } + Columns operator+( Column&& lhs, Column&& rhs ) { + Columns cols; + cols += CATCH_MOVE( lhs ); + cols += CATCH_MOVE( rhs ); + return cols; + } + + Columns& operator+=( Columns& lhs, Column const& rhs ) { + lhs.m_columns.push_back( rhs ); + return lhs; + } + Columns& operator+=( Columns& lhs, Column&& rhs ) { + lhs.m_columns.push_back( CATCH_MOVE( rhs ) ); + return lhs; + } + Columns operator+( Columns const& lhs, Column const& rhs ) { + auto combined( lhs ); + combined += rhs; + return combined; + } + Columns operator+( Columns&& lhs, Column&& rhs ) { + lhs += CATCH_MOVE( rhs ); + return CATCH_MOVE( lhs ); + } + + } // namespace TextFlow +} // namespace Catch + + + + +#include + +namespace Catch { + bool uncaught_exceptions() { +#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + return false; +#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) + return std::uncaught_exceptions() > 0; +#else + return std::uncaught_exception(); +#endif + } +} // end namespace Catch + + + +namespace Catch { + + WildcardPattern::WildcardPattern( std::string const& pattern, + CaseSensitive caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_pattern( normaliseString( pattern ) ) + { + if( startsWith( m_pattern, '*' ) ) { + m_pattern = m_pattern.substr( 1 ); + m_wildcard = WildcardAtStart; + } + if( endsWith( m_pattern, '*' ) ) { + m_pattern = m_pattern.substr( 0, m_pattern.size()-1 ); + m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); + } + } + + bool WildcardPattern::matches( std::string const& str ) const { + switch( m_wildcard ) { + case NoWildcard: + return m_pattern == normaliseString( str ); + case WildcardAtStart: + return endsWith( normaliseString( str ), m_pattern ); + case WildcardAtEnd: + return startsWith( normaliseString( str ), m_pattern ); + case WildcardAtBothEnds: + return contains( normaliseString( str ), m_pattern ); + default: + CATCH_INTERNAL_ERROR( "Unknown enum" ); + } + } + + std::string WildcardPattern::normaliseString( std::string const& str ) const { + return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str ); + } +} + + +// Note: swapping these two includes around causes MSVC to error out +// while in /permissive- mode. No, I don't know why. +// Tested on VS 2019, 18.{3, 4}.x + +#include +#include +#include + +namespace Catch { + +namespace { + + size_t trailingBytes(unsigned char c) { + if ((c & 0xE0) == 0xC0) { + return 2; + } + if ((c & 0xF0) == 0xE0) { + return 3; + } + if ((c & 0xF8) == 0xF0) { + return 4; + } + CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); + } + + uint32_t headerValue(unsigned char c) { + if ((c & 0xE0) == 0xC0) { + return c & 0x1F; + } + if ((c & 0xF0) == 0xE0) { + return c & 0x0F; + } + if ((c & 0xF8) == 0xF0) { + return c & 0x07; + } + CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); + } + + void hexEscapeChar(std::ostream& os, unsigned char c) { + std::ios_base::fmtflags f(os.flags()); + os << "\\x" + << std::uppercase << std::hex << std::setfill('0') << std::setw(2) + << static_cast(c); + os.flags(f); + } + + constexpr bool shouldNewline(XmlFormatting fmt) { + return !!(static_cast>(fmt & XmlFormatting::Newline)); + } + + constexpr bool shouldIndent(XmlFormatting fmt) { + return !!(static_cast>(fmt & XmlFormatting::Indent)); + } + +} // anonymous namespace + + void XmlEncode::encodeTo( std::ostream& os ) const { + // Apostrophe escaping not necessary if we always use " to write attributes + // (see: http://www.w3.org/TR/xml/#syntax) + + for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) { + unsigned char c = static_cast(m_str[idx]); + switch (c) { + case '<': os << "<"; break; + case '&': os << "&"; break; + + case '>': + // See: http://www.w3.org/TR/xml/#syntax + if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']') + os << ">"; + else + os << c; + break; + + case '\"': + if (m_forWhat == ForAttributes) + os << """; + else + os << c; + break; + + default: + // Check for control characters and invalid utf-8 + + // Escape control characters in standard ascii + // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0 + if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) { + hexEscapeChar(os, c); + break; + } + + // Plain ASCII: Write it to stream + if (c < 0x7F) { + os << c; + break; + } + + // UTF-8 territory + // Check if the encoding is valid and if it is not, hex escape bytes. + // Important: We do not check the exact decoded values for validity, only the encoding format + // First check that this bytes is a valid lead byte: + // This means that it is not encoded as 1111 1XXX + // Or as 10XX XXXX + if (c < 0xC0 || + c >= 0xF8) { + hexEscapeChar(os, c); + break; + } + + auto encBytes = trailingBytes(c); + // Are there enough bytes left to avoid accessing out-of-bounds memory? + if (idx + encBytes - 1 >= m_str.size()) { + hexEscapeChar(os, c); + break; + } + // The header is valid, check data + // The next encBytes bytes must together be a valid utf-8 + // This means: bitpattern 10XX XXXX and the extracted value is sane (ish) + bool valid = true; + uint32_t value = headerValue(c); + for (std::size_t n = 1; n < encBytes; ++n) { + unsigned char nc = static_cast(m_str[idx + n]); + valid &= ((nc & 0xC0) == 0x80); + value = (value << 6) | (nc & 0x3F); + } + + if ( + // Wrong bit pattern of following bytes + (!valid) || + // Overlong encodings + (value < 0x80) || + (0x80 <= value && value < 0x800 && encBytes > 2) || + (0x800 < value && value < 0x10000 && encBytes > 3) || + // Encoded value out of range + (value >= 0x110000) + ) { + hexEscapeChar(os, c); + break; + } + + // If we got here, this is in fact a valid(ish) utf-8 sequence + for (std::size_t n = 0; n < encBytes; ++n) { + os << m_str[idx + n]; + } + idx += encBytes - 1; + break; + } + } + } + + std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { + xmlEncode.encodeTo( os ); + return os; + } + + XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt ) + : m_writer( writer ), + m_fmt(fmt) + {} + + XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept + : m_writer( other.m_writer ), + m_fmt(other.m_fmt) + { + other.m_writer = nullptr; + other.m_fmt = XmlFormatting::None; + } + XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept { + if ( m_writer ) { + m_writer->endElement(); + } + m_writer = other.m_writer; + other.m_writer = nullptr; + m_fmt = other.m_fmt; + other.m_fmt = XmlFormatting::None; + return *this; + } + + + XmlWriter::ScopedElement::~ScopedElement() { + if (m_writer) { + m_writer->endElement(m_fmt); + } + } + + XmlWriter::ScopedElement& + XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) { + m_writer->writeText( text, fmt ); + return *this; + } + + XmlWriter::ScopedElement& + XmlWriter::ScopedElement::writeAttribute( StringRef name, + StringRef attribute ) { + m_writer->writeAttribute( name, attribute ); + return *this; + } + + + XmlWriter::XmlWriter( std::ostream& os ) : m_os( os ) + { + writeDeclaration(); + } + + XmlWriter::~XmlWriter() { + while (!m_tags.empty()) { + endElement(); + } + newlineIfNecessary(); + } + + XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) { + ensureTagClosed(); + newlineIfNecessary(); + if (shouldIndent(fmt)) { + m_os << m_indent; + m_indent += " "; + } + m_os << '<' << name; + m_tags.push_back( name ); + m_tagIsOpen = true; + applyFormatting(fmt); + return *this; + } + + XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) { + ScopedElement scoped( this, fmt ); + startElement( name, fmt ); + return scoped; + } + + XmlWriter& XmlWriter::endElement(XmlFormatting fmt) { + m_indent = m_indent.substr(0, m_indent.size() - 2); + + if( m_tagIsOpen ) { + m_os << "/>"; + m_tagIsOpen = false; + } else { + newlineIfNecessary(); + if (shouldIndent(fmt)) { + m_os << m_indent; + } + m_os << "'; + } + m_os << std::flush; + applyFormatting(fmt); + m_tags.pop_back(); + return *this; + } + + XmlWriter& XmlWriter::writeAttribute( StringRef name, + StringRef attribute ) { + if( !name.empty() && !attribute.empty() ) + m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; + return *this; + } + + XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) { + writeAttribute(name, (attribute ? "true"_sr : "false"_sr)); + return *this; + } + + XmlWriter& XmlWriter::writeAttribute( StringRef name, + char const* attribute ) { + writeAttribute( name, StringRef( attribute ) ); + return *this; + } + + XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) { + CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element"); + if( !text.empty() ){ + bool tagWasOpen = m_tagIsOpen; + ensureTagClosed(); + if (tagWasOpen && shouldIndent(fmt)) { + m_os << m_indent; + } + m_os << XmlEncode( text, XmlEncode::ForTextNodes ); + applyFormatting(fmt); + } + return *this; + } + + XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) { + ensureTagClosed(); + if (shouldIndent(fmt)) { + m_os << m_indent; + } + m_os << ""; + applyFormatting(fmt); + return *this; + } + + void XmlWriter::writeStylesheetRef( StringRef url ) { + m_os << R"()" << '\n'; + } + + void XmlWriter::ensureTagClosed() { + if( m_tagIsOpen ) { + m_os << '>' << std::flush; + newlineIfNecessary(); + m_tagIsOpen = false; + } + } + + void XmlWriter::applyFormatting(XmlFormatting fmt) { + m_needsNewline = shouldNewline(fmt); + } + + void XmlWriter::writeDeclaration() { + m_os << R"()" << '\n'; + } + + void XmlWriter::newlineIfNecessary() { + if( m_needsNewline ) { + m_os << '\n' << std::flush; + m_needsNewline = false; + } + } +} + + + + + +namespace Catch { +namespace Matchers { + + std::string MatcherUntypedBase::toString() const { + if (m_cachedToString.empty()) { + m_cachedToString = describe(); + } + return m_cachedToString; + } + + MatcherUntypedBase::~MatcherUntypedBase() = default; + +} // namespace Matchers +} // namespace Catch + + + + +namespace Catch { +namespace Matchers { + + std::string IsEmptyMatcher::describe() const { + return "is empty"; + } + + std::string HasSizeMatcher::describe() const { + ReusableStringStream sstr; + sstr << "has size == " << m_target_size; + return sstr.str(); + } + + IsEmptyMatcher IsEmpty() { + return {}; + } + + HasSizeMatcher SizeIs(std::size_t sz) { + return HasSizeMatcher{ sz }; + } + +} // end namespace Matchers +} // end namespace Catch + + + +namespace Catch { +namespace Matchers { + +bool ExceptionMessageMatcher::match(std::exception const& ex) const { + return ex.what() == m_message; +} + +std::string ExceptionMessageMatcher::describe() const { + return "exception message matches \"" + m_message + '"'; +} + +ExceptionMessageMatcher Message(std::string const& message) { + return ExceptionMessageMatcher(message); +} + +} // namespace Matchers +} // namespace Catch + + + +#include +#include +#include +#include +#include +#include +#include + + +namespace Catch { +namespace { + + template + bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) { + // Comparison with NaN should always be false. + // This way we can rule it out before getting into the ugly details + if (Catch::isnan(lhs) || Catch::isnan(rhs)) { + return false; + } + + // This should also handle positive and negative zeros, infinities + const auto ulpDist = ulpDistance(lhs, rhs); + + return ulpDist <= maxUlpDiff; + } + + +template +FP step(FP start, FP direction, uint64_t steps) { + for (uint64_t i = 0; i < steps; ++i) { + start = Catch::nextafter(start, direction); + } + return start; +} + +// Performs equivalent check of std::fabs(lhs - rhs) <= margin +// But without the subtraction to allow for INFINITY in comparison +bool marginComparison(double lhs, double rhs, double margin) { + return (lhs + margin >= rhs) && (rhs + margin >= lhs); +} + +template +void write(std::ostream& out, FloatingPoint num) { + out << std::scientific + << std::setprecision(std::numeric_limits::max_digits10 - 1) + << num; +} + +} // end anonymous namespace + +namespace Matchers { +namespace Detail { + + enum class FloatingPointKind : uint8_t { + Float, + Double + }; + +} // end namespace Detail + + + WithinAbsMatcher::WithinAbsMatcher(double target, double margin) + :m_target{ target }, m_margin{ margin } { + CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.' + << " Margin has to be non-negative."); + } + + // Performs equivalent check of std::fabs(lhs - rhs) <= margin + // But without the subtraction to allow for INFINITY in comparison + bool WithinAbsMatcher::match(double const& matchee) const { + return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee); + } + + std::string WithinAbsMatcher::describe() const { + return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target); + } + + + WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType) + :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } { + CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double + || m_ulps < (std::numeric_limits::max)(), + "Provided ULP is impossibly large for a float comparison."); + CATCH_ENFORCE( std::numeric_limits::is_iec559, + "WithinUlp matcher only supports platforms with " + "IEEE-754 compatible floating point representation" ); + } + +#if defined(__clang__) +#pragma clang diagnostic push +// Clang <3.5 reports on the default branch in the switch below +#pragma clang diagnostic ignored "-Wunreachable-code" +#endif + + bool WithinUlpsMatcher::match(double const& matchee) const { + switch (m_type) { + case Detail::FloatingPointKind::Float: + return almostEqualUlps(static_cast(matchee), static_cast(m_target), m_ulps); + case Detail::FloatingPointKind::Double: + return almostEqualUlps(matchee, m_target, m_ulps); + default: + CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" ); + } + } + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + + std::string WithinUlpsMatcher::describe() const { + std::stringstream ret; + + ret << "is within " << m_ulps << " ULPs of "; + + if (m_type == Detail::FloatingPointKind::Float) { + write(ret, static_cast(m_target)); + ret << 'f'; + } else { + write(ret, m_target); + } + + ret << " (["; + if (m_type == Detail::FloatingPointKind::Double) { + write( ret, + step( m_target, + -std::numeric_limits::infinity(), + m_ulps ) ); + ret << ", "; + write( ret, + step( m_target, + std::numeric_limits::infinity(), + m_ulps ) ); + } else { + // We have to cast INFINITY to float because of MinGW, see #1782 + write( ret, + step( static_cast( m_target ), + -std::numeric_limits::infinity(), + m_ulps ) ); + ret << ", "; + write( ret, + step( static_cast( m_target ), + std::numeric_limits::infinity(), + m_ulps ) ); + } + ret << "])"; + + return ret.str(); + } + + WithinRelMatcher::WithinRelMatcher(double target, double epsilon): + m_target(target), + m_epsilon(epsilon){ + CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense."); + CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense."); + } + + bool WithinRelMatcher::match(double const& matchee) const { + const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target)); + return marginComparison(matchee, m_target, + std::isinf(relMargin)? 0 : relMargin); + } + + std::string WithinRelMatcher::describe() const { + Catch::ReusableStringStream sstr; + sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other"; + return sstr.str(); + } + + +WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) { + return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double); +} + +WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) { + return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float); +} + +WithinAbsMatcher WithinAbs(double target, double margin) { + return WithinAbsMatcher(target, margin); +} + +WithinRelMatcher WithinRel(double target, double eps) { + return WithinRelMatcher(target, eps); +} + +WithinRelMatcher WithinRel(double target) { + return WithinRelMatcher(target, std::numeric_limits::epsilon() * 100); +} + +WithinRelMatcher WithinRel(float target, float eps) { + return WithinRelMatcher(target, eps); +} + +WithinRelMatcher WithinRel(float target) { + return WithinRelMatcher(target, std::numeric_limits::epsilon() * 100); +} + + + +bool IsNaNMatcher::match( double const& matchee ) const { + return std::isnan( matchee ); +} + +std::string IsNaNMatcher::describe() const { + using namespace std::string_literals; + return "is NaN"s; +} + +IsNaNMatcher IsNaN() { return IsNaNMatcher(); } + + } // namespace Matchers +} // namespace Catch + + + + +std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) { + if (desc.empty()) { + return "matches undescribed predicate"; + } else { + return "matches predicate: \"" + desc + '"'; + } +} + + + +namespace Catch { + namespace Matchers { + std::string AllTrueMatcher::describe() const { return "contains only true"; } + + AllTrueMatcher AllTrue() { return AllTrueMatcher{}; } + + std::string NoneTrueMatcher::describe() const { return "contains no true"; } + + NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; } + + std::string AnyTrueMatcher::describe() const { return "contains at least one true"; } + + AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; } + } // namespace Matchers +} // namespace Catch + + + +#include + +namespace Catch { +namespace Matchers { + + CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_str( adjustString( str ) ) + {} + std::string CasedString::adjustString( std::string const& str ) const { + return m_caseSensitivity == CaseSensitive::No + ? toLower( str ) + : str; + } + StringRef CasedString::caseSensitivitySuffix() const { + return m_caseSensitivity == CaseSensitive::Yes + ? StringRef() + : " (case insensitive)"_sr; + } + + + StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator ) + : m_comparator( comparator ), + m_operation( operation ) { + } + + std::string StringMatcherBase::describe() const { + std::string description; + description.reserve(5 + m_operation.size() + m_comparator.m_str.size() + + m_comparator.caseSensitivitySuffix().size()); + description += m_operation; + description += ": \""; + description += m_comparator.m_str; + description += '"'; + description += m_comparator.caseSensitivitySuffix(); + return description; + } + + StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {} + + bool StringEqualsMatcher::match( std::string const& source ) const { + return m_comparator.adjustString( source ) == m_comparator.m_str; + } + + + StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {} + + bool StringContainsMatcher::match( std::string const& source ) const { + return contains( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + + StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {} + + bool StartsWithMatcher::match( std::string const& source ) const { + return startsWith( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + + EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {} + + bool EndsWithMatcher::match( std::string const& source ) const { + return endsWith( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + + + RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {} + + bool RegexMatcher::match(std::string const& matchee) const { + auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway + if (m_caseSensitivity == CaseSensitive::No) { + flags |= std::regex::icase; + } + auto reg = std::regex(m_regex, flags); + return std::regex_match(matchee, reg); + } + + std::string RegexMatcher::describe() const { + return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively"); + } + + + StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) { + return StringEqualsMatcher( CasedString( str, caseSensitivity) ); + } + StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) { + return StringContainsMatcher( CasedString( str, caseSensitivity) ); + } + EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) { + return EndsWithMatcher( CasedString( str, caseSensitivity) ); + } + StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) { + return StartsWithMatcher( CasedString( str, caseSensitivity) ); + } + + RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) { + return RegexMatcher(regex, caseSensitivity); + } + +} // namespace Matchers +} // namespace Catch + + + +namespace Catch { +namespace Matchers { + MatcherGenericBase::~MatcherGenericBase() = default; + + namespace Detail { + + std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) { + std::string description; + std::size_t combined_size = 4; + for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) { + combined_size += desc->size(); + } + combined_size += static_cast(descriptions_end - descriptions_begin - 1) * combine.size(); + + description.reserve(combined_size); + + description += "( "; + bool first = true; + for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) { + if( first ) + first = false; + else + description += combine; + description += *desc; + } + description += " )"; + return description; + } + + } // namespace Detail +} // namespace Matchers +} // namespace Catch + + + + +namespace Catch { + + // This is the general overload that takes a any string matcher + // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers + // the Equals matcher (so the header does not mention matchers) + void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) { + std::string exceptionMessage = Catch::translateActiveException(); + MatchExpr expr( CATCH_MOVE(exceptionMessage), matcher ); + handler.handleExpr( expr ); + } + +} // namespace Catch + + + +#include + +namespace Catch { + + AutomakeReporter::~AutomakeReporter() = default; + + void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) { + // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR. + m_stream << ":test-result: "; + if ( _testCaseStats.totals.testCases.skipped > 0 ) { + m_stream << "SKIP"; + } else if (_testCaseStats.totals.assertions.allPassed()) { + m_stream << "PASS"; + } else if (_testCaseStats.totals.assertions.allOk()) { + m_stream << "XFAIL"; + } else { + m_stream << "FAIL"; + } + m_stream << ' ' << _testCaseStats.testInfo->name << '\n'; + StreamingReporterBase::testCaseEnded(_testCaseStats); + } + + void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) { + m_stream << ":test-result: SKIP " << testInfo.name << '\n'; + } + +} // end namespace Catch + + + + + + +namespace Catch { + ReporterBase::ReporterBase( ReporterConfig&& config ): + IEventListener( config.fullConfig() ), + m_wrapped_stream( CATCH_MOVE(config).takeStream() ), + m_stream( m_wrapped_stream->stream() ), + m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ), + m_customOptions( config.customOptions() ) + {} + + ReporterBase::~ReporterBase() = default; + + void ReporterBase::listReporters( + std::vector const& descriptions ) { + defaultListReporters(m_stream, descriptions, m_config->verbosity()); + } + + void ReporterBase::listListeners( + std::vector const& descriptions ) { + defaultListListeners( m_stream, descriptions ); + } + + void ReporterBase::listTests(std::vector const& tests) { + defaultListTests(m_stream, + m_colour.get(), + tests, + m_config->hasTestFilters(), + m_config->verbosity()); + } + + void ReporterBase::listTags(std::vector const& tags) { + defaultListTags( m_stream, tags, m_config->hasTestFilters() ); + } + +} // namespace Catch + + + + +#include + +namespace Catch { +namespace { + + // Colour::LightGrey + static constexpr Colour::Code compactDimColour = Colour::FileName; + +#ifdef CATCH_PLATFORM_MAC + static constexpr Catch::StringRef compactFailedString = "FAILED"_sr; + static constexpr Catch::StringRef compactPassedString = "PASSED"_sr; +#else + static constexpr Catch::StringRef compactFailedString = "failed"_sr; + static constexpr Catch::StringRef compactPassedString = "passed"_sr; +#endif + +// Implementation of CompactReporter formatting +class AssertionPrinter { +public: + AssertionPrinter& operator= (AssertionPrinter const&) = delete; + AssertionPrinter(AssertionPrinter const&) = delete; + AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_) + : stream(_stream) + , result(_stats.assertionResult) + , messages(_stats.infoMessages) + , itMessage(_stats.infoMessages.begin()) + , printInfoMessages(_printInfoMessages) + , colourImpl(colourImpl_) + {} + + void print() { + printSourceInfo(); + + itMessage = messages.begin(); + + switch (result.getResultType()) { + case ResultWas::Ok: + printResultType(Colour::ResultSuccess, compactPassedString); + printOriginalExpression(); + printReconstructedExpression(); + if (!result.hasExpression()) + printRemainingMessages(Colour::None); + else + printRemainingMessages(); + break; + case ResultWas::ExpressionFailed: + if (result.isOk()) + printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr); + else + printResultType(Colour::Error, compactFailedString); + printOriginalExpression(); + printReconstructedExpression(); + printRemainingMessages(); + break; + case ResultWas::ThrewException: + printResultType(Colour::Error, compactFailedString); + printIssue("unexpected exception with message:"); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::FatalErrorCondition: + printResultType(Colour::Error, compactFailedString); + printIssue("fatal error condition with message:"); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::DidntThrowException: + printResultType(Colour::Error, compactFailedString); + printIssue("expected exception, got none"); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::Info: + printResultType(Colour::None, "info"_sr); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::Warning: + printResultType(Colour::None, "warning"_sr); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::ExplicitFailure: + printResultType(Colour::Error, compactFailedString); + printIssue("explicitly"); + printRemainingMessages(Colour::None); + break; + case ResultWas::ExplicitSkip: + printResultType(Colour::Skip, "skipped"_sr); + printMessage(); + printRemainingMessages(); + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + printResultType(Colour::Error, "** internal error **"); + break; + } + } + +private: + void printSourceInfo() const { + stream << colourImpl->guardColour( Colour::FileName ) + << result.getSourceInfo() << ':'; + } + + void printResultType(Colour::Code colour, StringRef passOrFail) const { + if (!passOrFail.empty()) { + stream << colourImpl->guardColour(colour) << ' ' << passOrFail; + stream << ':'; + } + } + + void printIssue(char const* issue) const { + stream << ' ' << issue; + } + + void printExpressionWas() { + if (result.hasExpression()) { + stream << ';'; + { + stream << colourImpl->guardColour(compactDimColour) << " expression was:"; + } + printOriginalExpression(); + } + } + + void printOriginalExpression() const { + if (result.hasExpression()) { + stream << ' ' << result.getExpression(); + } + } + + void printReconstructedExpression() const { + if (result.hasExpandedExpression()) { + stream << colourImpl->guardColour(compactDimColour) << " for: "; + stream << result.getExpandedExpression(); + } + } + + void printMessage() { + if (itMessage != messages.end()) { + stream << " '" << itMessage->message << '\''; + ++itMessage; + } + } + + void printRemainingMessages(Colour::Code colour = compactDimColour) { + if (itMessage == messages.end()) + return; + + const auto itEnd = messages.cend(); + const auto N = static_cast(itEnd - itMessage); + + stream << colourImpl->guardColour( colour ) << " with " + << pluralise( N, "message"_sr ) << ':'; + + while (itMessage != itEnd) { + // If this assertion is a warning ignore any INFO messages + if (printInfoMessages || itMessage->type != ResultWas::Info) { + printMessage(); + if (itMessage != itEnd) { + stream << colourImpl->guardColour(compactDimColour) << " and"; + } + continue; + } + ++itMessage; + } + } + +private: + std::ostream& stream; + AssertionResult const& result; + std::vector const& messages; + std::vector::const_iterator itMessage; + bool printInfoMessages; + ColourImpl* colourImpl; +}; + +} // anon namespace + + std::string CompactReporter::getDescription() { + return "Reports test results on a single line, suitable for IDEs"; + } + + void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) { + m_stream << "No test cases matched '" << unmatchedSpec << "'\n"; + } + + void CompactReporter::testRunStarting( TestRunInfo const& ) { + if ( m_config->testSpec().hasFilters() ) { + m_stream << m_colour->guardColour( Colour::BrightYellow ) + << "Filters: " + << m_config->testSpec() + << '\n'; + } + m_stream << "RNG seed: " << getSeed() << '\n'; + } + + void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) { + AssertionResult const& result = _assertionStats.assertionResult; + + bool printInfoMessages = true; + + // Drop out if result was successful and we're not printing those + if( !m_config->includeSuccessfulResults() && result.isOk() ) { + if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip ) + return; + printInfoMessages = false; + } + + AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() ); + printer.print(); + + m_stream << '\n' << std::flush; + } + + void CompactReporter::sectionEnded(SectionStats const& _sectionStats) { + double dur = _sectionStats.durationInSeconds; + if ( shouldShowDuration( *m_config, dur ) ) { + m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush; + } + } + + void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) { + printTestRunTotals( m_stream, *m_colour, _testRunStats.totals ); + m_stream << "\n\n" << std::flush; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + CompactReporter::~CompactReporter() = default; + +} // end namespace Catch + + + + +#include + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch + // Note that 4062 (not all labels are handled and default is missing) is enabled +#endif + +#if defined(__clang__) +# pragma clang diagnostic push +// For simplicity, benchmarking-only helpers are always enabled +# pragma clang diagnostic ignored "-Wunused-function" +#endif + + + +namespace Catch { + +namespace { + +// Formatter impl for ConsoleReporter +class ConsoleAssertionPrinter { +public: + ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete; + ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete; + ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages) + : stream(_stream), + stats(_stats), + result(_stats.assertionResult), + colour(Colour::None), + messages(_stats.infoMessages), + colourImpl(colourImpl_), + printInfoMessages(_printInfoMessages) { + switch (result.getResultType()) { + case ResultWas::Ok: + colour = Colour::Success; + passOrFail = "PASSED"_sr; + //if( result.hasMessage() ) + if (messages.size() == 1) + messageLabel = "with message"_sr; + if (messages.size() > 1) + messageLabel = "with messages"_sr; + break; + case ResultWas::ExpressionFailed: + if (result.isOk()) { + colour = Colour::Success; + passOrFail = "FAILED - but was ok"_sr; + } else { + colour = Colour::Error; + passOrFail = "FAILED"_sr; + } + if (messages.size() == 1) + messageLabel = "with message"_sr; + if (messages.size() > 1) + messageLabel = "with messages"_sr; + break; + case ResultWas::ThrewException: + colour = Colour::Error; + passOrFail = "FAILED"_sr; + // todo switch + switch (messages.size()) { case 0: + messageLabel = "due to unexpected exception with "_sr; + break; + case 1: + messageLabel = "due to unexpected exception with message"_sr; + break; + default: + messageLabel = "due to unexpected exception with messages"_sr; + break; + } + break; + case ResultWas::FatalErrorCondition: + colour = Colour::Error; + passOrFail = "FAILED"_sr; + messageLabel = "due to a fatal error condition"_sr; + break; + case ResultWas::DidntThrowException: + colour = Colour::Error; + passOrFail = "FAILED"_sr; + messageLabel = "because no exception was thrown where one was expected"_sr; + break; + case ResultWas::Info: + messageLabel = "info"_sr; + break; + case ResultWas::Warning: + messageLabel = "warning"_sr; + break; + case ResultWas::ExplicitFailure: + passOrFail = "FAILED"_sr; + colour = Colour::Error; + if (messages.size() == 1) + messageLabel = "explicitly with message"_sr; + if (messages.size() > 1) + messageLabel = "explicitly with messages"_sr; + break; + case ResultWas::ExplicitSkip: + colour = Colour::Skip; + passOrFail = "SKIPPED"_sr; + if (messages.size() == 1) + messageLabel = "explicitly with message"_sr; + if (messages.size() > 1) + messageLabel = "explicitly with messages"_sr; + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + passOrFail = "** internal error **"_sr; + colour = Colour::Error; + break; + } + } + + void print() const { + printSourceInfo(); + if (stats.totals.assertions.total() > 0) { + printResultType(); + printOriginalExpression(); + printReconstructedExpression(); + } else { + stream << '\n'; + } + printMessage(); + } + +private: + void printResultType() const { + if (!passOrFail.empty()) { + stream << colourImpl->guardColour(colour) << passOrFail << ":\n"; + } + } + void printOriginalExpression() const { + if (result.hasExpression()) { + stream << colourImpl->guardColour( Colour::OriginalExpression ) + << " " << result.getExpressionInMacro() << '\n'; + } + } + void printReconstructedExpression() const { + if (result.hasExpandedExpression()) { + stream << "with expansion:\n"; + stream << colourImpl->guardColour( Colour::ReconstructedExpression ) + << TextFlow::Column( result.getExpandedExpression() ) + .indent( 2 ) + << '\n'; + } + } + void printMessage() const { + if (!messageLabel.empty()) + stream << messageLabel << ':' << '\n'; + for (auto const& msg : messages) { + // If this assertion is a warning ignore any INFO messages + if (printInfoMessages || msg.type != ResultWas::Info) + stream << TextFlow::Column(msg.message).indent(2) << '\n'; + } + } + void printSourceInfo() const { + stream << colourImpl->guardColour( Colour::FileName ) + << result.getSourceInfo() << ": "; + } + + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + Colour::Code colour; + StringRef passOrFail; + StringRef messageLabel; + std::vector const& messages; + ColourImpl* colourImpl; + bool printInfoMessages; +}; + +std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) { + const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0; + return (ratio == 0 && number > 0) ? 1 : static_cast(ratio); +} + +std::size_t& +findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) { + if (i > j && i > k && i > l) + return i; + else if (j > k && j > l) + return j; + else if (k > l) + return k; + else + return l; +} + +struct ColumnBreak {}; +struct RowBreak {}; +struct OutputFlush {}; + +class Duration { + enum class Unit { + Auto, + Nanoseconds, + Microseconds, + Milliseconds, + Seconds, + Minutes + }; + static const uint64_t s_nanosecondsInAMicrosecond = 1000; + static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond; + static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond; + static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond; + + double m_inNanoseconds; + Unit m_units; + +public: + explicit Duration(double inNanoseconds, Unit units = Unit::Auto) + : m_inNanoseconds(inNanoseconds), + m_units(units) { + if (m_units == Unit::Auto) { + if (m_inNanoseconds < s_nanosecondsInAMicrosecond) + m_units = Unit::Nanoseconds; + else if (m_inNanoseconds < s_nanosecondsInAMillisecond) + m_units = Unit::Microseconds; + else if (m_inNanoseconds < s_nanosecondsInASecond) + m_units = Unit::Milliseconds; + else if (m_inNanoseconds < s_nanosecondsInAMinute) + m_units = Unit::Seconds; + else + m_units = Unit::Minutes; + } + + } + + auto value() const -> double { + switch (m_units) { + case Unit::Microseconds: + return m_inNanoseconds / static_cast(s_nanosecondsInAMicrosecond); + case Unit::Milliseconds: + return m_inNanoseconds / static_cast(s_nanosecondsInAMillisecond); + case Unit::Seconds: + return m_inNanoseconds / static_cast(s_nanosecondsInASecond); + case Unit::Minutes: + return m_inNanoseconds / static_cast(s_nanosecondsInAMinute); + default: + return m_inNanoseconds; + } + } + StringRef unitsAsString() const { + switch (m_units) { + case Unit::Nanoseconds: + return "ns"_sr; + case Unit::Microseconds: + return "us"_sr; + case Unit::Milliseconds: + return "ms"_sr; + case Unit::Seconds: + return "s"_sr; + case Unit::Minutes: + return "m"_sr; + default: + return "** internal error **"_sr; + } + + } + friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& { + return os << duration.value() << ' ' << duration.unitsAsString(); + } +}; +} // end anon namespace + +enum class Justification { Left, Right }; + +struct ColumnInfo { + std::string name; + std::size_t width; + Justification justification; +}; + +class TablePrinter { + std::ostream& m_os; + std::vector m_columnInfos; + ReusableStringStream m_oss; + int m_currentColumn = -1; + bool m_isOpen = false; + +public: + TablePrinter( std::ostream& os, std::vector columnInfos ) + : m_os( os ), + m_columnInfos( CATCH_MOVE( columnInfos ) ) {} + + auto columnInfos() const -> std::vector const& { + return m_columnInfos; + } + + void open() { + if (!m_isOpen) { + m_isOpen = true; + *this << RowBreak(); + + TextFlow::Columns headerCols; + for (auto const& info : m_columnInfos) { + assert(info.width > 2); + headerCols += TextFlow::Column(info.name).width(info.width - 2); + headerCols += TextFlow::Spacer( 2 ); + } + m_os << headerCols << '\n'; + + m_os << lineOfChars('-') << '\n'; + } + } + void close() { + if (m_isOpen) { + *this << RowBreak(); + m_os << '\n' << std::flush; + m_isOpen = false; + } + } + + template + friend TablePrinter& operator<< (TablePrinter& tp, T const& value) { + tp.m_oss << value; + return tp; + } + + friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) { + auto colStr = tp.m_oss.str(); + const auto strSize = colStr.size(); + tp.m_oss.str(""); + tp.open(); + if (tp.m_currentColumn == static_cast(tp.m_columnInfos.size() - 1)) { + tp.m_currentColumn = -1; + tp.m_os << '\n'; + } + tp.m_currentColumn++; + + auto colInfo = tp.m_columnInfos[tp.m_currentColumn]; + auto padding = (strSize + 1 < colInfo.width) + ? std::string(colInfo.width - (strSize + 1), ' ') + : std::string(); + if (colInfo.justification == Justification::Left) + tp.m_os << colStr << padding << ' '; + else + tp.m_os << padding << colStr << ' '; + return tp; + } + + friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) { + if (tp.m_currentColumn > 0) { + tp.m_os << '\n'; + tp.m_currentColumn = -1; + } + return tp; + } + + friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) { + tp.m_os << std::flush; + return tp; + } +}; + +ConsoleReporter::ConsoleReporter(ReporterConfig&& config): + StreamingReporterBase( CATCH_MOVE( config ) ), + m_tablePrinter(Detail::make_unique(m_stream, + [&config]() -> std::vector { + if (config.fullConfig()->benchmarkNoAnalysis()) + { + return{ + { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left }, + { " samples", 14, Justification::Right }, + { " iterations", 14, Justification::Right }, + { " mean", 14, Justification::Right } + }; + } + else + { + return{ + { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left }, + { "samples mean std dev", 14, Justification::Right }, + { "iterations low mean low std dev", 14, Justification::Right }, + { "est run time high mean high std dev", 14, Justification::Right } + }; + } + }())) {} +ConsoleReporter::~ConsoleReporter() = default; + +std::string ConsoleReporter::getDescription() { + return "Reports test results as plain lines of text"; +} + +void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) { + m_stream << "No test cases matched '" << unmatchedSpec << "'\n"; +} + +void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) { + m_stream << "Invalid Filter: " << arg << '\n'; +} + +void ConsoleReporter::assertionStarting(AssertionInfo const&) {} + +void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) { + AssertionResult const& result = _assertionStats.assertionResult; + + bool includeResults = m_config->includeSuccessfulResults() || !result.isOk(); + + // Drop out if result was successful but we're not printing them. + // TODO: Make configurable whether skips should be printed + if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip) + return; + + lazyPrint(); + + ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults); + printer.print(); + m_stream << '\n' << std::flush; +} + +void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) { + m_tablePrinter->close(); + m_headerPrinted = false; + StreamingReporterBase::sectionStarting(_sectionInfo); +} +void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) { + m_tablePrinter->close(); + if (_sectionStats.missingAssertions) { + lazyPrint(); + auto guard = + m_colour->guardColour( Colour::ResultError ).engage( m_stream ); + if (m_sectionStack.size() > 1) + m_stream << "\nNo assertions in section"; + else + m_stream << "\nNo assertions in test case"; + m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush; + } + double dur = _sectionStats.durationInSeconds; + if (shouldShowDuration(*m_config, dur)) { + m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush; + } + if (m_headerPrinted) { + m_headerPrinted = false; + } + StreamingReporterBase::sectionEnded(_sectionStats); +} + +void ConsoleReporter::benchmarkPreparing( StringRef name ) { + lazyPrintWithoutClosingBenchmarkTable(); + + auto nameCol = TextFlow::Column( static_cast( name ) ) + .width( m_tablePrinter->columnInfos()[0].width - 2 ); + + bool firstLine = true; + for (auto line : nameCol) { + if (!firstLine) + (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak(); + else + firstLine = false; + + (*m_tablePrinter) << line << ColumnBreak(); + } +} + +void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) { + (*m_tablePrinter) << info.samples << ColumnBreak() + << info.iterations << ColumnBreak(); + if ( !m_config->benchmarkNoAnalysis() ) { + ( *m_tablePrinter ) + << Duration( info.estimatedDuration ) << ColumnBreak(); + } + ( *m_tablePrinter ) << OutputFlush{}; +} +void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) { + if (m_config->benchmarkNoAnalysis()) + { + (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak(); + } + else + { + (*m_tablePrinter) << ColumnBreak() + << Duration(stats.mean.point.count()) << ColumnBreak() + << Duration(stats.mean.lower_bound.count()) << ColumnBreak() + << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak() + << Duration(stats.standardDeviation.point.count()) << ColumnBreak() + << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak() + << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak(); + } +} + +void ConsoleReporter::benchmarkFailed( StringRef error ) { + auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream ); + (*m_tablePrinter) + << "Benchmark failed (" << error << ')' + << ColumnBreak() << RowBreak(); +} + +void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) { + m_tablePrinter->close(); + StreamingReporterBase::testCaseEnded(_testCaseStats); + m_headerPrinted = false; +} +void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) { + printTotalsDivider(_testRunStats.totals); + printTestRunTotals( m_stream, *m_colour, _testRunStats.totals ); + m_stream << '\n' << std::flush; + StreamingReporterBase::testRunEnded(_testRunStats); +} +void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) { + StreamingReporterBase::testRunStarting(_testRunInfo); + if ( m_config->testSpec().hasFilters() ) { + m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: " + << m_config->testSpec() << '\n'; + } + m_stream << "Randomness seeded to: " << getSeed() << '\n'; +} + +void ConsoleReporter::lazyPrint() { + + m_tablePrinter->close(); + lazyPrintWithoutClosingBenchmarkTable(); +} + +void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() { + + if ( !m_testRunInfoPrinted ) { + lazyPrintRunInfo(); + } + if (!m_headerPrinted) { + printTestCaseAndSectionHeader(); + m_headerPrinted = true; + } +} +void ConsoleReporter::lazyPrintRunInfo() { + m_stream << '\n' + << lineOfChars( '~' ) << '\n' + << m_colour->guardColour( Colour::SecondaryText ) + << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion() + << " host application.\n" + << "Run with -? for options\n\n"; + + m_testRunInfoPrinted = true; +} +void ConsoleReporter::printTestCaseAndSectionHeader() { + assert(!m_sectionStack.empty()); + printOpenHeader(currentTestCaseInfo->name); + + if (m_sectionStack.size() > 1) { + auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream ); + + auto + it = m_sectionStack.begin() + 1, // Skip first section (test case) + itEnd = m_sectionStack.end(); + for (; it != itEnd; ++it) + printHeaderString(it->name, 2); + } + + SourceLineInfo lineInfo = m_sectionStack.back().lineInfo; + + + m_stream << lineOfChars( '-' ) << '\n' + << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n' + << lineOfChars( '.' ) << "\n\n" + << std::flush; +} + +void ConsoleReporter::printClosedHeader(std::string const& _name) { + printOpenHeader(_name); + m_stream << lineOfChars('.') << '\n'; +} +void ConsoleReporter::printOpenHeader(std::string const& _name) { + m_stream << lineOfChars('-') << '\n'; + { + auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream ); + printHeaderString(_name); + } +} + +void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) { + // We want to get a bit fancy with line breaking here, so that subsequent + // lines start after ":" if one is present, e.g. + // ``` + // blablabla: Fancy + // linebreaking + // ``` + // but we also want to avoid problems with overly long indentation causing + // the text to take up too many lines, e.g. + // ``` + // blablabla: F + // a + // n + // c + // y + // . + // . + // . + // ``` + // So we limit the prefix indentation check to first quarter of the possible + // width + std::size_t idx = _string.find( ": " ); + if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) { + idx += 2; + } else { + idx = 0; + } + m_stream << TextFlow::Column( _string ) + .indent( indent + idx ) + .initialIndent( indent ) + << '\n'; +} + +void ConsoleReporter::printTotalsDivider(Totals const& totals) { + if (totals.testCases.total() > 0) { + std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total()); + std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total()); + std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total()); + std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total()); + while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1) + findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++; + while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1) + findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--; + + m_stream << m_colour->guardColour( Colour::Error ) + << std::string( failedRatio, '=' ) + << m_colour->guardColour( Colour::ResultExpectedFailure ) + << std::string( failedButOkRatio, '=' ); + if ( totals.testCases.allPassed() ) { + m_stream << m_colour->guardColour( Colour::ResultSuccess ) + << std::string( passedRatio, '=' ); + } else { + m_stream << m_colour->guardColour( Colour::Success ) + << std::string( passedRatio, '=' ); + } + m_stream << m_colour->guardColour( Colour::Skip ) + << std::string( skippedRatio, '=' ); + } else { + m_stream << m_colour->guardColour( Colour::Warning ) + << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' ); + } + m_stream << '\n'; +} + +} // end namespace Catch + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + + + + +#include +#include + +namespace Catch { + namespace { + struct BySectionInfo { + BySectionInfo( SectionInfo const& other ): m_other( other ) {} + BySectionInfo( BySectionInfo const& other ) = default; + bool operator()( + Detail::unique_ptr const& + node ) const { + return ( + ( node->stats.sectionInfo.name == m_other.name ) && + ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) ); + } + void operator=( BySectionInfo const& ) = delete; + + private: + SectionInfo const& m_other; + }; + + } // namespace + + namespace Detail { + AssertionOrBenchmarkResult::AssertionOrBenchmarkResult( + AssertionStats const& assertion ): + m_assertion( assertion ) {} + + AssertionOrBenchmarkResult::AssertionOrBenchmarkResult( + BenchmarkStats<> const& benchmark ): + m_benchmark( benchmark ) {} + + bool AssertionOrBenchmarkResult::isAssertion() const { + return m_assertion.some(); + } + bool AssertionOrBenchmarkResult::isBenchmark() const { + return m_benchmark.some(); + } + + AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const { + assert(m_assertion.some()); + + return *m_assertion; + } + BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const { + assert(m_benchmark.some()); + + return *m_benchmark; + } + + } + + CumulativeReporterBase::~CumulativeReporterBase() = default; + + void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) { + m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats); + } + + void + CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) { + // We need a copy, because SectionStats expect to take ownership + SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false ); + SectionNode* node; + if ( m_sectionStack.empty() ) { + if ( !m_rootSection ) { + m_rootSection = + Detail::make_unique( incompleteStats ); + } + node = m_rootSection.get(); + } else { + SectionNode& parentNode = *m_sectionStack.back(); + auto it = std::find_if( parentNode.childSections.begin(), + parentNode.childSections.end(), + BySectionInfo( sectionInfo ) ); + if ( it == parentNode.childSections.end() ) { + auto newNode = + Detail::make_unique( incompleteStats ); + node = newNode.get(); + parentNode.childSections.push_back( CATCH_MOVE( newNode ) ); + } else { + node = it->get(); + } + } + + m_deepestSection = node; + m_sectionStack.push_back( node ); + } + + void CumulativeReporterBase::assertionEnded( + AssertionStats const& assertionStats ) { + assert( !m_sectionStack.empty() ); + // AssertionResult holds a pointer to a temporary DecomposedExpression, + // which getExpandedExpression() calls to build the expression string. + // Our section stack copy of the assertionResult will likely outlive the + // temporary, so it must be expanded or discarded now to avoid calling + // a destroyed object later. + if ( m_shouldStoreFailedAssertions && + !assertionStats.assertionResult.isOk() ) { + static_cast( + assertionStats.assertionResult.getExpandedExpression() ); + } + if ( m_shouldStoreSuccesfulAssertions && + assertionStats.assertionResult.isOk() ) { + static_cast( + assertionStats.assertionResult.getExpandedExpression() ); + } + SectionNode& sectionNode = *m_sectionStack.back(); + sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats ); + } + + void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) { + assert( !m_sectionStack.empty() ); + SectionNode& node = *m_sectionStack.back(); + node.stats = sectionStats; + m_sectionStack.pop_back(); + } + + void CumulativeReporterBase::testCaseEnded( + TestCaseStats const& testCaseStats ) { + auto node = Detail::make_unique( testCaseStats ); + assert( m_sectionStack.size() == 0 ); + node->children.push_back( CATCH_MOVE(m_rootSection) ); + m_testCases.push_back( CATCH_MOVE(node) ); + + assert( m_deepestSection ); + m_deepestSection->stdOut = testCaseStats.stdOut; + m_deepestSection->stdErr = testCaseStats.stdErr; + } + + + void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) { + assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run"); + m_testRun = Detail::make_unique( testRunStats ); + m_testRun->children.swap( m_testCases ); + testRunEndedCumulative(); + } + + bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const { + return std::any_of( + assertionsAndBenchmarks.begin(), + assertionsAndBenchmarks.end(), + []( Detail::AssertionOrBenchmarkResult const& res ) { + return res.isAssertion(); + } ); + } + +} // end namespace Catch + + + + +namespace Catch { + + void EventListenerBase::fatalErrorEncountered( StringRef ) {} + + void EventListenerBase::benchmarkPreparing( StringRef ) {} + void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {} + void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {} + void EventListenerBase::benchmarkFailed( StringRef ) {} + + void EventListenerBase::assertionStarting( AssertionInfo const& ) {} + + void EventListenerBase::assertionEnded( AssertionStats const& ) {} + void EventListenerBase::listReporters( + std::vector const& ) {} + void EventListenerBase::listListeners( + std::vector const& ) {} + void EventListenerBase::listTests( std::vector const& ) {} + void EventListenerBase::listTags( std::vector const& ) {} + void EventListenerBase::noMatchingTestCases( StringRef ) {} + void EventListenerBase::reportInvalidTestSpec( StringRef ) {} + void EventListenerBase::testRunStarting( TestRunInfo const& ) {} + void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {} + void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {} + void EventListenerBase::sectionStarting( SectionInfo const& ) {} + void EventListenerBase::sectionEnded( SectionStats const& ) {} + void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {} + void EventListenerBase::testCaseEnded( TestCaseStats const& ) {} + void EventListenerBase::testRunEnded( TestRunStats const& ) {} + void EventListenerBase::skipTest( TestCaseInfo const& ) {} +} // namespace Catch + + + + +#include +#include +#include +#include +#include + +namespace Catch { + + namespace { + void listTestNamesOnly(std::ostream& out, + std::vector const& tests) { + for (auto const& test : tests) { + auto const& testCaseInfo = test.getTestCaseInfo(); + + if (startsWith(testCaseInfo.name, '#')) { + out << '"' << testCaseInfo.name << '"'; + } else { + out << testCaseInfo.name; + } + + out << '\n'; + } + out << std::flush; + } + } // end unnamed namespace + + + // Because formatting using c++ streams is stateful, drop down to C is + // required Alternatively we could use stringstream, but its performance + // is... not good. + std::string getFormattedDuration( double duration ) { + // Max exponent + 1 is required to represent the whole part + // + 1 for decimal point + // + 3 for the 3 decimal places + // + 1 for null terminator + const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1; + char buffer[maxDoubleSize]; + + // Save previous errno, to prevent sprintf from overwriting it + ErrnoGuard guard; +#ifdef _MSC_VER + size_t printedLength = static_cast( + sprintf_s( buffer, "%.3f", duration ) ); +#else + size_t printedLength = static_cast( + std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) ); +#endif + return std::string( buffer, printedLength ); + } + + bool shouldShowDuration( IConfig const& config, double duration ) { + if ( config.showDurations() == ShowDurations::Always ) { + return true; + } + if ( config.showDurations() == ShowDurations::Never ) { + return false; + } + const double min = config.minDuration(); + return min >= 0 && duration >= min; + } + + std::string serializeFilters( std::vector const& filters ) { + // We add a ' ' separator between each filter + size_t serialized_size = filters.size() - 1; + for (auto const& filter : filters) { + serialized_size += filter.size(); + } + + std::string serialized; + serialized.reserve(serialized_size); + bool first = true; + + for (auto const& filter : filters) { + if (!first) { + serialized.push_back(' '); + } + first = false; + serialized.append(filter); + } + + return serialized; + } + + std::ostream& operator<<( std::ostream& out, lineOfChars value ) { + for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) { + out.put( value.c ); + } + return out; + } + + void + defaultListReporters( std::ostream& out, + std::vector const& descriptions, + Verbosity verbosity ) { + out << "Available reporters:\n"; + const auto maxNameLen = + std::max_element( descriptions.begin(), + descriptions.end(), + []( ReporterDescription const& lhs, + ReporterDescription const& rhs ) { + return lhs.name.size() < rhs.name.size(); + } ) + ->name.size(); + + for ( auto const& desc : descriptions ) { + if ( verbosity == Verbosity::Quiet ) { + out << TextFlow::Column( desc.name ) + .indent( 2 ) + .width( 5 + maxNameLen ) + << '\n'; + } else { + out << TextFlow::Column( desc.name + ':' ) + .indent( 2 ) + .width( 5 + maxNameLen ) + + TextFlow::Column( desc.description ) + .initialIndent( 0 ) + .indent( 2 ) + .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 ) + << '\n'; + } + } + out << '\n' << std::flush; + } + + void defaultListListeners( std::ostream& out, + std::vector const& descriptions ) { + out << "Registered listeners:\n"; + + if(descriptions.empty()) { + return; + } + + const auto maxNameLen = + std::max_element( descriptions.begin(), + descriptions.end(), + []( ListenerDescription const& lhs, + ListenerDescription const& rhs ) { + return lhs.name.size() < rhs.name.size(); + } ) + ->name.size(); + + for ( auto const& desc : descriptions ) { + out << TextFlow::Column( static_cast( desc.name ) + + ':' ) + .indent( 2 ) + .width( maxNameLen + 5 ) + + TextFlow::Column( desc.description ) + .initialIndent( 0 ) + .indent( 2 ) + .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 ) + << '\n'; + } + + out << '\n' << std::flush; + } + + void defaultListTags( std::ostream& out, + std::vector const& tags, + bool isFiltered ) { + if ( isFiltered ) { + out << "Tags for matching test cases:\n"; + } else { + out << "All available tags:\n"; + } + + for ( auto const& tagCount : tags ) { + ReusableStringStream rss; + rss << " " << std::setw( 2 ) << tagCount.count << " "; + auto str = rss.str(); + auto wrapper = TextFlow::Column( tagCount.all() ) + .initialIndent( 0 ) + .indent( str.size() ) + .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 ); + out << str << wrapper << '\n'; + } + out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush; + } + + void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector const& tests, bool isFiltered, Verbosity verbosity) { + // We special case this to provide the equivalent of old + // `--list-test-names-only`, which could then be used by the + // `--input-file` option. + if (verbosity == Verbosity::Quiet) { + listTestNamesOnly(out, tests); + return; + } + + if (isFiltered) { + out << "Matching test cases:\n"; + } else { + out << "All available test cases:\n"; + } + + for (auto const& test : tests) { + auto const& testCaseInfo = test.getTestCaseInfo(); + Colour::Code colour = testCaseInfo.isHidden() + ? Colour::SecondaryText + : Colour::None; + auto colourGuard = streamColour->guardColour( colour ).engage( out ); + + out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n'; + if (verbosity >= Verbosity::High) { + out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n'; + } + if (!testCaseInfo.tags.empty() && + verbosity > Verbosity::Quiet) { + out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n'; + } + } + + if (isFiltered) { + out << pluralise(tests.size(), "matching test case"_sr); + } else { + out << pluralise(tests.size(), "test case"_sr); + } + out << "\n\n" << std::flush; + } + + namespace { + class SummaryColumn { + public: + SummaryColumn( std::string suffix, Colour::Code colour ): + m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {} + + SummaryColumn&& addRow( std::uint64_t count ) && { + std::string row = std::to_string(count); + auto const new_width = std::max( m_width, row.size() ); + if ( new_width > m_width ) { + for ( auto& oldRow : m_rows ) { + oldRow.insert( 0, new_width - m_width, ' ' ); + } + } else { + row.insert( 0, m_width - row.size(), ' ' ); + } + m_width = new_width; + m_rows.push_back( row ); + return std::move( *this ); + } + + std::string const& getSuffix() const { return m_suffix; } + Colour::Code getColour() const { return m_colour; } + std::string const& getRow( std::size_t index ) const { + return m_rows[index]; + } + + private: + std::string m_suffix; + Colour::Code m_colour; + std::size_t m_width = 0; + std::vector m_rows; + }; + + void printSummaryRow( std::ostream& stream, + ColourImpl& colour, + StringRef label, + std::vector const& cols, + std::size_t row ) { + for ( auto const& col : cols ) { + auto const& value = col.getRow( row ); + auto const& suffix = col.getSuffix(); + if ( suffix.empty() ) { + stream << label << ": "; + if ( value != "0" ) { + stream << value; + } else { + stream << colour.guardColour( Colour::Warning ) + << "- none -"; + } + } else if ( value != "0" ) { + stream << colour.guardColour( Colour::LightGrey ) << " | " + << colour.guardColour( col.getColour() ) << value + << ' ' << suffix; + } + } + stream << '\n'; + } + } // namespace + + void printTestRunTotals( std::ostream& stream, + ColourImpl& streamColour, + Totals const& totals ) { + if ( totals.testCases.total() == 0 ) { + stream << streamColour.guardColour( Colour::Warning ) + << "No tests ran\n"; + return; + } + + if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) { + stream << streamColour.guardColour( Colour::ResultSuccess ) + << "All tests passed"; + stream << " (" + << pluralise( totals.assertions.passed, "assertion"_sr ) + << " in " + << pluralise( totals.testCases.passed, "test case"_sr ) + << ')' << '\n'; + return; + } + + std::vector columns; + // Don't include "skipped assertions" in total count + const auto totalAssertionCount = + totals.assertions.total() - totals.assertions.skipped; + columns.push_back( SummaryColumn( "", Colour::None ) + .addRow( totals.testCases.total() ) + .addRow( totalAssertionCount ) ); + columns.push_back( SummaryColumn( "passed", Colour::Success ) + .addRow( totals.testCases.passed ) + .addRow( totals.assertions.passed ) ); + columns.push_back( SummaryColumn( "failed", Colour::ResultError ) + .addRow( totals.testCases.failed ) + .addRow( totals.assertions.failed ) ); + columns.push_back( SummaryColumn( "skipped", Colour::Skip ) + .addRow( totals.testCases.skipped ) + // Don't print "skipped assertions" + .addRow( 0 ) ); + columns.push_back( + SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) + .addRow( totals.testCases.failedButOk ) + .addRow( totals.assertions.failedButOk ) ); + printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 ); + printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 ); + } + +} // namespace Catch + + +// + +namespace Catch { + namespace { + void writeSourceInfo( JsonObjectWriter& writer, + SourceLineInfo const& sourceInfo ) { + auto source_location_writer = + writer.write( "source-location"_sr ).writeObject(); + source_location_writer.write( "filename"_sr ) + .write( sourceInfo.file ); + source_location_writer.write( "line"_sr ).write( sourceInfo.line ); + } + + void writeTags( JsonArrayWriter writer, std::vector const& tags ) { + for ( auto const& tag : tags ) { + writer.write( tag.original ); + } + } + + void writeProperties( JsonArrayWriter writer, + TestCaseInfo const& info ) { + if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); } + if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); } + if ( info.expectedToFail() ) { + writer.write( "expected-to-fail"_sr ); + } + if ( info.throws() ) { writer.write( "throws"_sr ); } + } + + } // namespace + + JsonReporter::JsonReporter( ReporterConfig&& config ): + StreamingReporterBase{ CATCH_MOVE( config ) } { + + m_preferences.shouldRedirectStdOut = true; + // TBD: Do we want to report all assertions? XML reporter does + // not, but for machine-parseable reporters I think the answer + // should be yes. + m_preferences.shouldReportAllAssertions = true; + + m_objectWriters.emplace( m_stream ); + m_writers.emplace( Writer::Object ); + auto& writer = m_objectWriters.top(); + + writer.write( "version"_sr ).write( 1 ); + + { + auto metadata_writer = writer.write( "metadata"_sr ).writeObject(); + metadata_writer.write( "name"_sr ).write( m_config->name() ); + metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() ); + metadata_writer.write( "catch2-version"_sr ) + .write( libraryVersion() ); + if ( m_config->testSpec().hasFilters() ) { + metadata_writer.write( "filters"_sr ) + .write( m_config->testSpec() ); + } + } + } + + JsonReporter::~JsonReporter() { + endListing(); + // TODO: Ensure this closes the top level object, add asserts + assert( m_writers.size() == 1 && "Only the top level object should be open" ); + assert( m_writers.top() == Writer::Object ); + endObject(); + m_stream << '\n' << std::flush; + assert( m_writers.empty() ); + } + + JsonArrayWriter& JsonReporter::startArray() { + m_arrayWriters.emplace( m_arrayWriters.top().writeArray() ); + m_writers.emplace( Writer::Array ); + return m_arrayWriters.top(); + } + JsonArrayWriter& JsonReporter::startArray( StringRef key ) { + m_arrayWriters.emplace( + m_objectWriters.top().write( key ).writeArray() ); + m_writers.emplace( Writer::Array ); + return m_arrayWriters.top(); + } + + JsonObjectWriter& JsonReporter::startObject() { + m_objectWriters.emplace( m_arrayWriters.top().writeObject() ); + m_writers.emplace( Writer::Object ); + return m_objectWriters.top(); + } + JsonObjectWriter& JsonReporter::startObject( StringRef key ) { + m_objectWriters.emplace( + m_objectWriters.top().write( key ).writeObject() ); + m_writers.emplace( Writer::Object ); + return m_objectWriters.top(); + } + + void JsonReporter::endObject() { + assert( isInside( Writer::Object ) ); + m_objectWriters.pop(); + m_writers.pop(); + } + void JsonReporter::endArray() { + assert( isInside( Writer::Array ) ); + m_arrayWriters.pop(); + m_writers.pop(); + } + + bool JsonReporter::isInside( Writer writer ) { + return !m_writers.empty() && m_writers.top() == writer; + } + + void JsonReporter::startListing() { + if ( !m_startedListing ) { startObject( "listings"_sr ); } + m_startedListing = true; + } + void JsonReporter::endListing() { + if ( m_startedListing ) { endObject(); } + m_startedListing = false; + } + + std::string JsonReporter::getDescription() { + return "Outputs listings as JSON. Test listing is Work-in-Progress!"; + } + + void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) { + StreamingReporterBase::testRunStarting( runInfo ); + endListing(); + + assert( isInside( Writer::Object ) ); + startObject( "test-run"_sr ); + startArray( "test-cases"_sr ); + } + + static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) { + writer.write( "passed"_sr ).write( counts.passed ); + writer.write( "failed"_sr ).write( counts.failed ); + writer.write( "fail-but-ok"_sr ).write( counts.failedButOk ); + writer.write( "skipped"_sr ).write( counts.skipped ); + } + + void JsonReporter::testRunEnded(TestRunStats const& runStats) { + assert( isInside( Writer::Array ) ); + // End "test-cases" + endArray(); + + { + auto totals = + m_objectWriters.top().write( "totals"_sr ).writeObject(); + writeCounts( totals.write( "assertions"_sr ).writeObject(), + runStats.totals.assertions ); + writeCounts( totals.write( "test-cases"_sr ).writeObject(), + runStats.totals.testCases ); + } + + // End the "test-run" object + endObject(); + } + + void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) { + StreamingReporterBase::testCaseStarting( tcInfo ); + + assert( isInside( Writer::Array ) && + "We should be in the 'test-cases' array" ); + startObject(); + // "test-info" prelude + { + auto testInfo = + m_objectWriters.top().write( "test-info"_sr ).writeObject(); + // TODO: handle testName vs className!! + testInfo.write( "name"_sr ).write( tcInfo.name ); + writeSourceInfo(testInfo, tcInfo.lineInfo); + writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags ); + writeProperties( testInfo.write( "properties"_sr ).writeArray(), + tcInfo ); + } + + + // Start the array for individual test runs (testCasePartial pairs) + startArray( "runs"_sr ); + } + + void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) { + StreamingReporterBase::testCaseEnded( tcStats ); + + // We need to close the 'runs' array before finishing the test case + assert( isInside( Writer::Array ) ); + endArray(); + + { + auto totals = + m_objectWriters.top().write( "totals"_sr ).writeObject(); + writeCounts( totals.write( "assertions"_sr ).writeObject(), + tcStats.totals.assertions ); + // We do not write the test case totals, because there will always be just one test case here. + // TODO: overall "result" -> success, skip, fail here? Or in partial result? + } + // We do not write out stderr/stdout, because we instead wrote those out in partial runs + + // TODO: aborting? + + // And we also close this test case's object + assert( isInside( Writer::Object ) ); + endObject(); + } + + void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/, + uint64_t index ) { + startObject(); + m_objectWriters.top().write( "run-idx"_sr ).write( index ); + startArray( "path"_sr ); + // TODO: we want to delay most of the printing to the 'root' section + // TODO: childSection key name? + } + + void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats, + uint64_t /*index*/ ) { + // Fixme: the top level section handles this. + //// path object + endArray(); + if ( !tcStats.stdOut.empty() ) { + m_objectWriters.top() + .write( "captured-stdout"_sr ) + .write( tcStats.stdOut ); + } + if ( !tcStats.stdErr.empty() ) { + m_objectWriters.top() + .write( "captured-stderr"_sr ) + .write( tcStats.stdErr ); + } + { + auto totals = + m_objectWriters.top().write( "totals"_sr ).writeObject(); + writeCounts( totals.write( "assertions"_sr ).writeObject(), + tcStats.totals.assertions ); + // We do not write the test case totals, because there will + // always be just one test case here. + // TODO: overall "result" -> success, skip, fail here? Or in + // partial result? + } + // TODO: aborting? + // run object + endObject(); + } + + void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) { + assert( isInside( Writer::Array ) && + "Section should always start inside an object" ); + // We want to nest top level sections, even though it shares name + // and source loc with the TEST_CASE + auto& sectionObject = startObject(); + sectionObject.write( "kind"_sr ).write( "section"_sr ); + sectionObject.write( "name"_sr ).write( sectionInfo.name ); + writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo ); + + + // TBD: Do we want to create this event lazily? It would become + // rather complex, but we could do it, and it would look + // better for empty sections. OTOH, empty sections should + // be rare. + startArray( "path"_sr ); + } + void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) { + // End the subpath array + endArray(); + // TODO: metadata + // TODO: what info do we have here? + + // End the section object + endObject(); + } + + void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {} + void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) { + // TODO: There is lot of different things to handle here, but + // we can fill it in later, after we show that the basic + // outline and streaming reporter impl works well enough. + //if ( !m_config->includeSuccessfulResults() + // && assertionStats.assertionResult.isOk() ) { + // return; + //} + assert( isInside( Writer::Array ) ); + auto assertionObject = m_arrayWriters.top().writeObject(); + + assertionObject.write( "kind"_sr ).write( "assertion"_sr ); + writeSourceInfo( assertionObject, + assertionStats.assertionResult.getSourceInfo() ); + assertionObject.write( "status"_sr ) + .write( assertionStats.assertionResult.isOk() ); + // TODO: handling of result. + // TODO: messages + // TODO: totals? + } + + + void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; } + void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {} + void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {} + void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; } + + void JsonReporter::listReporters( + std::vector const& descriptions ) { + startListing(); + + auto writer = + m_objectWriters.top().write( "reporters"_sr ).writeArray(); + for ( auto const& desc : descriptions ) { + auto desc_writer = writer.writeObject(); + desc_writer.write( "name"_sr ).write( desc.name ); + desc_writer.write( "description"_sr ).write( desc.description ); + } + } + void JsonReporter::listListeners( + std::vector const& descriptions ) { + startListing(); + + auto writer = + m_objectWriters.top().write( "listeners"_sr ).writeArray(); + + for ( auto const& desc : descriptions ) { + auto desc_writer = writer.writeObject(); + desc_writer.write( "name"_sr ).write( desc.name ); + desc_writer.write( "description"_sr ).write( desc.description ); + } + } + void JsonReporter::listTests( std::vector const& tests ) { + startListing(); + + auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray(); + + for ( auto const& test : tests ) { + auto desc_writer = writer.writeObject(); + auto const& info = test.getTestCaseInfo(); + + desc_writer.write( "name"_sr ).write( info.name ); + desc_writer.write( "class-name"_sr ).write( info.className ); + { + auto tag_writer = desc_writer.write( "tags"_sr ).writeArray(); + for ( auto const& tag : info.tags ) { + tag_writer.write( tag.original ); + } + } + writeSourceInfo( desc_writer, info.lineInfo ); + } + } + void JsonReporter::listTags( std::vector const& tags ) { + startListing(); + + auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray(); + for ( auto const& tag : tags ) { + auto tag_writer = writer.writeObject(); + { + auto aliases_writer = + tag_writer.write( "aliases"_sr ).writeArray(); + for ( auto alias : tag.spellings ) { + aliases_writer.write( alias ); + } + } + tag_writer.write( "count"_sr ).write( tag.count ); + } + } +} // namespace Catch + + + + +#include +#include +#include +#include + +namespace Catch { + + namespace { + std::string getCurrentTimestamp() { + time_t rawtime; + std::time(&rawtime); + + std::tm timeInfo = {}; +#if defined (_MSC_VER) || defined (__MINGW32__) + gmtime_s(&timeInfo, &rawtime); +#elif defined (CATCH_PLATFORM_PLAYSTATION) + gmtime_s(&rawtime, &timeInfo); +#elif defined (__IAR_SYSTEMS_ICC__) + timeInfo = *std::gmtime(&rawtime); +#else + gmtime_r(&rawtime, &timeInfo); +#endif + + auto const timeStampSize = sizeof("2017-01-16T17:06:45Z"); + char timeStamp[timeStampSize]; + const char * const fmt = "%Y-%m-%dT%H:%M:%SZ"; + + std::strftime(timeStamp, timeStampSize, fmt, &timeInfo); + + return std::string(timeStamp, timeStampSize - 1); + } + + std::string fileNameTag(std::vector const& tags) { + auto it = std::find_if(begin(tags), + end(tags), + [] (Tag const& tag) { + return tag.original.size() > 0 + && tag.original[0] == '#'; }); + if (it != tags.end()) { + return static_cast( + it->original.substr(1, it->original.size() - 1) + ); + } + return std::string(); + } + + // Formats the duration in seconds to 3 decimal places. + // This is done because some genius defined Maven Surefire schema + // in a way that only accepts 3 decimal places, and tools like + // Jenkins use that schema for validation JUnit reporter output. + std::string formatDuration( double seconds ) { + ReusableStringStream rss; + rss << std::fixed << std::setprecision( 3 ) << seconds; + return rss.str(); + } + + static void normalizeNamespaceMarkers(std::string& str) { + std::size_t pos = str.find( "::" ); + while ( pos != std::string::npos ) { + str.replace( pos, 2, "." ); + pos += 1; + pos = str.find( "::", pos ); + } + } + + } // anonymous namespace + + JunitReporter::JunitReporter( ReporterConfig&& _config ) + : CumulativeReporterBase( CATCH_MOVE(_config) ), + xml( m_stream ) + { + m_preferences.shouldRedirectStdOut = true; + m_preferences.shouldReportAllAssertions = false; + m_shouldStoreSuccesfulAssertions = false; + } + + std::string JunitReporter::getDescription() { + return "Reports test results in an XML format that looks like Ant's junitreport target"; + } + + void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) { + CumulativeReporterBase::testRunStarting( runInfo ); + xml.startElement( "testsuites" ); + suiteTimer.start(); + stdOutForSuite.clear(); + stdErrForSuite.clear(); + unexpectedExceptions = 0; + } + + void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) { + m_okToFail = testCaseInfo.okToFail(); + } + + void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) { + if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail ) + unexpectedExceptions++; + CumulativeReporterBase::assertionEnded( assertionStats ); + } + + void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { + stdOutForSuite += testCaseStats.stdOut; + stdErrForSuite += testCaseStats.stdErr; + CumulativeReporterBase::testCaseEnded( testCaseStats ); + } + + void JunitReporter::testRunEndedCumulative() { + const auto suiteTime = suiteTimer.getElapsedSeconds(); + writeRun( *m_testRun, suiteTime ); + xml.endElement(); + } + + void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); + + TestRunStats const& stats = testRunNode.value; + xml.writeAttribute( "name"_sr, stats.runInfo.name ); + xml.writeAttribute( "errors"_sr, unexpectedExceptions ); + xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions ); + xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped ); + xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() ); + xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD + if( m_config->showDurations() == ShowDurations::Never ) + xml.writeAttribute( "time"_sr, ""_sr ); + else + xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) ); + xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() ); + + // Write properties + { + auto properties = xml.scopedElement("properties"); + xml.scopedElement("property") + .writeAttribute("name"_sr, "random-seed"_sr) + .writeAttribute("value"_sr, m_config->rngSeed()); + if (m_config->testSpec().hasFilters()) { + xml.scopedElement("property") + .writeAttribute("name"_sr, "filters"_sr) + .writeAttribute("value"_sr, m_config->testSpec()); + } + } + + // Write test cases + for( auto const& child : testRunNode.children ) + writeTestCase( *child ); + + xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline ); + xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline ); + } + + void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) { + TestCaseStats const& stats = testCaseNode.value; + + // All test cases have exactly one section - which represents the + // test case itself. That section may have 0-n nested sections + assert( testCaseNode.children.size() == 1 ); + SectionNode const& rootSection = *testCaseNode.children.front(); + + std::string className = + static_cast( stats.testInfo->className ); + + if( className.empty() ) { + className = fileNameTag(stats.testInfo->tags); + if ( className.empty() ) { + className = "global"; + } + } + + if ( !m_config->name().empty() ) + className = static_cast(m_config->name()) + '.' + className; + + normalizeNamespaceMarkers(className); + + writeSection( className, "", rootSection, stats.testInfo->okToFail() ); + } + + void JunitReporter::writeSection( std::string const& className, + std::string const& rootName, + SectionNode const& sectionNode, + bool testOkToFail) { + std::string name = trim( sectionNode.stats.sectionInfo.name ); + if( !rootName.empty() ) + name = rootName + '/' + name; + + if ( sectionNode.stats.assertions.total() > 0 + || !sectionNode.stdOut.empty() + || !sectionNode.stdErr.empty() ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); + if( className.empty() ) { + xml.writeAttribute( "classname"_sr, name ); + xml.writeAttribute( "name"_sr, "root"_sr ); + } + else { + xml.writeAttribute( "classname"_sr, className ); + xml.writeAttribute( "name"_sr, name ); + } + xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) ); + // This is not ideal, but it should be enough to mimic gtest's + // junit output. + // Ideally the JUnit reporter would also handle `skipTest` + // events and write those out appropriately. + xml.writeAttribute( "status"_sr, "run"_sr ); + + if (sectionNode.stats.assertions.failedButOk) { + xml.scopedElement("skipped") + .writeAttribute("message", "TEST_CASE tagged with !mayfail"); + } + + writeAssertions( sectionNode ); + + + if( !sectionNode.stdOut.empty() ) + xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline ); + if( !sectionNode.stdErr.empty() ) + xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline ); + } + for( auto const& childNode : sectionNode.childSections ) + if( className.empty() ) + writeSection( name, "", *childNode, testOkToFail ); + else + writeSection( className, name, *childNode, testOkToFail ); + } + + void JunitReporter::writeAssertions( SectionNode const& sectionNode ) { + for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) { + if (assertionOrBenchmark.isAssertion()) { + writeAssertion(assertionOrBenchmark.asAssertion()); + } + } + } + + void JunitReporter::writeAssertion( AssertionStats const& stats ) { + AssertionResult const& result = stats.assertionResult; + if ( !result.isOk() || + result.getResultType() == ResultWas::ExplicitSkip ) { + std::string elementName; + switch( result.getResultType() ) { + case ResultWas::ThrewException: + case ResultWas::FatalErrorCondition: + elementName = "error"; + break; + case ResultWas::ExplicitFailure: + case ResultWas::ExpressionFailed: + case ResultWas::DidntThrowException: + elementName = "failure"; + break; + case ResultWas::ExplicitSkip: + elementName = "skipped"; + break; + // We should never see these here: + case ResultWas::Info: + case ResultWas::Warning: + case ResultWas::Ok: + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + elementName = "internalError"; + break; + } + + XmlWriter::ScopedElement e = xml.scopedElement( elementName ); + + xml.writeAttribute( "message"_sr, result.getExpression() ); + xml.writeAttribute( "type"_sr, result.getTestMacroName() ); + + ReusableStringStream rss; + if ( result.getResultType() == ResultWas::ExplicitSkip ) { + rss << "SKIPPED\n"; + } else { + rss << "FAILED" << ":\n"; + if (result.hasExpression()) { + rss << " "; + rss << result.getExpressionInMacro(); + rss << '\n'; + } + if (result.hasExpandedExpression()) { + rss << "with expansion:\n"; + rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n'; + } + } + + if( result.hasMessage() ) + rss << result.getMessage() << '\n'; + for( auto const& msg : stats.infoMessages ) + if( msg.type == ResultWas::Info ) + rss << msg.message << '\n'; + + rss << "at " << result.getSourceInfo(); + xml.writeText( rss.str(), XmlFormatting::Newline ); + } + } + +} // end namespace Catch + + + + +#include + +namespace Catch { + void MultiReporter::updatePreferences(IEventListener const& reporterish) { + m_preferences.shouldRedirectStdOut |= + reporterish.getPreferences().shouldRedirectStdOut; + m_preferences.shouldReportAllAssertions |= + reporterish.getPreferences().shouldReportAllAssertions; + } + + void MultiReporter::addListener( IEventListenerPtr&& listener ) { + updatePreferences(*listener); + m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) ); + ++m_insertedListeners; + } + + void MultiReporter::addReporter( IEventListenerPtr&& reporter ) { + updatePreferences(*reporter); + + // We will need to output the captured stdout if there are reporters + // that do not want it captured. + // We do not consider listeners, because it is generally assumed that + // listeners are output-transparent, even though they can ask for stdout + // capture to do something with it. + m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut; + + // Reporters can always be placed to the back without breaking the + // reporting order + m_reporterLikes.push_back( CATCH_MOVE( reporter ) ); + } + + void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->noMatchingTestCases( unmatchedSpec ); + } + } + + void MultiReporter::fatalErrorEncountered( StringRef error ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->fatalErrorEncountered( error ); + } + } + + void MultiReporter::reportInvalidTestSpec( StringRef arg ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->reportInvalidTestSpec( arg ); + } + } + + void MultiReporter::benchmarkPreparing( StringRef name ) { + for (auto& reporterish : m_reporterLikes) { + reporterish->benchmarkPreparing(name); + } + } + void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->benchmarkStarting( benchmarkInfo ); + } + } + void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->benchmarkEnded( benchmarkStats ); + } + } + + void MultiReporter::benchmarkFailed( StringRef error ) { + for (auto& reporterish : m_reporterLikes) { + reporterish->benchmarkFailed(error); + } + } + + void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testRunStarting( testRunInfo ); + } + } + + void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testCaseStarting( testInfo ); + } + } + + void + MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo, + uint64_t partNumber ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testCasePartialStarting( testInfo, partNumber ); + } + } + + void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->sectionStarting( sectionInfo ); + } + } + + void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->assertionStarting( assertionInfo ); + } + } + + void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) { + const bool reportByDefault = + assertionStats.assertionResult.getResultType() != ResultWas::Ok || + m_config->includeSuccessfulResults(); + + for ( auto & reporterish : m_reporterLikes ) { + if ( reportByDefault || + reporterish->getPreferences().shouldReportAllAssertions ) { + reporterish->assertionEnded( assertionStats ); + } + } + } + + void MultiReporter::sectionEnded( SectionStats const& sectionStats ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->sectionEnded( sectionStats ); + } + } + + void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats, + uint64_t partNumber ) { + if ( m_preferences.shouldRedirectStdOut && + m_haveNoncapturingReporters ) { + if ( !testStats.stdOut.empty() ) { + Catch::cout() << testStats.stdOut << std::flush; + } + if ( !testStats.stdErr.empty() ) { + Catch::cerr() << testStats.stdErr << std::flush; + } + } + + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testCasePartialEnded( testStats, partNumber ); + } + } + + void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testCaseEnded( testCaseStats ); + } + } + + void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->testRunEnded( testRunStats ); + } + } + + + void MultiReporter::skipTest( TestCaseInfo const& testInfo ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->skipTest( testInfo ); + } + } + + void MultiReporter::listReporters(std::vector const& descriptions) { + for (auto& reporterish : m_reporterLikes) { + reporterish->listReporters(descriptions); + } + } + + void MultiReporter::listListeners( + std::vector const& descriptions ) { + for ( auto& reporterish : m_reporterLikes ) { + reporterish->listListeners( descriptions ); + } + } + + void MultiReporter::listTests(std::vector const& tests) { + for (auto& reporterish : m_reporterLikes) { + reporterish->listTests(tests); + } + } + + void MultiReporter::listTags(std::vector const& tags) { + for (auto& reporterish : m_reporterLikes) { + reporterish->listTags(tags); + } + } + +} // end namespace Catch + + + + + +namespace Catch { + namespace Detail { + + void registerReporterImpl( std::string const& name, + IReporterFactoryPtr reporterPtr ) { + CATCH_TRY { + getMutableRegistryHub().registerReporter( + name, CATCH_MOVE( reporterPtr ) ); + } + CATCH_CATCH_ALL { + // Do not throw when constructing global objects, instead + // register the exception to be processed later + getMutableRegistryHub().registerStartupException(); + } + } + + void registerListenerImpl( Detail::unique_ptr listenerFactory ) { + getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) ); + } + + + } // namespace Detail +} // namespace Catch + + + + +#include + +namespace Catch { + + namespace { + std::string createMetadataString(IConfig const& config) { + ReusableStringStream sstr; + if ( config.testSpec().hasFilters() ) { + sstr << "filters='" + << config.testSpec() + << "' "; + } + sstr << "rng-seed=" << config.rngSeed(); + return sstr.str(); + } + } + + void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) { + CumulativeReporterBase::testRunStarting(testRunInfo); + + xml.writeComment( createMetadataString( *m_config ) ); + xml.startElement("testExecutions"); + xml.writeAttribute("version"_sr, '1'); + } + + void SonarQubeReporter::writeRun( TestRunNode const& runNode ) { + std::map> testsPerFile; + + for ( auto const& child : runNode.children ) { + testsPerFile[child->value.testInfo->lineInfo.file].push_back( + child.get() ); + } + + for ( auto const& kv : testsPerFile ) { + writeTestFile( kv.first, kv.second ); + } + } + + void SonarQubeReporter::writeTestFile(StringRef filename, std::vector const& testCaseNodes) { + XmlWriter::ScopedElement e = xml.scopedElement("file"); + xml.writeAttribute("path"_sr, filename); + + for (auto const& child : testCaseNodes) + writeTestCase(*child); + } + + void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) { + // All test cases have exactly one section - which represents the + // test case itself. That section may have 0-n nested sections + assert(testCaseNode.children.size() == 1); + SectionNode const& rootSection = *testCaseNode.children.front(); + writeSection("", rootSection, testCaseNode.value.testInfo->okToFail()); + } + + void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) { + std::string name = trim(sectionNode.stats.sectionInfo.name); + if (!rootName.empty()) + name = rootName + '/' + name; + + if ( sectionNode.stats.assertions.total() > 0 + || !sectionNode.stdOut.empty() + || !sectionNode.stdErr.empty() ) { + XmlWriter::ScopedElement e = xml.scopedElement("testCase"); + xml.writeAttribute("name"_sr, name); + xml.writeAttribute("duration"_sr, static_cast(sectionNode.stats.durationInSeconds * 1000)); + + writeAssertions(sectionNode, okToFail); + } + + for (auto const& childNode : sectionNode.childSections) + writeSection(name, *childNode, okToFail); + } + + void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) { + for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) { + if (assertionOrBenchmark.isAssertion()) { + writeAssertion(assertionOrBenchmark.asAssertion(), okToFail); + } + } + } + + void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) { + AssertionResult const& result = stats.assertionResult; + if ( !result.isOk() || + result.getResultType() == ResultWas::ExplicitSkip ) { + std::string elementName; + if (okToFail) { + elementName = "skipped"; + } else { + switch (result.getResultType()) { + case ResultWas::ThrewException: + case ResultWas::FatalErrorCondition: + elementName = "error"; + break; + case ResultWas::ExplicitFailure: + case ResultWas::ExpressionFailed: + case ResultWas::DidntThrowException: + elementName = "failure"; + break; + case ResultWas::ExplicitSkip: + elementName = "skipped"; + break; + // We should never see these here: + case ResultWas::Info: + case ResultWas::Warning: + case ResultWas::Ok: + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + elementName = "internalError"; + break; + } + } + + XmlWriter::ScopedElement e = xml.scopedElement(elementName); + + ReusableStringStream messageRss; + messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')'; + xml.writeAttribute("message"_sr, messageRss.str()); + + ReusableStringStream textRss; + if ( result.getResultType() == ResultWas::ExplicitSkip ) { + textRss << "SKIPPED\n"; + } else { + textRss << "FAILED:\n"; + if (result.hasExpression()) { + textRss << '\t' << result.getExpressionInMacro() << '\n'; + } + if (result.hasExpandedExpression()) { + textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n'; + } + } + + if (result.hasMessage()) + textRss << result.getMessage() << '\n'; + + for (auto const& msg : stats.infoMessages) + if (msg.type == ResultWas::Info) + textRss << msg.message << '\n'; + + textRss << "at " << result.getSourceInfo(); + xml.writeText(textRss.str(), XmlFormatting::Newline); + } + } + +} // end namespace Catch + + + +namespace Catch { + + StreamingReporterBase::~StreamingReporterBase() = default; + + void + StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) { + currentTestRunInfo = _testRunInfo; + } + + void StreamingReporterBase::testRunEnded( TestRunStats const& ) { + currentTestCaseInfo = nullptr; + } + +} // end namespace Catch + + + +#include +#include + +namespace Catch { + + namespace { + // Yes, this has to be outside the class and namespaced by naming. + // Making older compiler happy is hard. + static constexpr StringRef tapFailedString = "not ok"_sr; + static constexpr StringRef tapPassedString = "ok"_sr; + static constexpr Colour::Code tapDimColour = Colour::FileName; + + class TapAssertionPrinter { + public: + TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete; + TapAssertionPrinter(TapAssertionPrinter const&) = delete; + TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_) + : stream(_stream) + , result(_stats.assertionResult) + , messages(_stats.infoMessages) + , itMessage(_stats.infoMessages.begin()) + , printInfoMessages(true) + , counter(_counter) + , colourImpl( colour_ ) {} + + void print() { + itMessage = messages.begin(); + + switch (result.getResultType()) { + case ResultWas::Ok: + printResultType(tapPassedString); + printOriginalExpression(); + printReconstructedExpression(); + if (!result.hasExpression()) + printRemainingMessages(Colour::None); + else + printRemainingMessages(); + break; + case ResultWas::ExpressionFailed: + if (result.isOk()) { + printResultType(tapPassedString); + } else { + printResultType(tapFailedString); + } + printOriginalExpression(); + printReconstructedExpression(); + if (result.isOk()) { + printIssue(" # TODO"); + } + printRemainingMessages(); + break; + case ResultWas::ThrewException: + printResultType(tapFailedString); + printIssue("unexpected exception with message:"_sr); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::FatalErrorCondition: + printResultType(tapFailedString); + printIssue("fatal error condition with message:"_sr); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::DidntThrowException: + printResultType(tapFailedString); + printIssue("expected exception, got none"_sr); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::Info: + printResultType("info"_sr); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::Warning: + printResultType("warning"_sr); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::ExplicitFailure: + printResultType(tapFailedString); + printIssue("explicitly"_sr); + printRemainingMessages(Colour::None); + break; + case ResultWas::ExplicitSkip: + printResultType(tapPassedString); + printIssue(" # SKIP"_sr); + printMessage(); + printRemainingMessages(); + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + printResultType("** internal error **"_sr); + break; + } + } + + private: + void printResultType(StringRef passOrFail) const { + if (!passOrFail.empty()) { + stream << passOrFail << ' ' << counter << " -"; + } + } + + void printIssue(StringRef issue) const { + stream << ' ' << issue; + } + + void printExpressionWas() { + if (result.hasExpression()) { + stream << ';'; + stream << colourImpl->guardColour( tapDimColour ) + << " expression was:"; + printOriginalExpression(); + } + } + + void printOriginalExpression() const { + if (result.hasExpression()) { + stream << ' ' << result.getExpression(); + } + } + + void printReconstructedExpression() const { + if (result.hasExpandedExpression()) { + stream << colourImpl->guardColour( tapDimColour ) << " for: "; + + std::string expr = result.getExpandedExpression(); + std::replace(expr.begin(), expr.end(), '\n', ' '); + stream << expr; + } + } + + void printMessage() { + if (itMessage != messages.end()) { + stream << " '" << itMessage->message << '\''; + ++itMessage; + } + } + + void printRemainingMessages(Colour::Code colour = tapDimColour) { + if (itMessage == messages.end()) { + return; + } + + // using messages.end() directly (or auto) yields compilation error: + std::vector::const_iterator itEnd = messages.end(); + const std::size_t N = static_cast(itEnd - itMessage); + + stream << colourImpl->guardColour( colour ) << " with " + << pluralise( N, "message"_sr ) << ':'; + + for (; itMessage != itEnd; ) { + // If this assertion is a warning ignore any INFO messages + if (printInfoMessages || itMessage->type != ResultWas::Info) { + stream << " '" << itMessage->message << '\''; + if (++itMessage != itEnd) { + stream << colourImpl->guardColour(tapDimColour) << " and"; + } + } + } + } + + private: + std::ostream& stream; + AssertionResult const& result; + std::vector const& messages; + std::vector::const_iterator itMessage; + bool printInfoMessages; + std::size_t counter; + ColourImpl* colourImpl; + }; + + } // End anonymous namespace + + void TAPReporter::testRunStarting( TestRunInfo const& ) { + if ( m_config->testSpec().hasFilters() ) { + m_stream << "# filters: " << m_config->testSpec() << '\n'; + } + m_stream << "# rng-seed: " << m_config->rngSeed() << '\n'; + } + + void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) { + m_stream << "# No test cases matched '" << unmatchedSpec << "'\n"; + } + + void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) { + ++counter; + + m_stream << "# " << currentTestCaseInfo->name << '\n'; + TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get()); + printer.print(); + + m_stream << '\n' << std::flush; + } + + void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) { + m_stream << "1.." << _testRunStats.totals.assertions.total(); + if (_testRunStats.totals.testCases.total() == 0) { + m_stream << " # Skipped: No tests ran."; + } + m_stream << "\n\n" << std::flush; + StreamingReporterBase::testRunEnded(_testRunStats); + } + + + + +} // end namespace Catch + + + + +#include +#include + +namespace Catch { + + namespace { + // if string has a : in first line will set indent to follow it on + // subsequent lines + void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) { + std::size_t i = _string.find(": "); + if (i != std::string::npos) + i += 2; + else + i = 0; + os << TextFlow::Column(_string) + .indent(indent + i) + .initialIndent(indent) << '\n'; + } + + std::string escape(StringRef str) { + std::string escaped = static_cast(str); + replaceInPlace(escaped, "|", "||"); + replaceInPlace(escaped, "'", "|'"); + replaceInPlace(escaped, "\n", "|n"); + replaceInPlace(escaped, "\r", "|r"); + replaceInPlace(escaped, "[", "|["); + replaceInPlace(escaped, "]", "|]"); + return escaped; + } + } // end anonymous namespace + + + TeamCityReporter::~TeamCityReporter() = default; + + void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) { + m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name ) + << "']\n"; + } + + void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) { + m_stream << "##teamcity[testSuiteFinished name='" + << escape( runStats.runInfo.name ) << "']\n"; + } + + void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) { + AssertionResult const& result = assertionStats.assertionResult; + if ( !result.isOk() || + result.getResultType() == ResultWas::ExplicitSkip ) { + + ReusableStringStream msg; + if (!m_headerPrintedForThisSection) + printSectionHeader(msg.get()); + m_headerPrintedForThisSection = true; + + msg << result.getSourceInfo() << '\n'; + + switch (result.getResultType()) { + case ResultWas::ExpressionFailed: + msg << "expression failed"; + break; + case ResultWas::ThrewException: + msg << "unexpected exception"; + break; + case ResultWas::FatalErrorCondition: + msg << "fatal error condition"; + break; + case ResultWas::DidntThrowException: + msg << "no exception was thrown where one was expected"; + break; + case ResultWas::ExplicitFailure: + msg << "explicit failure"; + break; + case ResultWas::ExplicitSkip: + msg << "explicit skip"; + break; + + // We shouldn't get here because of the isOk() test + case ResultWas::Ok: + case ResultWas::Info: + case ResultWas::Warning: + CATCH_ERROR("Internal error in TeamCity reporter"); + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + CATCH_ERROR("Not implemented"); + } + if (assertionStats.infoMessages.size() == 1) + msg << " with message:"; + if (assertionStats.infoMessages.size() > 1) + msg << " with messages:"; + for (auto const& messageInfo : assertionStats.infoMessages) + msg << "\n \"" << messageInfo.message << '"'; + + + if (result.hasExpression()) { + msg << + "\n " << result.getExpressionInMacro() << "\n" + "with expansion:\n" + " " << result.getExpandedExpression() << '\n'; + } + + if ( result.getResultType() == ResultWas::ExplicitSkip ) { + m_stream << "##teamcity[testIgnored"; + } else if ( currentTestCaseInfo->okToFail() ) { + msg << "- failure ignore as test marked as 'ok to fail'\n"; + m_stream << "##teamcity[testIgnored"; + } else { + m_stream << "##teamcity[testFailed"; + } + m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\'' + << " message='" << escape( msg.str() ) << '\'' << "]\n"; + } + m_stream.flush(); + } + + void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) { + m_testTimer.start(); + StreamingReporterBase::testCaseStarting(testInfo); + m_stream << "##teamcity[testStarted name='" + << escape(testInfo.name) << "']\n"; + m_stream.flush(); + } + + void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) { + StreamingReporterBase::testCaseEnded(testCaseStats); + auto const& testCaseInfo = *testCaseStats.testInfo; + if (!testCaseStats.stdOut.empty()) + m_stream << "##teamcity[testStdOut name='" + << escape(testCaseInfo.name) + << "' out='" << escape(testCaseStats.stdOut) << "']\n"; + if (!testCaseStats.stdErr.empty()) + m_stream << "##teamcity[testStdErr name='" + << escape(testCaseInfo.name) + << "' out='" << escape(testCaseStats.stdErr) << "']\n"; + m_stream << "##teamcity[testFinished name='" + << escape(testCaseInfo.name) << "' duration='" + << m_testTimer.getElapsedMilliseconds() << "']\n"; + m_stream.flush(); + } + + void TeamCityReporter::printSectionHeader(std::ostream& os) { + assert(!m_sectionStack.empty()); + + if (m_sectionStack.size() > 1) { + os << lineOfChars('-') << '\n'; + + std::vector::const_iterator + it = m_sectionStack.begin() + 1, // Skip first section (test case) + itEnd = m_sectionStack.end(); + for (; it != itEnd; ++it) + printHeaderString(os, it->name); + os << lineOfChars('-') << '\n'; + } + + SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; + + os << lineInfo << '\n'; + os << lineOfChars('.') << "\n\n"; + } + +} // end namespace Catch + + + + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch + // Note that 4062 (not all labels are handled + // and default is missing) is enabled +#endif + +namespace Catch { + XmlReporter::XmlReporter( ReporterConfig&& _config ) + : StreamingReporterBase( CATCH_MOVE(_config) ), + m_xml(m_stream) + { + m_preferences.shouldRedirectStdOut = true; + m_preferences.shouldReportAllAssertions = true; + } + + XmlReporter::~XmlReporter() = default; + + std::string XmlReporter::getDescription() { + return "Reports test results as an XML document"; + } + + std::string XmlReporter::getStylesheetRef() const { + return std::string(); + } + + void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) { + m_xml + .writeAttribute( "filename"_sr, sourceInfo.file ) + .writeAttribute( "line"_sr, sourceInfo.line ); + } + + void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) { + StreamingReporterBase::testRunStarting( testInfo ); + std::string stylesheetRef = getStylesheetRef(); + if( !stylesheetRef.empty() ) + m_xml.writeStylesheetRef( stylesheetRef ); + m_xml.startElement("Catch2TestRun") + .writeAttribute("name"_sr, m_config->name()) + .writeAttribute("rng-seed"_sr, m_config->rngSeed()) + .writeAttribute("xml-format-version"_sr, 3) + .writeAttribute("catch2-version"_sr, libraryVersion()); + if ( m_config->testSpec().hasFilters() ) { + m_xml.writeAttribute( "filters"_sr, m_config->testSpec() ); + } + } + + void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) { + StreamingReporterBase::testCaseStarting(testInfo); + m_xml.startElement( "TestCase" ) + .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) ) + .writeAttribute( "tags"_sr, testInfo.tagsAsString() ); + + writeSourceInfo( testInfo.lineInfo ); + + if ( m_config->showDurations() == ShowDurations::Always ) + m_testCaseTimer.start(); + m_xml.ensureTagClosed(); + } + + void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) { + StreamingReporterBase::sectionStarting( sectionInfo ); + if( m_sectionDepth++ > 0 ) { + m_xml.startElement( "Section" ) + .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) ); + writeSourceInfo( sectionInfo.lineInfo ); + m_xml.ensureTagClosed(); + } + } + + void XmlReporter::assertionStarting( AssertionInfo const& ) { } + + void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) { + + AssertionResult const& result = assertionStats.assertionResult; + + bool includeResults = m_config->includeSuccessfulResults() || !result.isOk(); + + if( includeResults || result.getResultType() == ResultWas::Warning ) { + // Print any info messages in tags. + for( auto const& msg : assertionStats.infoMessages ) { + if( msg.type == ResultWas::Info && includeResults ) { + auto t = m_xml.scopedElement( "Info" ); + writeSourceInfo( msg.lineInfo ); + t.writeText( msg.message ); + } else if ( msg.type == ResultWas::Warning ) { + auto t = m_xml.scopedElement( "Warning" ); + writeSourceInfo( msg.lineInfo ); + t.writeText( msg.message ); + } + } + } + + // Drop out if result was successful but we're not printing them. + if ( !includeResults && result.getResultType() != ResultWas::Warning && + result.getResultType() != ResultWas::ExplicitSkip ) { + return; + } + + // Print the expression if there is one. + if( result.hasExpression() ) { + m_xml.startElement( "Expression" ) + .writeAttribute( "success"_sr, result.succeeded() ) + .writeAttribute( "type"_sr, result.getTestMacroName() ); + + writeSourceInfo( result.getSourceInfo() ); + + m_xml.scopedElement( "Original" ) + .writeText( result.getExpression() ); + m_xml.scopedElement( "Expanded" ) + .writeText( result.getExpandedExpression() ); + } + + // And... Print a result applicable to each result type. + switch( result.getResultType() ) { + case ResultWas::ThrewException: + m_xml.startElement( "Exception" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + case ResultWas::FatalErrorCondition: + m_xml.startElement( "FatalErrorCondition" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + case ResultWas::Info: + m_xml.scopedElement( "Info" ) + .writeText( result.getMessage() ); + break; + case ResultWas::Warning: + // Warning will already have been written + break; + case ResultWas::ExplicitFailure: + m_xml.startElement( "Failure" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + case ResultWas::ExplicitSkip: + m_xml.startElement( "Skip" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + default: + break; + } + + if( result.hasExpression() ) + m_xml.endElement(); + } + + void XmlReporter::sectionEnded( SectionStats const& sectionStats ) { + StreamingReporterBase::sectionEnded( sectionStats ); + if ( --m_sectionDepth > 0 ) { + { + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); + e.writeAttribute( "successes"_sr, sectionStats.assertions.passed ); + e.writeAttribute( "failures"_sr, sectionStats.assertions.failed ); + e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk ); + e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds ); + } + // Ends assertion tag + m_xml.endElement(); + } + } + + void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { + StreamingReporterBase::testCaseEnded( testCaseStats ); + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); + e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() ); + e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() ); + if( !testCaseStats.stdOut.empty() ) + m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline ); + if( !testCaseStats.stdErr.empty() ) + m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline ); + + m_xml.endElement(); + } + + void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) { + StreamingReporterBase::testRunEnded( testRunStats ); + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed ) + .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed ) + .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk ) + .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped ); + m_xml.scopedElement( "OverallResultsCases") + .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed ) + .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed ) + .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk ) + .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped ); + m_xml.endElement(); + } + + void XmlReporter::benchmarkPreparing( StringRef name ) { + m_xml.startElement("BenchmarkResults") + .writeAttribute("name"_sr, name); + } + + void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) { + m_xml.writeAttribute("samples"_sr, info.samples) + .writeAttribute("resamples"_sr, info.resamples) + .writeAttribute("iterations"_sr, info.iterations) + .writeAttribute("clockResolution"_sr, info.clockResolution) + .writeAttribute("estimatedDuration"_sr, info.estimatedDuration) + .writeComment("All values in nano seconds"_sr); + } + + void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) { + m_xml.scopedElement("mean") + .writeAttribute("value"_sr, benchmarkStats.mean.point.count()) + .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count()) + .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count()) + .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval); + m_xml.scopedElement("standardDeviation") + .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count()) + .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count()) + .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count()) + .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval); + m_xml.scopedElement("outliers") + .writeAttribute("variance"_sr, benchmarkStats.outlierVariance) + .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild) + .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe) + .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild) + .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe); + m_xml.endElement(); + } + + void XmlReporter::benchmarkFailed(StringRef error) { + m_xml.scopedElement("failed"). + writeAttribute("message"_sr, error); + m_xml.endElement(); + } + + void XmlReporter::listReporters(std::vector const& descriptions) { + auto outerTag = m_xml.scopedElement("AvailableReporters"); + for (auto const& reporter : descriptions) { + auto inner = m_xml.scopedElement("Reporter"); + m_xml.startElement("Name", XmlFormatting::Indent) + .writeText(reporter.name, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + m_xml.startElement("Description", XmlFormatting::Indent) + .writeText(reporter.description, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + } + } + + void XmlReporter::listListeners(std::vector const& descriptions) { + auto outerTag = m_xml.scopedElement( "RegisteredListeners" ); + for ( auto const& listener : descriptions ) { + auto inner = m_xml.scopedElement( "Listener" ); + m_xml.startElement( "Name", XmlFormatting::Indent ) + .writeText( listener.name, XmlFormatting::None ) + .endElement( XmlFormatting::Newline ); + m_xml.startElement( "Description", XmlFormatting::Indent ) + .writeText( listener.description, XmlFormatting::None ) + .endElement( XmlFormatting::Newline ); + } + } + + void XmlReporter::listTests(std::vector const& tests) { + auto outerTag = m_xml.scopedElement("MatchingTests"); + for (auto const& test : tests) { + auto innerTag = m_xml.scopedElement("TestCase"); + auto const& testInfo = test.getTestCaseInfo(); + m_xml.startElement("Name", XmlFormatting::Indent) + .writeText(testInfo.name, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + m_xml.startElement("ClassName", XmlFormatting::Indent) + .writeText(testInfo.className, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + m_xml.startElement("Tags", XmlFormatting::Indent) + .writeText(testInfo.tagsAsString(), XmlFormatting::None) + .endElement(XmlFormatting::Newline); + + auto sourceTag = m_xml.scopedElement("SourceInfo"); + m_xml.startElement("File", XmlFormatting::Indent) + .writeText(testInfo.lineInfo.file, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + m_xml.startElement("Line", XmlFormatting::Indent) + .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None) + .endElement(XmlFormatting::Newline); + } + } + + void XmlReporter::listTags(std::vector const& tags) { + auto outerTag = m_xml.scopedElement("TagsFromMatchingTests"); + for (auto const& tag : tags) { + auto innerTag = m_xml.scopedElement("Tag"); + m_xml.startElement("Count", XmlFormatting::Indent) + .writeText(std::to_string(tag.count), XmlFormatting::None) + .endElement(XmlFormatting::Newline); + auto aliasTag = m_xml.scopedElement("Aliases"); + for (auto const& alias : tag.spellings) { + m_xml.startElement("Alias", XmlFormatting::Indent) + .writeText(alias, XmlFormatting::None) + .endElement(XmlFormatting::Newline); + } + } + } + +} // end namespace Catch + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif diff --git a/windows/NativeShell/tests/catch_amalgamated.hpp b/windows/NativeShell/tests/catch_amalgamated.hpp new file mode 100644 index 0000000..b7c768b --- /dev/null +++ b/windows/NativeShell/tests/catch_amalgamated.hpp @@ -0,0 +1,14106 @@ + +// Copyright Catch2 Authors +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.txt or copy at +// https://www.boost.org/LICENSE_1_0.txt) + +// SPDX-License-Identifier: BSL-1.0 + +// Catch v3.7.1 +// Generated: 2024-09-17 10:36:40.974985 +// ---------------------------------------------------------- +// This file is an amalgamation of multiple different files. +// You probably shouldn't edit it directly. +// ---------------------------------------------------------- +#ifndef CATCH_AMALGAMATED_HPP_INCLUDED +#define CATCH_AMALGAMATED_HPP_INCLUDED + + +/** \file + * This is a convenience header for Catch2. It includes **all** of Catch2 headers. + * + * Generally the Catch2 users should use specific includes they need, + * but this header can be used instead for ease-of-experimentation, or + * just plain convenience, at the cost of (significantly) increased + * compilation times. + * + * When a new header is added to either the top level folder, or to the + * corresponding internal subfolder, it should be added here. Headers + * added to the various subparts (e.g. matchers, generators, etc...), + * should go their respective catch-all headers. + */ + +#ifndef CATCH_ALL_HPP_INCLUDED +#define CATCH_ALL_HPP_INCLUDED + + + +/** \file + * This is a convenience header for Catch2's benchmarking. It includes + * **all** of Catch2 headers related to benchmarking. + * + * Generally the Catch2 users should use specific includes they need, + * but this header can be used instead for ease-of-experimentation, or + * just plain convenience, at the cost of (significantly) increased + * compilation times. + * + * When a new header is added to either the `benchmark` folder, or to + * the corresponding internal (detail) subfolder, it should be added here. + */ + +#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED +#define CATCH_BENCHMARK_ALL_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_BENCHMARK_HPP_INCLUDED +#define CATCH_BENCHMARK_HPP_INCLUDED + + + +#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED +#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED + +// Detect a number of compiler features - by compiler +// The following features are defined: +// +// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? +// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? +// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? +// **************** +// Note to maintainers: if new toggles are added please document them +// in configuration.md, too +// **************** + +// In general each macro has a _NO_ form +// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. +// Many features, at point of detection, define an _INTERNAL_ macro, so they +// can be combined, en-mass, with the _NO_ forms later. + + + +#ifndef CATCH_PLATFORM_HPP_INCLUDED +#define CATCH_PLATFORM_HPP_INCLUDED + +// See e.g.: +// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html +#ifdef __APPLE__ +# ifndef __has_extension +# define __has_extension(x) 0 +# endif +# include +# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ + (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) +# define CATCH_PLATFORM_MAC +# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) +# define CATCH_PLATFORM_IPHONE +# endif + +#elif defined(linux) || defined(__linux) || defined(__linux__) +# define CATCH_PLATFORM_LINUX + +#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) +# define CATCH_PLATFORM_WINDOWS + +# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP ) +# define CATCH_PLATFORM_WINDOWS_UWP +# endif + +#elif defined(__ORBIS__) || defined(__PROSPERO__) +# define CATCH_PLATFORM_PLAYSTATION + +#endif + +#endif // CATCH_PLATFORM_HPP_INCLUDED + +#ifdef __cplusplus + +# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +# define CATCH_CPP17_OR_GREATER +# endif + +# if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) +# define CATCH_CPP20_OR_GREATER +# endif + +#endif + +// Only GCC compiler should be used in this block, so other compilers trying to +// mask themselves as GCC should be ignored. +#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) + +// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses +// for older versions of GCC. +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \ + _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" ) + +# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \ + _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" ) + +# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \ + _Pragma( "GCC diagnostic ignored \"-Wshadow\"" ) + +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) + +#endif + +#if defined(__NVCOMPILER) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" ) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" ) +#endif + +#if defined(__CUDACC__) && !defined(__clang__) +# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__ +// New pragmas introduced in CUDA 11.5+ +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" ) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" ) +# else +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" ) +# endif +#endif + +// clang-cl defines _MSC_VER as well as __clang__, which could cause the +// start/stop internal suppression macros to be double defined. +#if defined(__clang__) && !defined(_MSC_VER) + +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) + +#endif // __clang__ && !_MSC_VER + +#if defined(__clang__) + +// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug +// which results in calls to destructors being emitted for each temporary, +// without a matching initialization. In practice, this can result in something +// like `std::string::~string` being called on an uninitialized value. +// +// For example, this code will likely segfault under IBM XL: +// ``` +// REQUIRE(std::string("12") + "34" == "1234") +// ``` +// +// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which +// results in calls to the immediately evaluated lambda expressions to be +// reported as unevaluated lambdas. +// https://developer.nvidia.com/nvidia_bug/3321845. +// +// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. +# if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER ) +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ +# endif + + +# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ + _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") + +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) + +# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) + +# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wcomma\"" ) + +# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wshadow\"" ) + +#endif // __clang__ + + +//////////////////////////////////////////////////////////////////////////////// +// We know some environments not to support full POSIX signals +#if defined( CATCH_PLATFORM_WINDOWS ) || \ + defined( CATCH_PLATFORM_PLAYSTATION ) || \ + defined( __CYGWIN__ ) || \ + defined( __QNX__ ) || \ + defined( __EMSCRIPTEN__ ) || \ + defined( __DJGPP__ ) || \ + defined( __OS400__ ) +# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +#else +# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Assume that some platforms do not support getenv. +#if defined( CATCH_PLATFORM_WINDOWS_UWP ) || \ + defined( CATCH_PLATFORM_PLAYSTATION ) || \ + defined( _GAMING_XBOX ) +# define CATCH_INTERNAL_CONFIG_NO_GETENV +#else +# define CATCH_INTERNAL_CONFIG_GETENV +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Android somehow still does not support std::to_string +#if defined(__ANDROID__) +# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Not all Windows environments support SEH properly +#if defined(__MINGW32__) +# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH +#endif + +//////////////////////////////////////////////////////////////////////////////// +// PS4 +#if defined(__ORBIS__) +# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Cygwin +#ifdef __CYGWIN__ + +// Required for some versions of Cygwin to declare gettimeofday +// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin +# define _BSD_SOURCE +// some versions of cygwin (most) do not support std::to_string. Use the libstd check. +// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 +# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ + && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) + +# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING + +# endif +#endif // __CYGWIN__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#if defined(_MSC_VER) + +// We want to defer to nvcc-specific warning suppression if we are compiled +// with nvcc masquerading for MSVC. +# if !defined( __CUDACC__ ) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + __pragma( warning( push ) ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + __pragma( warning( pop ) ) +# endif + +// Universal Windows platform does not support SEH +// Or console colours (or console at all...) +# if defined(CATCH_PLATFORM_WINDOWS_UWP) +# define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 +# else +# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH +# endif + +// MSVC traditional preprocessor needs some workaround for __VA_ARGS__ +// _MSVC_TRADITIONAL == 0 means new conformant preprocessor +// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor +# if !defined(__clang__) // Handle Clang masquerading for msvc +# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) +# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +# endif // MSVC_TRADITIONAL +# endif // __clang__ + +#endif // _MSC_VER + +#if defined(_REENTRANT) || defined(_MSC_VER) +// Enable async processing, as -pthread is specified or no additional linking is required +# define CATCH_INTERNAL_CONFIG_USE_ASYNC +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// +// Check if we are compiled with -fno-exceptions or equivalent +#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) +# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED +#endif + + +//////////////////////////////////////////////////////////////////////////////// +// Embarcadero C++Build +#if defined(__BORLANDC__) + #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN +#endif + +//////////////////////////////////////////////////////////////////////////////// + +// RTX is a special version of Windows that is real time. +// This means that it is detected as Windows, but does not provide +// the same set of capabilities as real Windows does. +#if defined(UNDER_RTSS) || defined(RTX64_BUILD) + #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH + #define CATCH_INTERNAL_CONFIG_NO_ASYNC + #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 +#endif + +#if !defined(_GLIBCXX_USE_C99_MATH_TR1) +#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER +#endif + +// Various stdlib support checks that require __has_include +#if defined(__has_include) + // Check if string_view is available and usable + #if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW + #endif + + // Check if optional is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) + + // Check if byte is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # include + # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) + # define CATCH_INTERNAL_CONFIG_CPP17_BYTE + # endif + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) + + // Check if variant is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # if defined(__clang__) && (__clang_major__ < 8) + // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 + // fix should be in clang 8, workaround in libstdc++ 8.2 + # include + # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) + # define CATCH_CONFIG_NO_CPP17_VARIANT + # else + # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT + # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) + # else + # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT + # endif // defined(__clang__) && (__clang_major__ < 8) + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) +#endif // defined(__has_include) + + +#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) +# define CATCH_CONFIG_WINDOWS_SEH +#endif +// This is set by default, because we assume that unix compilers are posix-signal-compatible by default. +#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +# define CATCH_CONFIG_POSIX_SIGNALS +#endif + +#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV) +# define CATCH_CONFIG_GETENV +#endif + +#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) +# define CATCH_CONFIG_CPP11_TO_STRING +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) +# define CATCH_CONFIG_CPP17_OPTIONAL +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) +# define CATCH_CONFIG_CPP17_STRING_VIEW +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) +# define CATCH_CONFIG_CPP17_VARIANT +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) +# define CATCH_CONFIG_CPP17_BYTE +#endif + + +#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) +# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE +#endif + +#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) +# define CATCH_CONFIG_NEW_CAPTURE +#endif + +#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \ + !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) && \ + !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS ) +# define CATCH_CONFIG_DISABLE_EXCEPTIONS +#endif + +#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) +# define CATCH_CONFIG_POLYFILL_ISNAN +#endif + +#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) +# define CATCH_CONFIG_USE_ASYNC +#endif + +#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) +# define CATCH_CONFIG_GLOBAL_NEXTAFTER +#endif + + +// Even if we do not think the compiler has that warning, we still have +// to provide a macro that can be used by the code. +#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION +#endif +#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS +#endif +#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS ) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#endif +#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS ) +# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS +#endif +#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS ) +# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS +#endif + + +// The goal of this macro is to avoid evaluation of the arguments, but +// still have the compiler warn on problems inside... +#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) +#endif + +#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#elif defined(__clang__) && (__clang_major__ < 5) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#endif + + +#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +#define CATCH_TRY if ((true)) +#define CATCH_CATCH_ALL if ((false)) +#define CATCH_CATCH_ANON(type) if ((false)) +#else +#define CATCH_TRY try +#define CATCH_CATCH_ALL catch (...) +#define CATCH_CATCH_ANON(type) catch (type) +#endif + +#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) +#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#endif + +#if defined( CATCH_PLATFORM_WINDOWS ) && \ + !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \ + !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \ + !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 ) +# define CATCH_CONFIG_COLOUR_WIN32 +#endif + +#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \ + !defined( CATCH_CONFIG_STATIC ) +# ifdef Catch2_EXPORTS +# define CATCH_EXPORT //__declspec( dllexport ) // not needed +# else +# define CATCH_EXPORT __declspec( dllimport ) +# endif +#else +# define CATCH_EXPORT +#endif + +#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED + + +#ifndef CATCH_CONTEXT_HPP_INCLUDED +#define CATCH_CONTEXT_HPP_INCLUDED + + +namespace Catch { + + class IResultCapture; + class IConfig; + + class Context { + IConfig const* m_config = nullptr; + IResultCapture* m_resultCapture = nullptr; + + CATCH_EXPORT static Context* currentContext; + friend Context& getCurrentMutableContext(); + friend Context const& getCurrentContext(); + static void createContext(); + friend void cleanUpContext(); + + public: + constexpr IResultCapture* getResultCapture() const { + return m_resultCapture; + } + constexpr IConfig const* getConfig() const { return m_config; } + constexpr void setResultCapture( IResultCapture* resultCapture ) { + m_resultCapture = resultCapture; + } + constexpr void setConfig( IConfig const* config ) { m_config = config; } + + }; + + Context& getCurrentMutableContext(); + + inline Context const& getCurrentContext() { + // We duplicate the logic from `getCurrentMutableContext` here, + // to avoid paying the call overhead in debug mode. + if ( !Context::currentContext ) { Context::createContext(); } + // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn) + return *Context::currentContext; + } + + void cleanUpContext(); + + class SimplePcg32; + SimplePcg32& sharedRng(); +} + +#endif // CATCH_CONTEXT_HPP_INCLUDED + + +#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED +#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED + +#include + +//! Replacement for std::move with better compile time performance +#define CATCH_MOVE(...) static_cast&&>(__VA_ARGS__) + +//! Replacement for std::forward with better compile time performance +#define CATCH_FORWARD(...) static_cast(__VA_ARGS__) + +#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED + + +#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED +#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED + +namespace Catch { + + //! Used to signal that an assertion macro failed + struct TestFailureException{}; + //! Used to signal that the remainder of a test should be skipped + struct TestSkipException {}; + + /** + * Outlines throwing of `TestFailureException` into a single TU + * + * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers. + */ + [[noreturn]] void throw_test_failure_exception(); + + /** + * Outlines throwing of `TestSkipException` into a single TU + * + * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers. + */ + [[noreturn]] void throw_test_skip_exception(); + +} // namespace Catch + +#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED + + +#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED +#define CATCH_UNIQUE_NAME_HPP_INCLUDED + + + + +/** \file + * Wrapper for the CONFIG configuration option + * + * When generating internal unique names, there are two options. Either + * we mix in the current line number, or mix in an incrementing number. + * We prefer the latter, using `__COUNTER__`, but users might want to + * use the former. + */ + +#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED +#define CATCH_CONFIG_COUNTER_HPP_INCLUDED + + +#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) + #define CATCH_INTERNAL_CONFIG_COUNTER +#endif + +#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \ + !defined( CATCH_CONFIG_NO_COUNTER ) && \ + !defined( CATCH_CONFIG_COUNTER ) +# define CATCH_CONFIG_COUNTER +#endif + + +#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED +#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line +#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) +#ifdef CATCH_CONFIG_COUNTER +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) +#else +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) +#endif + +#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED + + +#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED +#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED + +#include + + + +#ifndef CATCH_STRINGREF_HPP_INCLUDED +#define CATCH_STRINGREF_HPP_INCLUDED + +#include +#include +#include +#include + +#include + +namespace Catch { + + /// A non-owning string class (similar to the forthcoming std::string_view) + /// Note that, because a StringRef may be a substring of another string, + /// it may not be null terminated. + class StringRef { + public: + using size_type = std::size_t; + using const_iterator = const char*; + + static constexpr size_type npos{ static_cast( -1 ) }; + + private: + static constexpr char const* const s_empty = ""; + + char const* m_start = s_empty; + size_type m_size = 0; + + public: // construction + constexpr StringRef() noexcept = default; + + StringRef( char const* rawChars ) noexcept; + + constexpr StringRef( char const* rawChars, size_type size ) noexcept + : m_start( rawChars ), + m_size( size ) + {} + + StringRef( std::string const& stdString ) noexcept + : m_start( stdString.c_str() ), + m_size( stdString.size() ) + {} + + explicit operator std::string() const { + return std::string(m_start, m_size); + } + + public: // operators + auto operator == ( StringRef other ) const noexcept -> bool { + return m_size == other.m_size + && (std::memcmp( m_start, other.m_start, m_size ) == 0); + } + auto operator != (StringRef other) const noexcept -> bool { + return !(*this == other); + } + + constexpr auto operator[] ( size_type index ) const noexcept -> char { + assert(index < m_size); + return m_start[index]; + } + + bool operator<(StringRef rhs) const noexcept; + + public: // named queries + constexpr auto empty() const noexcept -> bool { + return m_size == 0; + } + constexpr auto size() const noexcept -> size_type { + return m_size; + } + + // Returns a substring of [start, start + length). + // If start + length > size(), then the substring is [start, size()). + // If start > size(), then the substring is empty. + constexpr StringRef substr(size_type start, size_type length) const noexcept { + if (start < m_size) { + const auto shortened_size = m_size - start; + return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length); + } else { + return StringRef(); + } + } + + // Returns the current start pointer. May not be null-terminated. + constexpr char const* data() const noexcept { + return m_start; + } + + constexpr const_iterator begin() const { return m_start; } + constexpr const_iterator end() const { return m_start + m_size; } + + + friend std::string& operator += (std::string& lhs, StringRef rhs); + friend std::ostream& operator << (std::ostream& os, StringRef str); + friend std::string operator+(StringRef lhs, StringRef rhs); + + /** + * Provides a three-way comparison with rhs + * + * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive + * number if lhs > rhs + */ + int compare( StringRef rhs ) const; + }; + + + constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { + return StringRef( rawChars, size ); + } +} // namespace Catch + +constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { + return Catch::StringRef( rawChars, size ); +} + +#endif // CATCH_STRINGREF_HPP_INCLUDED + + +#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED +#define CATCH_RESULT_TYPE_HPP_INCLUDED + +namespace Catch { + + // ResultWas::OfType enum + struct ResultWas { enum OfType { + Unknown = -1, + Ok = 0, + Info = 1, + Warning = 2, + // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit? + ExplicitSkip = 4, + + FailureBit = 0x10, + + ExpressionFailed = FailureBit | 1, + ExplicitFailure = FailureBit | 2, + + Exception = 0x100 | FailureBit, + + ThrewException = Exception | 1, + DidntThrowException = Exception | 2, + + FatalErrorCondition = 0x200 | FailureBit + + }; }; + + constexpr bool isOk( ResultWas::OfType resultType ) { + return ( resultType & ResultWas::FailureBit ) == 0; + } + constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; } + + + // ResultDisposition::Flags enum + struct ResultDisposition { enum Flags { + Normal = 0x01, + + ContinueOnFailure = 0x02, // Failures fail test, but execution continues + FalseTest = 0x04, // Prefix expression with ! + SuppressFail = 0x08 // Failures are reported but do not fail the test + }; }; + + constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs, + ResultDisposition::Flags rhs ) { + return static_cast( static_cast( lhs ) | + static_cast( rhs ) ); + } + + constexpr bool isFalseTest( int flags ) { + return ( flags & ResultDisposition::FalseTest ) != 0; + } + constexpr bool shouldSuppressFailure( int flags ) { + return ( flags & ResultDisposition::SuppressFail ) != 0; + } + +} // end namespace Catch + +#endif // CATCH_RESULT_TYPE_HPP_INCLUDED + + +#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED +#define CATCH_UNIQUE_PTR_HPP_INCLUDED + +#include +#include + + +namespace Catch { +namespace Detail { + /** + * A reimplementation of `std::unique_ptr` for improved compilation performance + * + * Does not support arrays nor custom deleters. + */ + template + class unique_ptr { + T* m_ptr; + public: + constexpr unique_ptr(std::nullptr_t = nullptr): + m_ptr{} + {} + explicit constexpr unique_ptr(T* ptr): + m_ptr(ptr) + {} + + template ::value>> + unique_ptr(unique_ptr&& from): + m_ptr(from.release()) + {} + + template ::value>> + unique_ptr& operator=(unique_ptr&& from) { + reset(from.release()); + + return *this; + } + + unique_ptr(unique_ptr const&) = delete; + unique_ptr& operator=(unique_ptr const&) = delete; + + unique_ptr(unique_ptr&& rhs) noexcept: + m_ptr(rhs.m_ptr) { + rhs.m_ptr = nullptr; + } + unique_ptr& operator=(unique_ptr&& rhs) noexcept { + reset(rhs.release()); + + return *this; + } + + ~unique_ptr() { + delete m_ptr; + } + + T& operator*() { + assert(m_ptr); + return *m_ptr; + } + T const& operator*() const { + assert(m_ptr); + return *m_ptr; + } + T* operator->() noexcept { + assert(m_ptr); + return m_ptr; + } + T const* operator->() const noexcept { + assert(m_ptr); + return m_ptr; + } + + T* get() { return m_ptr; } + T const* get() const { return m_ptr; } + + void reset(T* ptr = nullptr) { + delete m_ptr; + m_ptr = ptr; + } + + T* release() { + auto temp = m_ptr; + m_ptr = nullptr; + return temp; + } + + explicit operator bool() const { + return m_ptr; + } + + friend void swap(unique_ptr& lhs, unique_ptr& rhs) { + auto temp = lhs.m_ptr; + lhs.m_ptr = rhs.m_ptr; + rhs.m_ptr = temp; + } + }; + + //! Specialization to cause compile-time error for arrays + template + class unique_ptr; + + template + unique_ptr make_unique(Args&&... args) { + return unique_ptr(new T(CATCH_FORWARD(args)...)); + } + + +} // end namespace Detail +} // end namespace Catch + +#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED + + +#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED +#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_CLOCK_HPP_INCLUDED +#define CATCH_CLOCK_HPP_INCLUDED + +#include + +namespace Catch { + namespace Benchmark { + using IDuration = std::chrono::nanoseconds; + using FDuration = std::chrono::duration; + + template + using TimePoint = typename Clock::time_point; + + using default_clock = std::chrono::steady_clock; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_CLOCK_HPP_INCLUDED + +namespace Catch { + + // We cannot forward declare the type with default template argument + // multiple times, so it is split out into a separate header so that + // we can prevent multiple declarations in dependees + template + struct BenchmarkStats; + +} // end namespace Catch + +#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED + +namespace Catch { + + class AssertionResult; + struct AssertionInfo; + struct SectionInfo; + struct SectionEndInfo; + struct MessageInfo; + struct MessageBuilder; + struct Counts; + struct AssertionReaction; + struct SourceLineInfo; + + class ITransientExpression; + class IGeneratorTracker; + + struct BenchmarkInfo; + + namespace Generators { + class GeneratorUntypedBase; + using GeneratorBasePtr = Catch::Detail::unique_ptr; + } + + + class IResultCapture { + public: + virtual ~IResultCapture(); + + virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0; + virtual bool sectionStarted( StringRef sectionName, + SourceLineInfo const& sectionLineInfo, + Counts& assertions ) = 0; + virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0; + virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0; + + virtual IGeneratorTracker* + acquireGeneratorTracker( StringRef generatorName, + SourceLineInfo const& lineInfo ) = 0; + virtual IGeneratorTracker* + createGeneratorTracker( StringRef generatorName, + SourceLineInfo lineInfo, + Generators::GeneratorBasePtr&& generator ) = 0; + + virtual void benchmarkPreparing( StringRef name ) = 0; + virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0; + virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0; + virtual void benchmarkFailed( StringRef error ) = 0; + + virtual void pushScopedMessage( MessageInfo const& message ) = 0; + virtual void popScopedMessage( MessageInfo const& message ) = 0; + + virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0; + + virtual void handleFatalErrorCondition( StringRef message ) = 0; + + virtual void handleExpr + ( AssertionInfo const& info, + ITransientExpression const& expr, + AssertionReaction& reaction ) = 0; + virtual void handleMessage + ( AssertionInfo const& info, + ResultWas::OfType resultType, + std::string&& message, + AssertionReaction& reaction ) = 0; + virtual void handleUnexpectedExceptionNotThrown + ( AssertionInfo const& info, + AssertionReaction& reaction ) = 0; + virtual void handleUnexpectedInflightException + ( AssertionInfo const& info, + std::string&& message, + AssertionReaction& reaction ) = 0; + virtual void handleIncomplete + ( AssertionInfo const& info ) = 0; + virtual void handleNonExpr + ( AssertionInfo const &info, + ResultWas::OfType resultType, + AssertionReaction &reaction ) = 0; + + + + virtual bool lastAssertionPassed() = 0; + virtual void assertionPassed() = 0; + + // Deprecated, do not use: + virtual std::string getCurrentTestName() const = 0; + virtual const AssertionResult* getLastResult() const = 0; + virtual void exceptionEarlyReported() = 0; + }; + + IResultCapture& getResultCapture(); +} + +#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED + + +#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED +#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED + + + +#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED +#define CATCH_NONCOPYABLE_HPP_INCLUDED + +namespace Catch { + namespace Detail { + + //! Deriving classes become noncopyable and nonmovable + class NonCopyable { + NonCopyable( NonCopyable const& ) = delete; + NonCopyable( NonCopyable&& ) = delete; + NonCopyable& operator=( NonCopyable const& ) = delete; + NonCopyable& operator=( NonCopyable&& ) = delete; + + protected: + NonCopyable() noexcept = default; + }; + + } // namespace Detail +} // namespace Catch + +#endif // CATCH_NONCOPYABLE_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + enum class Verbosity { + Quiet = 0, + Normal, + High + }; + + struct WarnAbout { enum What { + Nothing = 0x00, + //! A test case or leaf section did not run any assertions + NoAssertions = 0x01, + //! A command line test spec matched no test cases + UnmatchedTestSpec = 0x02, + }; }; + + enum class ShowDurations { + DefaultForReporter, + Always, + Never + }; + enum class TestRunOrder { + Declared, + LexicographicallySorted, + Randomized + }; + enum class ColourMode : std::uint8_t { + //! Let Catch2 pick implementation based on platform detection + PlatformDefault, + //! Use ANSI colour code escapes + ANSI, + //! Use Win32 console colour API + Win32, + //! Don't use any colour + None + }; + struct WaitForKeypress { enum When { + Never, + BeforeStart = 1, + BeforeExit = 2, + BeforeStartAndExit = BeforeStart | BeforeExit + }; }; + + class TestSpec; + class IStream; + + class IConfig : public Detail::NonCopyable { + public: + virtual ~IConfig(); + + virtual bool allowThrows() const = 0; + virtual StringRef name() const = 0; + virtual bool includeSuccessfulResults() const = 0; + virtual bool shouldDebugBreak() const = 0; + virtual bool warnAboutMissingAssertions() const = 0; + virtual bool warnAboutUnmatchedTestSpecs() const = 0; + virtual bool zeroTestsCountAsSuccess() const = 0; + virtual int abortAfter() const = 0; + virtual bool showInvisibles() const = 0; + virtual ShowDurations showDurations() const = 0; + virtual double minDuration() const = 0; + virtual TestSpec const& testSpec() const = 0; + virtual bool hasTestFilters() const = 0; + virtual std::vector const& getTestsOrTags() const = 0; + virtual TestRunOrder runOrder() const = 0; + virtual uint32_t rngSeed() const = 0; + virtual unsigned int shardCount() const = 0; + virtual unsigned int shardIndex() const = 0; + virtual ColourMode defaultColourMode() const = 0; + virtual std::vector const& getSectionsToRun() const = 0; + virtual Verbosity verbosity() const = 0; + + virtual bool skipBenchmarks() const = 0; + virtual bool benchmarkNoAnalysis() const = 0; + virtual unsigned int benchmarkSamples() const = 0; + virtual double benchmarkConfidenceInterval() const = 0; + virtual unsigned int benchmarkResamples() const = 0; + virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0; + }; +} + +#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED + + +#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED +#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED + + +#include + +namespace Catch { + + class TestCaseHandle; + struct TestCaseInfo; + class ITestCaseRegistry; + class IExceptionTranslatorRegistry; + class IExceptionTranslator; + class ReporterRegistry; + class IReporterFactory; + class ITagAliasRegistry; + class ITestInvoker; + class IMutableEnumValuesRegistry; + struct SourceLineInfo; + + class StartupExceptionRegistry; + class EventListenerFactory; + + using IReporterFactoryPtr = Detail::unique_ptr; + + class IRegistryHub { + public: + virtual ~IRegistryHub(); // = default + + virtual ReporterRegistry const& getReporterRegistry() const = 0; + virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; + virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0; + virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0; + + + virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0; + }; + + class IMutableRegistryHub { + public: + virtual ~IMutableRegistryHub(); // = default + virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0; + virtual void registerListener( Detail::unique_ptr factory ) = 0; + virtual void registerTest(Detail::unique_ptr&& testInfo, Detail::unique_ptr&& invoker) = 0; + virtual void registerTranslator( Detail::unique_ptr&& translator ) = 0; + virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0; + virtual void registerStartupException() noexcept = 0; + virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0; + }; + + IRegistryHub const& getRegistryHub(); + IMutableRegistryHub& getMutableRegistryHub(); + void cleanUp(); + std::string translateActiveException(); + +} + +#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED + + +#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED +#define CATCH_BENCHMARK_STATS_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_ESTIMATE_HPP_INCLUDED +#define CATCH_ESTIMATE_HPP_INCLUDED + +namespace Catch { + namespace Benchmark { + template + struct Estimate { + Type point; + Type lower_bound; + Type upper_bound; + double confidence_interval; + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_ESTIMATE_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED +#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED + +namespace Catch { + namespace Benchmark { + struct OutlierClassification { + int samples_seen = 0; + int low_severe = 0; // more than 3 times IQR below Q1 + int low_mild = 0; // 1.5 to 3 times IQR below Q1 + int high_mild = 0; // 1.5 to 3 times IQR above Q3 + int high_severe = 0; // more than 3 times IQR above Q3 + + constexpr int total() const { + return low_severe + low_mild + high_mild + high_severe; + } + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED +// The fwd decl & default specialization needs to be seen by VS2017 before +// BenchmarkStats itself, or VS2017 will report compilation error. + +#include +#include + +namespace Catch { + + struct BenchmarkInfo { + std::string name; + double estimatedDuration; + int iterations; + unsigned int samples; + unsigned int resamples; + double clockResolution; + double clockCost; + }; + + // We need to keep template parameter for backwards compatibility, + // but we also do not want to use the template paraneter. + template + struct BenchmarkStats { + BenchmarkInfo info; + + std::vector samples; + Benchmark::Estimate mean; + Benchmark::Estimate standardDeviation; + Benchmark::OutlierClassification outliers; + double outlierVariance; + }; + + +} // end namespace Catch + +#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED +#define CATCH_ENVIRONMENT_HPP_INCLUDED + + +namespace Catch { + namespace Benchmark { + struct EnvironmentEstimate { + FDuration mean; + OutlierClassification outliers; + }; + struct Environment { + EnvironmentEstimate clock_resolution; + EnvironmentEstimate clock_cost; + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_ENVIRONMENT_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED +#define CATCH_EXECUTION_PLAN_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED +#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_CHRONOMETER_HPP_INCLUDED +#define CATCH_CHRONOMETER_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_OPTIMIZER_HPP_INCLUDED +#define CATCH_OPTIMIZER_HPP_INCLUDED + +#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__) +# include // atomic_thread_fence +#endif + + +#include + +namespace Catch { + namespace Benchmark { +#if defined(__GNUC__) || defined(__clang__) + template + inline void keep_memory(T* p) { + asm volatile("" : : "g"(p) : "memory"); + } + inline void keep_memory() { + asm volatile("" : : : "memory"); + } + + namespace Detail { + inline void optimizer_barrier() { keep_memory(); } + } // namespace Detail +#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__) + +#if defined(_MSVC_VER) +#pragma optimize("", off) +#elif defined(__IAR_SYSTEMS_ICC__) +// For IAR the pragma only affects the following function +#pragma optimize=disable +#endif + template + inline void keep_memory(T* p) { + // thanks @milleniumbug + *reinterpret_cast(p) = *reinterpret_cast(p); + } + // TODO equivalent keep_memory() +#if defined(_MSVC_VER) +#pragma optimize("", on) +#endif + + namespace Detail { + inline void optimizer_barrier() { + std::atomic_thread_fence(std::memory_order_seq_cst); + } + } // namespace Detail + +#endif + + template + inline void deoptimize_value(T&& x) { + keep_memory(&x); + } + + template + inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t::value> { + deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...)); + } + + template + inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t::value> { + CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...); + } + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_OPTIMIZER_HPP_INCLUDED + + +#ifndef CATCH_META_HPP_INCLUDED +#define CATCH_META_HPP_INCLUDED + +#include + +namespace Catch { + template + struct true_given : std::true_type {}; + + struct is_callable_tester { + template + static true_given()(std::declval()...))> test(int); + template + static std::false_type test(...); + }; + + template + struct is_callable; + + template + struct is_callable : decltype(is_callable_tester::test(0)) {}; + + +#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703 + // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is + // replaced with std::invoke_result here. + template + using FunctionReturnType = std::remove_reference_t>>; +#else + template + using FunctionReturnType = std::remove_reference_t>>; +#endif + +} // namespace Catch + +namespace mpl_{ + struct na; +} + +#endif // CATCH_META_HPP_INCLUDED + +namespace Catch { + namespace Benchmark { + namespace Detail { + struct ChronometerConcept { + virtual void start() = 0; + virtual void finish() = 0; + virtual ~ChronometerConcept(); // = default; + + ChronometerConcept() = default; + ChronometerConcept(ChronometerConcept const&) = default; + ChronometerConcept& operator=(ChronometerConcept const&) = default; + }; + template + struct ChronometerModel final : public ChronometerConcept { + void start() override { started = Clock::now(); } + void finish() override { finished = Clock::now(); } + + IDuration elapsed() const { + return std::chrono::duration_cast( + finished - started ); + } + + TimePoint started; + TimePoint finished; + }; + } // namespace Detail + + struct Chronometer { + public: + template + void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable()); } + + int runs() const { return repeats; } + + Chronometer(Detail::ChronometerConcept& meter, int repeats_) + : impl(&meter) + , repeats(repeats_) {} + + private: + template + void measure(Fun&& fun, std::false_type) { + measure([&fun](int) { return fun(); }, std::true_type()); + } + + template + void measure(Fun&& fun, std::true_type) { + Detail::optimizer_barrier(); + impl->start(); + for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i); + impl->finish(); + Detail::optimizer_barrier(); + } + + Detail::ChronometerConcept* impl; + int repeats; + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_CHRONOMETER_HPP_INCLUDED + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + struct is_related + : std::is_same, std::decay_t> {}; + + /// We need to reinvent std::function because every piece of code that might add overhead + /// in a measurement context needs to have consistent performance characteristics so that we + /// can account for it in the measurement. + /// Implementations of std::function with optimizations that aren't always applicable, like + /// small buffer optimizations, are not uncommon. + /// This is effectively an implementation of std::function without any such optimizations; + /// it may be slow, but it is consistently slow. + struct BenchmarkFunction { + private: + struct callable { + virtual void call(Chronometer meter) const = 0; + virtual ~callable(); // = default; + + callable() = default; + callable(callable&&) = default; + callable& operator=(callable&&) = default; + }; + template + struct model : public callable { + model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {} + model(Fun const& fun_) : fun(fun_) {} + + void call(Chronometer meter) const override { + call(meter, is_callable()); + } + void call(Chronometer meter, std::true_type) const { + fun(meter); + } + void call(Chronometer meter, std::false_type) const { + meter.measure(fun); + } + + Fun fun; + }; + + public: + BenchmarkFunction(); + + template ::value, int> = 0> + BenchmarkFunction(Fun&& fun) + : f(new model>(CATCH_FORWARD(fun))) {} + + BenchmarkFunction( BenchmarkFunction&& that ) noexcept: + f( CATCH_MOVE( that.f ) ) {} + + BenchmarkFunction& + operator=( BenchmarkFunction&& that ) noexcept { + f = CATCH_MOVE( that.f ); + return *this; + } + + void operator()(Chronometer meter) const { f->call(meter); } + + private: + Catch::Detail::unique_ptr f; + }; + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_REPEAT_HPP_INCLUDED +#define CATCH_REPEAT_HPP_INCLUDED + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + struct repeater { + void operator()(int k) const { + for (int i = 0; i < k; ++i) { + fun(); + } + } + Fun fun; + }; + template + repeater> repeat(Fun&& fun) { + return { CATCH_FORWARD(fun) }; + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_REPEAT_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED +#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_MEASURE_HPP_INCLUDED +#define CATCH_MEASURE_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED +#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED + + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + struct CompleteType { using type = T; }; + template <> + struct CompleteType { struct type {}; }; + + template + using CompleteType_t = typename CompleteType::type; + + template + struct CompleteInvoker { + template + static Result invoke(Fun&& fun, Args&&... args) { + return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...); + } + }; + template <> + struct CompleteInvoker { + template + static CompleteType_t invoke(Fun&& fun, Args&&... args) { + CATCH_FORWARD(fun)(CATCH_FORWARD(args)...); + return {}; + } + }; + + // invoke and not return void :( + template + CompleteType_t> complete_invoke(Fun&& fun, Args&&... args) { + return CompleteInvoker>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...); + } + + } // namespace Detail + + template + Detail::CompleteType_t> user_code(Fun&& fun) { + return Detail::complete_invoke(CATCH_FORWARD(fun)); + } + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_TIMING_HPP_INCLUDED +#define CATCH_TIMING_HPP_INCLUDED + + +#include + +namespace Catch { + namespace Benchmark { + template + struct Timing { + IDuration elapsed; + Result result; + int iterations; + }; + template + using TimingOf = Timing>>; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_TIMING_HPP_INCLUDED + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + TimingOf measure(Fun&& fun, Args&&... args) { + auto start = Clock::now(); + auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...); + auto end = Clock::now(); + auto delta = end - start; + return { delta, CATCH_FORWARD(r), 1 }; + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_MEASURE_HPP_INCLUDED + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + TimingOf measure_one(Fun&& fun, int iters, std::false_type) { + return Detail::measure(fun, iters); + } + template + TimingOf measure_one(Fun&& fun, int iters, std::true_type) { + Detail::ChronometerModel meter; + auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters)); + + return { meter.elapsed(), CATCH_MOVE(result), iters }; + } + + template + using run_for_at_least_argument_t = std::conditional_t::value, Chronometer, int>; + + + [[noreturn]] + void throw_optimized_away_error(); + + template + TimingOf> + run_for_at_least(IDuration how_long, + const int initial_iterations, + Fun&& fun) { + auto iters = initial_iterations; + while (iters < (1 << 30)) { + auto&& Timing = measure_one(fun, iters, is_callable()); + + if (Timing.elapsed >= how_long) { + return { Timing.elapsed, CATCH_MOVE(Timing.result), iters }; + } + iters *= 2; + } + throw_optimized_away_error(); + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED + +#include + +namespace Catch { + namespace Benchmark { + struct ExecutionPlan { + int iterations_per_sample; + FDuration estimated_duration; + Detail::BenchmarkFunction benchmark; + FDuration warmup_time; + int warmup_iterations; + + template + std::vector run(const IConfig &cfg, Environment env) const { + // warmup a bit + Detail::run_for_at_least( + std::chrono::duration_cast( warmup_time ), + warmup_iterations, + Detail::repeat( []() { return Clock::now(); } ) + ); + + std::vector times; + const auto num_samples = cfg.benchmarkSamples(); + times.reserve( num_samples ); + for ( size_t i = 0; i < num_samples; ++i ) { + Detail::ChronometerModel model; + this->benchmark( Chronometer( model, iterations_per_sample ) ); + auto sample_time = model.elapsed() - env.clock_cost.mean; + if ( sample_time < FDuration::zero() ) { + sample_time = FDuration::zero(); + } + times.push_back(sample_time / iterations_per_sample); + } + return times; + } + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED +#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_STATS_HPP_INCLUDED +#define CATCH_STATS_HPP_INCLUDED + + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + using sample = std::vector; + + double weighted_average_quantile( int k, + int q, + double* first, + double* last ); + + OutlierClassification + classify_outliers( double const* first, double const* last ); + + double mean( double const* first, double const* last ); + + double normal_cdf( double x ); + + double erfc_inv(double x); + + double normal_quantile(double p); + + Estimate + bootstrap( double confidence_level, + double* first, + double* last, + sample const& resample, + double ( *estimator )( double const*, double const* ) ); + + struct bootstrap_analysis { + Estimate mean; + Estimate standard_deviation; + double outlier_variance; + }; + + bootstrap_analysis analyse_samples(double confidence_level, + unsigned int n_resamples, + double* first, + double* last); + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_STATS_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + std::vector resolution(int k) { + const size_t points = static_cast( k + 1 ); + // To avoid overhead from the branch inside vector::push_back, + // we allocate them all and then overwrite. + std::vector> times(points); + for ( auto& time : times ) { + time = Clock::now(); + } + + std::vector deltas; + deltas.reserve(static_cast(k)); + for ( size_t idx = 1; idx < points; ++idx ) { + deltas.push_back( static_cast( + ( times[idx] - times[idx - 1] ).count() ) ); + } + + return deltas; + } + + constexpr auto warmup_iterations = 10000; + constexpr auto warmup_time = std::chrono::milliseconds(100); + constexpr auto minimum_ticks = 1000; + constexpr auto warmup_seed = 10000; + constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500); + constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1); + constexpr auto clock_cost_estimation_tick_limit = 100000; + constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10); + constexpr auto clock_cost_estimation_iterations = 10000; + + template + int warmup() { + return run_for_at_least(warmup_time, warmup_seed, &resolution) + .iterations; + } + template + EnvironmentEstimate estimate_clock_resolution(int iterations) { + auto r = run_for_at_least(clock_resolution_estimation_time, iterations, &resolution) + .result; + return { + FDuration(mean(r.data(), r.data() + r.size())), + classify_outliers(r.data(), r.data() + r.size()), + }; + } + template + EnvironmentEstimate estimate_clock_cost(FDuration resolution) { + auto time_limit = (std::min)( + resolution * clock_cost_estimation_tick_limit, + FDuration(clock_cost_estimation_time_limit)); + auto time_clock = [](int k) { + return Detail::measure([k] { + for (int i = 0; i < k; ++i) { + volatile auto ignored = Clock::now(); + (void)ignored; + } + }).elapsed; + }; + time_clock(1); + int iters = clock_cost_estimation_iterations; + auto&& r = run_for_at_least(clock_cost_estimation_time, iters, time_clock); + std::vector times; + int nsamples = static_cast(std::ceil(time_limit / r.elapsed)); + times.reserve(static_cast(nsamples)); + for ( int s = 0; s < nsamples; ++s ) { + times.push_back( static_cast( + ( time_clock( r.iterations ) / r.iterations ) + .count() ) ); + } + return { + FDuration(mean(times.data(), times.data() + times.size())), + classify_outliers(times.data(), times.data() + times.size()), + }; + } + + template + Environment measure_environment() { +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wexit-time-destructors" +#endif + static Catch::Detail::unique_ptr env; +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + if (env) { + return *env; + } + + auto iters = Detail::warmup(); + auto resolution = Detail::estimate_clock_resolution(iters); + auto cost = Detail::estimate_clock_cost(resolution.mean); + + env = Catch::Detail::make_unique( Environment{resolution, cost} ); + return *env; + } + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_ANALYSE_HPP_INCLUDED +#define CATCH_ANALYSE_HPP_INCLUDED + + + +// Adapted from donated nonius code. + +#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED +#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED + + +#include + +namespace Catch { + namespace Benchmark { + struct SampleAnalysis { + std::vector samples; + Estimate mean; + Estimate standard_deviation; + OutlierClassification outliers; + double outlier_variance; + }; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED + + +namespace Catch { + class IConfig; + + namespace Benchmark { + namespace Detail { + SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last); + } // namespace Detail + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_ANALYSE_HPP_INCLUDED + +#include +#include +#include +#include +#include + +namespace Catch { + namespace Benchmark { + struct Benchmark { + Benchmark(std::string&& benchmarkName) + : name(CATCH_MOVE(benchmarkName)) {} + + template + Benchmark(std::string&& benchmarkName , FUN &&func) + : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {} + + template + ExecutionPlan prepare(const IConfig &cfg, Environment env) { + auto min_time = env.clock_resolution.mean * Detail::minimum_ticks; + auto run_time = std::max(min_time, std::chrono::duration_cast(cfg.benchmarkWarmupTime())); + auto&& test = Detail::run_for_at_least(std::chrono::duration_cast(run_time), 1, fun); + int new_iters = static_cast(std::ceil(min_time * test.iterations / test.elapsed)); + return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast(cfg.benchmarkWarmupTime()), Detail::warmup_iterations }; + } + + template + void run() { + static_assert( Clock::is_steady, + "Benchmarking clock should be steady" ); + auto const* cfg = getCurrentContext().getConfig(); + + auto env = Detail::measure_environment(); + + getResultCapture().benchmarkPreparing(name); + CATCH_TRY{ + auto plan = user_code([&] { + return prepare(*cfg, env); + }); + + BenchmarkInfo info { + CATCH_MOVE(name), + plan.estimated_duration.count(), + plan.iterations_per_sample, + cfg->benchmarkSamples(), + cfg->benchmarkResamples(), + env.clock_resolution.mean.count(), + env.clock_cost.mean.count() + }; + + getResultCapture().benchmarkStarting(info); + + auto samples = user_code([&] { + return plan.template run(*cfg, env); + }); + + auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size()); + BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance }; + getResultCapture().benchmarkEnded(stats); + } CATCH_CATCH_ANON (TestFailureException const&) { + getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr); + } CATCH_CATCH_ALL{ + getResultCapture().benchmarkFailed(translateActiveException()); + // We let the exception go further up so that the + // test case is marked as failed. + std::rethrow_exception(std::current_exception()); + } + } + + // sets lambda to be used in fun *and* executes benchmark! + template ::value, int> = 0> + Benchmark & operator=(Fun func) { + auto const* cfg = getCurrentContext().getConfig(); + if (!cfg->skipBenchmarks()) { + fun = Detail::BenchmarkFunction(func); + run(); + } + return *this; + } + + explicit operator bool() { + return true; + } + + private: + Detail::BenchmarkFunction fun; + std::string name; + }; + } +} // namespace Catch + +#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1 +#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2 + +#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\ + if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \ + BenchmarkName = [&](int benchmarkIndex) + +#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\ + if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \ + BenchmarkName = [&] + +#if defined(CATCH_CONFIG_PREFIX_ALL) + +#define CATCH_BENCHMARK(...) \ + INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,)) +#define CATCH_BENCHMARK_ADVANCED(name) \ + INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name) + +#else + +#define BENCHMARK(...) \ + INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,)) +#define BENCHMARK_ADVANCED(name) \ + INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name) + +#endif + +#endif // CATCH_BENCHMARK_HPP_INCLUDED + + +// Adapted from donated nonius code. + +#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED +#define CATCH_CONSTRUCTOR_HPP_INCLUDED + + +#include + +namespace Catch { + namespace Benchmark { + namespace Detail { + template + struct ObjectStorage + { + ObjectStorage() = default; + + ObjectStorage(const ObjectStorage& other) + { + new(&data) T(other.stored_object()); + } + + ObjectStorage(ObjectStorage&& other) + { + new(data) T(CATCH_MOVE(other.stored_object())); + } + + ~ObjectStorage() { destruct_on_exit(); } + + template + void construct(Args&&... args) + { + new (data) T(CATCH_FORWARD(args)...); + } + + template + std::enable_if_t destruct() + { + stored_object().~T(); + } + + private: + // If this is a constructor benchmark, destruct the underlying object + template + void destruct_on_exit(std::enable_if_t* = nullptr) { destruct(); } + // Otherwise, don't + template + void destruct_on_exit(std::enable_if_t* = nullptr) { } + +#if defined( __GNUC__ ) && __GNUC__ <= 6 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif + T& stored_object() { return *reinterpret_cast( data ); } + + T const& stored_object() const { + return *reinterpret_cast( data ); + } +#if defined( __GNUC__ ) && __GNUC__ <= 6 +# pragma GCC diagnostic pop +#endif + + alignas( T ) unsigned char data[sizeof( T )]{}; + }; + } // namespace Detail + + template + using storage_for = Detail::ObjectStorage; + + template + using destructable_object = Detail::ObjectStorage; + } // namespace Benchmark +} // namespace Catch + +#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED + +#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED + + +#ifndef CATCH_APPROX_HPP_INCLUDED +#define CATCH_APPROX_HPP_INCLUDED + + + +#ifndef CATCH_TOSTRING_HPP_INCLUDED +#define CATCH_TOSTRING_HPP_INCLUDED + + +#include +#include +#include +#include + + + + +/** \file + * Wrapper for the WCHAR configuration option + * + * We want to support platforms that do not provide `wchar_t`, so we + * sometimes have to disable providing wchar_t overloads through Catch2, + * e.g. the StringMaker specialization for `std::wstring`. + */ + +#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED +#define CATCH_CONFIG_WCHAR_HPP_INCLUDED + + +// We assume that WCHAR should be enabled by default, and only disabled +// for a shortlist (so far only DJGPP) of compilers. + +#if defined(__DJGPP__) +# define CATCH_INTERNAL_CONFIG_NO_WCHAR +#endif // __DJGPP__ + +#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \ + !defined( CATCH_CONFIG_NO_WCHAR ) && \ + !defined( CATCH_CONFIG_WCHAR ) +# define CATCH_CONFIG_WCHAR +#endif + +#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED + + +#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED +#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED + + +#include +#include +#include +#include + +namespace Catch { + + class ReusableStringStream : Detail::NonCopyable { + std::size_t m_index; + std::ostream* m_oss; + public: + ReusableStringStream(); + ~ReusableStringStream(); + + //! Returns the serialized state + std::string str() const; + //! Sets internal state to `str` + void str(std::string const& str); + +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +// Old versions of GCC do not understand -Wnonnull-compare +#pragma GCC diagnostic ignored "-Wpragmas" +// Streaming a function pointer triggers Waddress and Wnonnull-compare +// on GCC, because it implicitly converts it to bool and then decides +// that the check it uses (a? true : false) is tautological and cannot +// be null... +#pragma GCC diagnostic ignored "-Waddress" +#pragma GCC diagnostic ignored "-Wnonnull-compare" +#endif + + template + auto operator << ( T const& value ) -> ReusableStringStream& { + *m_oss << value; + return *this; + } + +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + auto get() -> std::ostream& { return *m_oss; } + }; +} + +#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED + + +#ifndef CATCH_VOID_TYPE_HPP_INCLUDED +#define CATCH_VOID_TYPE_HPP_INCLUDED + + +namespace Catch { + namespace Detail { + + template + struct make_void { using type = void; }; + + template + using void_t = typename make_void::type; + + } // namespace Detail +} // namespace Catch + + +#endif // CATCH_VOID_TYPE_HPP_INCLUDED + + +#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED +#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED + + +#include + +namespace Catch { + + namespace Detail { + struct EnumInfo { + StringRef m_name; + std::vector> m_values; + + ~EnumInfo(); + + StringRef lookup( int value ) const; + }; + } // namespace Detail + + class IMutableEnumValuesRegistry { + public: + virtual ~IMutableEnumValuesRegistry(); // = default; + + virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector const& values ) = 0; + + template + Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list values ) { + static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int"); + std::vector intValues; + intValues.reserve( values.size() ); + for( auto enumValue : values ) + intValues.push_back( static_cast( enumValue ) ); + return registerEnum( enumName, allEnums, intValues ); + } + }; + +} // Catch + +#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED + +#ifdef CATCH_CONFIG_CPP17_STRING_VIEW +#include +#endif + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless +#endif + +// We need a dummy global operator<< so we can bring it into Catch namespace later +struct Catch_global_namespace_dummy{}; +std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); + +namespace Catch { + // Bring in global namespace operator<< for ADL lookup in + // `IsStreamInsertable` below. + using ::operator<<; + + namespace Detail { + + inline std::size_t catch_strnlen(const char *str, std::size_t n) { + auto ret = std::char_traits::find(str, n, '\0'); + if (ret != nullptr) { + return static_cast(ret - str); + } + return n; + } + + constexpr StringRef unprintableString = "{?}"_sr; + + //! Encases `string in quotes, and optionally escapes invisibles + std::string convertIntoString( StringRef string, bool escapeInvisibles ); + + //! Encases `string` in quotes, and escapes invisibles if user requested + //! it via CLI + std::string convertIntoString( StringRef string ); + + std::string rawMemoryToString( const void *object, std::size_t size ); + + template + std::string rawMemoryToString( const T& object ) { + return rawMemoryToString( &object, sizeof(object) ); + } + + template + class IsStreamInsertable { + template + static auto test(int) + -> decltype(std::declval() << std::declval(), std::true_type()); + + template + static auto test(...)->std::false_type; + + public: + static const bool value = decltype(test(0))::value; + }; + + template + std::string convertUnknownEnumToString( E e ); + + template + std::enable_if_t< + !std::is_enum::value && !std::is_base_of::value, + std::string> convertUnstreamable( T const& ) { + return std::string(Detail::unprintableString); + } + template + std::enable_if_t< + !std::is_enum::value && std::is_base_of::value, + std::string> convertUnstreamable(T const& ex) { + return ex.what(); + } + + + template + std::enable_if_t< + std::is_enum::value, + std::string> convertUnstreamable( T const& value ) { + return convertUnknownEnumToString( value ); + } + +#if defined(_MANAGED) + //! Convert a CLR string to a utf8 std::string + template + std::string clrReferenceToString( T^ ref ) { + if (ref == nullptr) + return std::string("null"); + auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString()); + cli::pin_ptr p = &bytes[0]; + return std::string(reinterpret_cast(p), bytes->Length); + } +#endif + + } // namespace Detail + + + template + struct StringMaker { + template + static + std::enable_if_t<::Catch::Detail::IsStreamInsertable::value, std::string> + convert(const Fake& value) { + ReusableStringStream rss; + // NB: call using the function-like syntax to avoid ambiguity with + // user-defined templated operator<< under clang. + rss.operator<<(value); + return rss.str(); + } + + template + static + std::enable_if_t::value, std::string> + convert( const Fake& value ) { +#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER) + return Detail::convertUnstreamable(value); +#else + return CATCH_CONFIG_FALLBACK_STRINGIFIER(value); +#endif + } + }; + + namespace Detail { + + // This function dispatches all stringification requests inside of Catch. + // Should be preferably called fully qualified, like ::Catch::Detail::stringify + template + std::string stringify(const T& e) { + return ::Catch::StringMaker>>::convert(e); + } + + template + std::string convertUnknownEnumToString( E e ) { + return ::Catch::Detail::stringify(static_cast>(e)); + } + +#if defined(_MANAGED) + template + std::string stringify( T^ e ) { + return ::Catch::StringMaker::convert(e); + } +#endif + + } // namespace Detail + + // Some predefined specializations + + template<> + struct StringMaker { + static std::string convert(const std::string& str); + }; + +#ifdef CATCH_CONFIG_CPP17_STRING_VIEW + template<> + struct StringMaker { + static std::string convert(std::string_view str); + }; +#endif + + template<> + struct StringMaker { + static std::string convert(char const * str); + }; + template<> + struct StringMaker { + static std::string convert(char * str); + }; + +#if defined(CATCH_CONFIG_WCHAR) + template<> + struct StringMaker { + static std::string convert(const std::wstring& wstr); + }; + +# ifdef CATCH_CONFIG_CPP17_STRING_VIEW + template<> + struct StringMaker { + static std::string convert(std::wstring_view str); + }; +# endif + + template<> + struct StringMaker { + static std::string convert(wchar_t const * str); + }; + template<> + struct StringMaker { + static std::string convert(wchar_t * str); + }; +#endif // CATCH_CONFIG_WCHAR + + template + struct StringMaker { + static std::string convert(char const* str) { + return Detail::convertIntoString( + StringRef( str, Detail::catch_strnlen( str, SZ ) ) ); + } + }; + template + struct StringMaker { + static std::string convert(signed char const* str) { + auto reinterpreted = reinterpret_cast(str); + return Detail::convertIntoString( + StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ))); + } + }; + template + struct StringMaker { + static std::string convert(unsigned char const* str) { + auto reinterpreted = reinterpret_cast(str); + return Detail::convertIntoString( + StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ))); + } + }; + +#if defined(CATCH_CONFIG_CPP17_BYTE) + template<> + struct StringMaker { + static std::string convert(std::byte value); + }; +#endif // defined(CATCH_CONFIG_CPP17_BYTE) + template<> + struct StringMaker { + static std::string convert(int value); + }; + template<> + struct StringMaker { + static std::string convert(long value); + }; + template<> + struct StringMaker { + static std::string convert(long long value); + }; + template<> + struct StringMaker { + static std::string convert(unsigned int value); + }; + template<> + struct StringMaker { + static std::string convert(unsigned long value); + }; + template<> + struct StringMaker { + static std::string convert(unsigned long long value); + }; + + template<> + struct StringMaker { + static std::string convert(bool b) { + using namespace std::string_literals; + return b ? "true"s : "false"s; + } + }; + + template<> + struct StringMaker { + static std::string convert(char c); + }; + template<> + struct StringMaker { + static std::string convert(signed char value); + }; + template<> + struct StringMaker { + static std::string convert(unsigned char value); + }; + + template<> + struct StringMaker { + static std::string convert(std::nullptr_t) { + using namespace std::string_literals; + return "nullptr"s; + } + }; + + template<> + struct StringMaker { + static std::string convert(float value); + CATCH_EXPORT static int precision; + }; + + template<> + struct StringMaker { + static std::string convert(double value); + CATCH_EXPORT static int precision; + }; + + template + struct StringMaker { + template + static std::string convert(U* p) { + if (p) { + return ::Catch::Detail::rawMemoryToString(p); + } else { + return "nullptr"; + } + } + }; + + template + struct StringMaker { + static std::string convert(R C::* p) { + if (p) { + return ::Catch::Detail::rawMemoryToString(p); + } else { + return "nullptr"; + } + } + }; + +#if defined(_MANAGED) + template + struct StringMaker { + static std::string convert( T^ ref ) { + return ::Catch::Detail::clrReferenceToString(ref); + } + }; +#endif + + namespace Detail { + template + std::string rangeToString(InputIterator first, Sentinel last) { + ReusableStringStream rss; + rss << "{ "; + if (first != last) { + rss << ::Catch::Detail::stringify(*first); + for (++first; first != last; ++first) + rss << ", " << ::Catch::Detail::stringify(*first); + } + rss << " }"; + return rss.str(); + } + } + +} // namespace Catch + +////////////////////////////////////////////////////// +// Separate std-lib types stringification, so it can be selectively enabled +// This means that we do not bring in their headers + +#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS) +# define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER +# define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER +# define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER +# define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER +#endif + +// Separate std::pair specialization +#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER) +#include +namespace Catch { + template + struct StringMaker > { + static std::string convert(const std::pair& pair) { + ReusableStringStream rss; + rss << "{ " + << ::Catch::Detail::stringify(pair.first) + << ", " + << ::Catch::Detail::stringify(pair.second) + << " }"; + return rss.str(); + } + }; +} +#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER + +#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL) +#include +namespace Catch { + template + struct StringMaker > { + static std::string convert(const std::optional& optional) { + if (optional.has_value()) { + return ::Catch::Detail::stringify(*optional); + } else { + return "{ }"; + } + } + }; + template <> + struct StringMaker { + static std::string convert(const std::nullopt_t&) { + return "{ }"; + } + }; +} +#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER + +// Separate std::tuple specialization +#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER) +#include +namespace Catch { + namespace Detail { + template< + typename Tuple, + std::size_t N = 0, + bool = (N < std::tuple_size::value) + > + struct TupleElementPrinter { + static void print(const Tuple& tuple, std::ostream& os) { + os << (N ? ", " : " ") + << ::Catch::Detail::stringify(std::get(tuple)); + TupleElementPrinter::print(tuple, os); + } + }; + + template< + typename Tuple, + std::size_t N + > + struct TupleElementPrinter { + static void print(const Tuple&, std::ostream&) {} + }; + + } + + + template + struct StringMaker> { + static std::string convert(const std::tuple& tuple) { + ReusableStringStream rss; + rss << '{'; + Detail::TupleElementPrinter>::print(tuple, rss.get()); + rss << " }"; + return rss.str(); + } + }; +} +#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER + +#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT) +#include +namespace Catch { + template<> + struct StringMaker { + static std::string convert(const std::monostate&) { + return "{ }"; + } + }; + + template + struct StringMaker> { + static std::string convert(const std::variant& variant) { + if (variant.valueless_by_exception()) { + return "{valueless variant}"; + } else { + return std::visit( + [](const auto& value) { + return ::Catch::Detail::stringify(value); + }, + variant + ); + } + } + }; +} +#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER + +namespace Catch { + // Import begin/ end from std here + using std::begin; + using std::end; + + namespace Detail { + template + struct is_range_impl : std::false_type {}; + + template + struct is_range_impl()))>> : std::true_type {}; + } // namespace Detail + + template + struct is_range : Detail::is_range_impl {}; + +#if defined(_MANAGED) // Managed types are never ranges + template + struct is_range { + static const bool value = false; + }; +#endif + + template + std::string rangeToString( Range const& range ) { + return ::Catch::Detail::rangeToString( begin( range ), end( range ) ); + } + + // Handle vector specially + template + std::string rangeToString( std::vector const& v ) { + ReusableStringStream rss; + rss << "{ "; + bool first = true; + for( bool b : v ) { + if( first ) + first = false; + else + rss << ", "; + rss << ::Catch::Detail::stringify( b ); + } + rss << " }"; + return rss.str(); + } + + template + struct StringMaker::value && !::Catch::Detail::IsStreamInsertable::value>> { + static std::string convert( R const& range ) { + return rangeToString( range ); + } + }; + + template + struct StringMaker { + static std::string convert(T const(&arr)[SZ]) { + return rangeToString(arr); + } + }; + + +} // namespace Catch + +// Separate std::chrono::duration specialization +#include +#include +#include + + +namespace Catch { + +template +struct ratio_string { + static std::string symbol() { + Catch::ReusableStringStream rss; + rss << '[' << Ratio::num << '/' + << Ratio::den << ']'; + return rss.str(); + } +}; + +template <> +struct ratio_string { + static char symbol() { return 'a'; } +}; +template <> +struct ratio_string { + static char symbol() { return 'f'; } +}; +template <> +struct ratio_string { + static char symbol() { return 'p'; } +}; +template <> +struct ratio_string { + static char symbol() { return 'n'; } +}; +template <> +struct ratio_string { + static char symbol() { return 'u'; } +}; +template <> +struct ratio_string { + static char symbol() { return 'm'; } +}; + + //////////// + // std::chrono::duration specializations + template + struct StringMaker> { + static std::string convert(std::chrono::duration const& duration) { + ReusableStringStream rss; + rss << duration.count() << ' ' << ratio_string::symbol() << 's'; + return rss.str(); + } + }; + template + struct StringMaker>> { + static std::string convert(std::chrono::duration> const& duration) { + ReusableStringStream rss; + rss << duration.count() << " s"; + return rss.str(); + } + }; + template + struct StringMaker>> { + static std::string convert(std::chrono::duration> const& duration) { + ReusableStringStream rss; + rss << duration.count() << " m"; + return rss.str(); + } + }; + template + struct StringMaker>> { + static std::string convert(std::chrono::duration> const& duration) { + ReusableStringStream rss; + rss << duration.count() << " h"; + return rss.str(); + } + }; + + //////////// + // std::chrono::time_point specialization + // Generic time_point cannot be specialized, only std::chrono::time_point + template + struct StringMaker> { + static std::string convert(std::chrono::time_point const& time_point) { + return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch"; + } + }; + // std::chrono::time_point specialization + template + struct StringMaker> { + static std::string convert(std::chrono::time_point const& time_point) { + auto converted = std::chrono::system_clock::to_time_t(time_point); + +#ifdef _MSC_VER + std::tm timeInfo = {}; + gmtime_s(&timeInfo, &converted); +#else + std::tm* timeInfo = std::gmtime(&converted); +#endif + + auto const timeStampSize = sizeof("2017-01-16T17:06:45Z"); + char timeStamp[timeStampSize]; + const char * const fmt = "%Y-%m-%dT%H:%M:%SZ"; + +#ifdef _MSC_VER + std::strftime(timeStamp, timeStampSize, fmt, &timeInfo); +#else + std::strftime(timeStamp, timeStampSize, fmt, timeInfo); +#endif + return std::string(timeStamp, timeStampSize - 1); + } + }; +} + + +#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \ +namespace Catch { \ + template<> struct StringMaker { \ + static std::string convert( enumName value ) { \ + static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \ + return static_cast(enumInfo.lookup( static_cast( value ) )); \ + } \ + }; \ +} + +#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ ) + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // CATCH_TOSTRING_HPP_INCLUDED + +#include + +namespace Catch { + + class Approx { + private: + bool equalityComparisonImpl(double other) const; + // Sets and validates the new margin (margin >= 0) + void setMargin(double margin); + // Sets and validates the new epsilon (0 < epsilon < 1) + void setEpsilon(double epsilon); + + public: + explicit Approx ( double value ); + + static Approx custom(); + + Approx operator-() const; + + template ::value>> + Approx operator()( T const& value ) const { + Approx approx( static_cast(value) ); + approx.m_epsilon = m_epsilon; + approx.m_margin = m_margin; + approx.m_scale = m_scale; + return approx; + } + + template ::value>> + explicit Approx( T const& value ): Approx(static_cast(value)) + {} + + + template ::value>> + friend bool operator == ( const T& lhs, Approx const& rhs ) { + auto lhs_v = static_cast(lhs); + return rhs.equalityComparisonImpl(lhs_v); + } + + template ::value>> + friend bool operator == ( Approx const& lhs, const T& rhs ) { + return operator==( rhs, lhs ); + } + + template ::value>> + friend bool operator != ( T const& lhs, Approx const& rhs ) { + return !operator==( lhs, rhs ); + } + + template ::value>> + friend bool operator != ( Approx const& lhs, T const& rhs ) { + return !operator==( rhs, lhs ); + } + + template ::value>> + friend bool operator <= ( T const& lhs, Approx const& rhs ) { + return static_cast(lhs) < rhs.m_value || lhs == rhs; + } + + template ::value>> + friend bool operator <= ( Approx const& lhs, T const& rhs ) { + return lhs.m_value < static_cast(rhs) || lhs == rhs; + } + + template ::value>> + friend bool operator >= ( T const& lhs, Approx const& rhs ) { + return static_cast(lhs) > rhs.m_value || lhs == rhs; + } + + template ::value>> + friend bool operator >= ( Approx const& lhs, T const& rhs ) { + return lhs.m_value > static_cast(rhs) || lhs == rhs; + } + + template ::value>> + Approx& epsilon( T const& newEpsilon ) { + const auto epsilonAsDouble = static_cast(newEpsilon); + setEpsilon(epsilonAsDouble); + return *this; + } + + template ::value>> + Approx& margin( T const& newMargin ) { + const auto marginAsDouble = static_cast(newMargin); + setMargin(marginAsDouble); + return *this; + } + + template ::value>> + Approx& scale( T const& newScale ) { + m_scale = static_cast(newScale); + return *this; + } + + std::string toString() const; + + private: + double m_epsilon; + double m_margin; + double m_scale; + double m_value; + }; + +namespace literals { + Approx operator ""_a(long double val); + Approx operator ""_a(unsigned long long val); +} // end namespace literals + +template<> +struct StringMaker { + static std::string convert(Catch::Approx const& value); +}; + +} // end namespace Catch + +#endif // CATCH_APPROX_HPP_INCLUDED + + +#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED +#define CATCH_ASSERTION_INFO_HPP_INCLUDED + + + +#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED +#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED + +#include +#include + +namespace Catch { + + struct SourceLineInfo { + + SourceLineInfo() = delete; + constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept: + file( _file ), + line( _line ) + {} + + bool operator == ( SourceLineInfo const& other ) const noexcept; + bool operator < ( SourceLineInfo const& other ) const noexcept; + + char const* file; + std::size_t line; + + friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info); + }; +} + +#define CATCH_INTERNAL_LINEINFO \ + ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) + +#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED + +namespace Catch { + + struct AssertionInfo { + // AssertionInfo() = delete; + + StringRef macroName; + SourceLineInfo lineInfo; + StringRef capturedExpression; + ResultDisposition::Flags resultDisposition; + }; + +} // end namespace Catch + +#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED + + +#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED +#define CATCH_ASSERTION_RESULT_HPP_INCLUDED + + + +#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED +#define CATCH_LAZY_EXPR_HPP_INCLUDED + +#include + +namespace Catch { + + class ITransientExpression; + + class LazyExpression { + friend class AssertionHandler; + friend struct AssertionStats; + friend class RunContext; + + ITransientExpression const* m_transientExpression = nullptr; + bool m_isNegated; + public: + constexpr LazyExpression( bool isNegated ): + m_isNegated(isNegated) + {} + constexpr LazyExpression(LazyExpression const& other) = default; + LazyExpression& operator = ( LazyExpression const& ) = delete; + + constexpr explicit operator bool() const { + return m_transientExpression != nullptr; + } + + friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&; + }; + +} // namespace Catch + +#endif // CATCH_LAZY_EXPR_HPP_INCLUDED + +#include + +namespace Catch { + + struct AssertionResultData + { + AssertionResultData() = delete; + + AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression ); + + std::string message; + mutable std::string reconstructedExpression; + LazyExpression lazyExpression; + ResultWas::OfType resultType; + + std::string reconstructExpression() const; + }; + + class AssertionResult { + public: + AssertionResult() = delete; + AssertionResult( AssertionInfo const& info, AssertionResultData&& data ); + + bool isOk() const; + bool succeeded() const; + ResultWas::OfType getResultType() const; + bool hasExpression() const; + bool hasMessage() const; + std::string getExpression() const; + std::string getExpressionInMacro() const; + bool hasExpandedExpression() const; + std::string getExpandedExpression() const; + StringRef getMessage() const; + SourceLineInfo getSourceInfo() const; + StringRef getTestMacroName() const; + + //protected: + AssertionInfo m_info; + AssertionResultData m_resultData; + }; + +} // end namespace Catch + +#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED + + +#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED +#define CATCH_CASE_SENSITIVE_HPP_INCLUDED + +namespace Catch { + + enum class CaseSensitive { Yes, No }; + +} // namespace Catch + +#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED + + +#ifndef CATCH_CONFIG_HPP_INCLUDED +#define CATCH_CONFIG_HPP_INCLUDED + + + +#ifndef CATCH_TEST_SPEC_HPP_INCLUDED +#define CATCH_TEST_SPEC_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + + + +#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED +#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED + + +#include + +namespace Catch +{ + class WildcardPattern { + enum WildcardPosition { + NoWildcard = 0, + WildcardAtStart = 1, + WildcardAtEnd = 2, + WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd + }; + + public: + + WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity ); + bool matches( std::string const& str ) const; + + private: + std::string normaliseString( std::string const& str ) const; + CaseSensitive m_caseSensitivity; + WildcardPosition m_wildcard = NoWildcard; + std::string m_pattern; + }; +} + +#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + class IConfig; + struct TestCaseInfo; + class TestCaseHandle; + + class TestSpec { + + class Pattern { + public: + explicit Pattern( std::string const& name ); + virtual ~Pattern(); + virtual bool matches( TestCaseInfo const& testCase ) const = 0; + std::string const& name() const; + private: + virtual void serializeTo( std::ostream& out ) const = 0; + // Writes string that would be reparsed into the pattern + friend std::ostream& operator<<(std::ostream& out, + Pattern const& pattern) { + pattern.serializeTo( out ); + return out; + } + + std::string const m_name; + }; + + class NamePattern : public Pattern { + public: + explicit NamePattern( std::string const& name, std::string const& filterString ); + bool matches( TestCaseInfo const& testCase ) const override; + private: + void serializeTo( std::ostream& out ) const override; + + WildcardPattern m_wildcardPattern; + }; + + class TagPattern : public Pattern { + public: + explicit TagPattern( std::string const& tag, std::string const& filterString ); + bool matches( TestCaseInfo const& testCase ) const override; + private: + void serializeTo( std::ostream& out ) const override; + + std::string m_tag; + }; + + struct Filter { + std::vector> m_required; + std::vector> m_forbidden; + + //! Serializes this filter into a string that would be parsed into + //! an equivalent filter + void serializeTo( std::ostream& out ) const; + friend std::ostream& operator<<(std::ostream& out, Filter const& f) { + f.serializeTo( out ); + return out; + } + + bool matches( TestCaseInfo const& testCase ) const; + }; + + static std::string extractFilterName( Filter const& filter ); + + public: + struct FilterMatch { + std::string name; + std::vector tests; + }; + using Matches = std::vector; + using vectorStrings = std::vector; + + bool hasFilters() const; + bool matches( TestCaseInfo const& testCase ) const; + Matches matchesByFilter( std::vector const& testCases, IConfig const& config ) const; + const vectorStrings & getInvalidSpecs() const; + + private: + std::vector m_filters; + std::vector m_invalidSpecs; + + friend class TestSpecParser; + //! Serializes this test spec into a string that would be parsed into + //! equivalent test spec + void serializeTo( std::ostream& out ) const; + friend std::ostream& operator<<(std::ostream& out, + TestSpec const& spec) { + spec.serializeTo( out ); + return out; + } + }; +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif // CATCH_TEST_SPEC_HPP_INCLUDED + + +#ifndef CATCH_OPTIONAL_HPP_INCLUDED +#define CATCH_OPTIONAL_HPP_INCLUDED + + +#include + +namespace Catch { + + // An optional type + template + class Optional { + public: + Optional(): nullableValue( nullptr ) {} + ~Optional() { reset(); } + + Optional( T const& _value ): + nullableValue( new ( storage ) T( _value ) ) {} + Optional( T&& _value ): + nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {} + + Optional& operator=( T const& _value ) { + reset(); + nullableValue = new ( storage ) T( _value ); + return *this; + } + Optional& operator=( T&& _value ) { + reset(); + nullableValue = new ( storage ) T( CATCH_MOVE( _value ) ); + return *this; + } + + Optional( Optional const& _other ): + nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {} + Optional( Optional&& _other ): + nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) ) + : nullptr ) {} + + Optional& operator=( Optional const& _other ) { + if ( &_other != this ) { + reset(); + if ( _other ) { nullableValue = new ( storage ) T( *_other ); } + } + return *this; + } + Optional& operator=( Optional&& _other ) { + if ( &_other != this ) { + reset(); + if ( _other ) { + nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) ); + } + } + return *this; + } + + void reset() { + if ( nullableValue ) { nullableValue->~T(); } + nullableValue = nullptr; + } + + T& operator*() { + assert(nullableValue); + return *nullableValue; + } + T const& operator*() const { + assert(nullableValue); + return *nullableValue; + } + T* operator->() { + assert(nullableValue); + return nullableValue; + } + const T* operator->() const { + assert(nullableValue); + return nullableValue; + } + + T valueOr( T const& defaultValue ) const { + return nullableValue ? *nullableValue : defaultValue; + } + + bool some() const { return nullableValue != nullptr; } + bool none() const { return nullableValue == nullptr; } + + bool operator !() const { return nullableValue == nullptr; } + explicit operator bool() const { + return some(); + } + + friend bool operator==(Optional const& a, Optional const& b) { + if (a.none() && b.none()) { + return true; + } else if (a.some() && b.some()) { + return *a == *b; + } else { + return false; + } + } + friend bool operator!=(Optional const& a, Optional const& b) { + return !( a == b ); + } + + private: + T* nullableValue; + alignas(alignof(T)) char storage[sizeof(T)]; + }; + +} // end namespace Catch + +#endif // CATCH_OPTIONAL_HPP_INCLUDED + + +#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED +#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED + +#include + +namespace Catch { + + enum class GenerateFrom { + Time, + RandomDevice, + //! Currently equivalent to RandomDevice, but can change at any point + Default + }; + + std::uint32_t generateRandomSeed(GenerateFrom from); + +} // end namespace Catch + +#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED + + +#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED +#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED + + +#include +#include +#include + +namespace Catch { + + enum class ColourMode : std::uint8_t; + + namespace Detail { + //! Splits the reporter spec into reporter name and kv-pair options + std::vector splitReporterSpec( StringRef reporterSpec ); + + Optional stringToColourMode( StringRef colourMode ); + } + + /** + * Structured reporter spec that a reporter can be created from + * + * Parsing has been validated, but semantics have not. This means e.g. + * that the colour mode is known to Catch2, but it might not be + * compiled into the binary, and the output filename might not be + * openable. + */ + class ReporterSpec { + std::string m_name; + Optional m_outputFileName; + Optional m_colourMode; + std::map m_customOptions; + + friend bool operator==( ReporterSpec const& lhs, + ReporterSpec const& rhs ); + friend bool operator!=( ReporterSpec const& lhs, + ReporterSpec const& rhs ) { + return !( lhs == rhs ); + } + + public: + ReporterSpec( + std::string name, + Optional outputFileName, + Optional colourMode, + std::map customOptions ); + + std::string const& name() const { return m_name; } + + Optional const& outputFile() const { + return m_outputFileName; + } + + Optional const& colourMode() const { return m_colourMode; } + + std::map const& customOptions() const { + return m_customOptions; + } + }; + + /** + * Parses provided reporter spec string into + * + * Returns empty optional on errors, e.g. + * * field that is not first and not a key+value pair + * * duplicated keys in kv pair + * * unknown catch reporter option + * * empty key/value in an custom kv pair + * * ... + */ + Optional parseReporterSpec( StringRef reporterSpec ); + +} + +#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + class IStream; + + /** + * `ReporterSpec` but with the defaults filled in. + * + * Like `ReporterSpec`, the semantics are unchecked. + */ + struct ProcessedReporterSpec { + std::string name; + std::string outputFilename; + ColourMode colourMode; + std::map customOptions; + friend bool operator==( ProcessedReporterSpec const& lhs, + ProcessedReporterSpec const& rhs ); + friend bool operator!=( ProcessedReporterSpec const& lhs, + ProcessedReporterSpec const& rhs ) { + return !( lhs == rhs ); + } + }; + + struct ConfigData { + + bool listTests = false; + bool listTags = false; + bool listReporters = false; + bool listListeners = false; + + bool showSuccessfulTests = false; + bool shouldDebugBreak = false; + bool noThrow = false; + bool showHelp = false; + bool showInvisibles = false; + bool filenamesAsTags = false; + bool libIdentify = false; + bool allowZeroTests = false; + + int abortAfter = -1; + uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default); + + unsigned int shardCount = 1; + unsigned int shardIndex = 0; + + bool skipBenchmarks = false; + bool benchmarkNoAnalysis = false; + unsigned int benchmarkSamples = 100; + double benchmarkConfidenceInterval = 0.95; + unsigned int benchmarkResamples = 100'000; + std::chrono::milliseconds::rep benchmarkWarmupTime = 100; + + Verbosity verbosity = Verbosity::Normal; + WarnAbout::What warnings = WarnAbout::Nothing; + ShowDurations showDurations = ShowDurations::DefaultForReporter; + double minDuration = -1; + TestRunOrder runOrder = TestRunOrder::Declared; + ColourMode defaultColourMode = ColourMode::PlatformDefault; + WaitForKeypress::When waitForKeypress = WaitForKeypress::Never; + + std::string defaultOutputFilename; + std::string name; + std::string processName; + std::vector reporterSpecifications; + + std::vector testsOrTags; + std::vector sectionsToRun; + }; + + + class Config : public IConfig { + public: + + Config() = default; + Config( ConfigData const& data ); + ~Config() override; // = default in the cpp file + + bool listTests() const; + bool listTags() const; + bool listReporters() const; + bool listListeners() const; + + std::vector const& getReporterSpecs() const; + std::vector const& + getProcessedReporterSpecs() const; + + std::vector const& getTestsOrTags() const override; + std::vector const& getSectionsToRun() const override; + + TestSpec const& testSpec() const override; + bool hasTestFilters() const override; + + bool showHelp() const; + + // IConfig interface + bool allowThrows() const override; + StringRef name() const override; + bool includeSuccessfulResults() const override; + bool warnAboutMissingAssertions() const override; + bool warnAboutUnmatchedTestSpecs() const override; + bool zeroTestsCountAsSuccess() const override; + ShowDurations showDurations() const override; + double minDuration() const override; + TestRunOrder runOrder() const override; + uint32_t rngSeed() const override; + unsigned int shardCount() const override; + unsigned int shardIndex() const override; + ColourMode defaultColourMode() const override; + bool shouldDebugBreak() const override; + int abortAfter() const override; + bool showInvisibles() const override; + Verbosity verbosity() const override; + bool skipBenchmarks() const override; + bool benchmarkNoAnalysis() const override; + unsigned int benchmarkSamples() const override; + double benchmarkConfidenceInterval() const override; + unsigned int benchmarkResamples() const override; + std::chrono::milliseconds benchmarkWarmupTime() const override; + + private: + // Reads Bazel env vars and applies them to the config + void readBazelEnvVars(); + + ConfigData m_data; + std::vector m_processedReporterSpecs; + TestSpec m_testSpec; + bool m_hasTestFilters = false; + }; +} // end namespace Catch + +#endif // CATCH_CONFIG_HPP_INCLUDED + + +#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED +#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED + +#include + +namespace Catch { + //! Returns Catch2's current RNG seed. + std::uint32_t getSeed(); +} + +#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED + + +#ifndef CATCH_MESSAGE_HPP_INCLUDED +#define CATCH_MESSAGE_HPP_INCLUDED + + + + +/** \file + * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option + * + * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros + * by prepending CATCH_. This may not be desirable if the only clashes are with + * logger macros such as INFO and WARN. In this cases + * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset + * of relevant macros. + * + */ + +#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED +#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED + + +#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES) + #define CATCH_CONFIG_PREFIX_MESSAGES +#endif + +#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED + + +#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED +#define CATCH_STREAM_END_STOP_HPP_INCLUDED + + +namespace Catch { + + // Use this in variadic streaming macros to allow + // << +StreamEndStop + // as well as + // << stuff +StreamEndStop + struct StreamEndStop { + constexpr StringRef operator+() const { return StringRef(); } + + template + constexpr friend T const& operator+( T const& value, StreamEndStop ) { + return value; + } + }; + +} // namespace Catch + +#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED + + +#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED +#define CATCH_MESSAGE_INFO_HPP_INCLUDED + + +#include + +namespace Catch { + + struct MessageInfo { + MessageInfo( StringRef _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ); + + StringRef macroName; + std::string message; + SourceLineInfo lineInfo; + ResultWas::OfType type; + unsigned int sequence; + + bool operator == (MessageInfo const& other) const { + return sequence == other.sequence; + } + bool operator < (MessageInfo const& other) const { + return sequence < other.sequence; + } + private: + static unsigned int globalCount; + }; + +} // end namespace Catch + +#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED + +#include +#include + +namespace Catch { + + struct SourceLineInfo; + class IResultCapture; + + struct MessageStream { + + template + MessageStream& operator << ( T const& value ) { + m_stream << value; + return *this; + } + + ReusableStringStream m_stream; + }; + + struct MessageBuilder : MessageStream { + MessageBuilder( StringRef macroName, + SourceLineInfo const& lineInfo, + ResultWas::OfType type ): + m_info(macroName, lineInfo, type) {} + + template + MessageBuilder&& operator << ( T const& value ) && { + m_stream << value; + return CATCH_MOVE(*this); + } + + MessageInfo m_info; + }; + + class ScopedMessage { + public: + explicit ScopedMessage( MessageBuilder&& builder ); + ScopedMessage( ScopedMessage& duplicate ) = delete; + ScopedMessage( ScopedMessage&& old ) noexcept; + ~ScopedMessage(); + + MessageInfo m_info; + bool m_moved = false; + }; + + class Capturer { + std::vector m_messages; + IResultCapture& m_resultCapture; + size_t m_captured = 0; + public: + Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ); + + Capturer(Capturer const&) = delete; + Capturer& operator=(Capturer const&) = delete; + + ~Capturer(); + + void captureValue( size_t index, std::string const& value ); + + template + void captureValues( size_t index, T const& value ) { + captureValue( index, Catch::Detail::stringify( value ) ); + } + + template + void captureValues( size_t index, T const& value, Ts const&... values ) { + captureValue( index, Catch::Detail::stringify(value) ); + captureValues( index+1, values... ); + } + }; + +} // end namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \ + do { \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \ + catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \ + catchAssertionHandler.complete(); \ + } while( false ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \ + Catch::Capturer varName( macroName##_catch_sr, \ + CATCH_INTERNAL_LINEINFO, \ + Catch::ResultWas::Info, \ + #__VA_ARGS__##_catch_sr ); \ + varName.captureValues( 0, __VA_ARGS__ ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_INFO( macroName, log ) \ + const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \ + Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log ) + + +#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE) + + #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg ) + #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg ) + #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg ) + #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ ) + +#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE) + + #define CATCH_INFO( msg ) (void)(0) + #define CATCH_UNSCOPED_INFO( msg ) (void)(0) + #define CATCH_WARN( msg ) (void)(0) + #define CATCH_CAPTURE( ... ) (void)(0) + +#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE) + + #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg ) + #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg ) + #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg ) + #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ ) + +#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE) + + #define INFO( msg ) (void)(0) + #define UNSCOPED_INFO( msg ) (void)(0) + #define WARN( msg ) (void)(0) + #define CAPTURE( ... ) (void)(0) + +#endif // end of user facing macro declarations + + + + +#endif // CATCH_MESSAGE_HPP_INCLUDED + + +#ifndef CATCH_SECTION_INFO_HPP_INCLUDED +#define CATCH_SECTION_INFO_HPP_INCLUDED + + + +#ifndef CATCH_TOTALS_HPP_INCLUDED +#define CATCH_TOTALS_HPP_INCLUDED + +#include + +namespace Catch { + + struct Counts { + Counts operator - ( Counts const& other ) const; + Counts& operator += ( Counts const& other ); + + std::uint64_t total() const; + bool allPassed() const; + bool allOk() const; + + std::uint64_t passed = 0; + std::uint64_t failed = 0; + std::uint64_t failedButOk = 0; + std::uint64_t skipped = 0; + }; + + struct Totals { + + Totals operator - ( Totals const& other ) const; + Totals& operator += ( Totals const& other ); + + Totals delta( Totals const& prevTotals ) const; + + Counts assertions; + Counts testCases; + }; +} + +#endif // CATCH_TOTALS_HPP_INCLUDED + +#include + +namespace Catch { + + struct SectionInfo { + // The last argument is ignored, so that people can write + // SECTION("ShortName", "Proper description that is long") and + // still use the `-c` flag comfortably. + SectionInfo( SourceLineInfo const& _lineInfo, std::string _name, + const char* const = nullptr ): + name(CATCH_MOVE(_name)), + lineInfo(_lineInfo) + {} + + std::string name; + SourceLineInfo lineInfo; + }; + + struct SectionEndInfo { + SectionInfo sectionInfo; + Counts prevAssertions; + double durationInSeconds; + }; + +} // end namespace Catch + +#endif // CATCH_SECTION_INFO_HPP_INCLUDED + + +#ifndef CATCH_SESSION_HPP_INCLUDED +#define CATCH_SESSION_HPP_INCLUDED + + + +#ifndef CATCH_COMMANDLINE_HPP_INCLUDED +#define CATCH_COMMANDLINE_HPP_INCLUDED + + + +#ifndef CATCH_CLARA_HPP_INCLUDED +#define CATCH_CLARA_HPP_INCLUDED + +#if defined( __clang__ ) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wweak-vtables" +# pragma clang diagnostic ignored "-Wshadow" +# pragma clang diagnostic ignored "-Wdeprecated" +#endif + +#if defined( __GNUC__ ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wsign-conversion" +#endif + +#ifndef CLARA_CONFIG_OPTIONAL_TYPE +# ifdef __has_include +# if __has_include( ) && __cplusplus >= 201703L +# include +# define CLARA_CONFIG_OPTIONAL_TYPE std::optional +# endif +# endif +#endif + + +#include +#include +#include +#include +#include +#include +#include + +namespace Catch { + namespace Clara { + + class Args; + class Parser; + + // enum of result types from a parse + enum class ParseResultType { + Matched, + NoMatch, + ShortCircuitAll, + ShortCircuitSame + }; + + struct accept_many_t {}; + constexpr accept_many_t accept_many {}; + + namespace Detail { + struct fake_arg { + template + operator T(); + }; + + template + struct is_unary_function : std::false_type {}; + + template + struct is_unary_function< + F, + Catch::Detail::void_t()( fake_arg() ) ) + > + > : std::true_type {}; + + // Traits for extracting arg and return type of lambdas (for single + // argument lambdas) + template + struct UnaryLambdaTraits + : UnaryLambdaTraits {}; + + template + struct UnaryLambdaTraits { + static const bool isValid = false; + }; + + template + struct UnaryLambdaTraits { + static const bool isValid = true; + using ArgType = std::remove_const_t>; + using ReturnType = ReturnT; + }; + + class TokenStream; + + // Wraps a token coming from a token stream. These may not directly + // correspond to strings as a single string may encode an option + + // its argument if the : or = form is used + enum class TokenType { Option, Argument }; + struct Token { + TokenType type; + StringRef token; + }; + + // Abstracts iterators into args as a stream of tokens, with option + // arguments uniformly handled + class TokenStream { + using Iterator = std::vector::const_iterator; + Iterator it; + Iterator itEnd; + std::vector m_tokenBuffer; + void loadBuffer(); + + public: + explicit TokenStream( Args const& args ); + TokenStream( Iterator it, Iterator itEnd ); + + explicit operator bool() const { + return !m_tokenBuffer.empty() || it != itEnd; + } + + size_t count() const { + return m_tokenBuffer.size() + ( itEnd - it ); + } + + Token operator*() const { + assert( !m_tokenBuffer.empty() ); + return m_tokenBuffer.front(); + } + + Token const* operator->() const { + assert( !m_tokenBuffer.empty() ); + return &m_tokenBuffer.front(); + } + + TokenStream& operator++(); + }; + + //! Denotes type of a parsing result + enum class ResultType { + Ok, ///< No errors + LogicError, ///< Error in user-specified arguments for + ///< construction + RuntimeError ///< Error in parsing inputs + }; + + class ResultBase { + protected: + ResultBase( ResultType type ): m_type( type ) {} + virtual ~ResultBase(); // = default; + + + ResultBase(ResultBase const&) = default; + ResultBase& operator=(ResultBase const&) = default; + ResultBase(ResultBase&&) = default; + ResultBase& operator=(ResultBase&&) = default; + + virtual void enforceOk() const = 0; + + ResultType m_type; + }; + + template + class ResultValueBase : public ResultBase { + public: + T const& value() const& { + enforceOk(); + return m_value; + } + T&& value() && { + enforceOk(); + return CATCH_MOVE( m_value ); + } + + protected: + ResultValueBase( ResultType type ): ResultBase( type ) {} + + ResultValueBase( ResultValueBase const& other ): + ResultBase( other ) { + if ( m_type == ResultType::Ok ) + new ( &m_value ) T( other.m_value ); + } + ResultValueBase( ResultValueBase&& other ): + ResultBase( other ) { + if ( m_type == ResultType::Ok ) + new ( &m_value ) T( CATCH_MOVE(other.m_value) ); + } + + + ResultValueBase( ResultType, T const& value ): + ResultBase( ResultType::Ok ) { + new ( &m_value ) T( value ); + } + ResultValueBase( ResultType, T&& value ): + ResultBase( ResultType::Ok ) { + new ( &m_value ) T( CATCH_MOVE(value) ); + } + + ResultValueBase& operator=( ResultValueBase const& other ) { + if ( m_type == ResultType::Ok ) + m_value.~T(); + ResultBase::operator=( other ); + if ( m_type == ResultType::Ok ) + new ( &m_value ) T( other.m_value ); + return *this; + } + ResultValueBase& operator=( ResultValueBase&& other ) { + if ( m_type == ResultType::Ok ) m_value.~T(); + ResultBase::operator=( other ); + if ( m_type == ResultType::Ok ) + new ( &m_value ) T( CATCH_MOVE(other.m_value) ); + return *this; + } + + + ~ResultValueBase() override { + if ( m_type == ResultType::Ok ) + m_value.~T(); + } + + union { + T m_value; + }; + }; + + template <> class ResultValueBase : public ResultBase { + protected: + using ResultBase::ResultBase; + }; + + template + class BasicResult : public ResultValueBase { + public: + template + explicit BasicResult( BasicResult const& other ): + ResultValueBase( other.type() ), + m_errorMessage( other.errorMessage() ) { + assert( type() != ResultType::Ok ); + } + + template + static auto ok( U&& value ) -> BasicResult { + return { ResultType::Ok, CATCH_FORWARD(value) }; + } + static auto ok() -> BasicResult { return { ResultType::Ok }; } + static auto logicError( std::string&& message ) + -> BasicResult { + return { ResultType::LogicError, CATCH_MOVE(message) }; + } + static auto runtimeError( std::string&& message ) + -> BasicResult { + return { ResultType::RuntimeError, CATCH_MOVE(message) }; + } + + explicit operator bool() const { + return m_type == ResultType::Ok; + } + auto type() const -> ResultType { return m_type; } + auto errorMessage() const -> std::string const& { + return m_errorMessage; + } + + protected: + void enforceOk() const override { + + // Errors shouldn't reach this point, but if they do + // the actual error message will be in m_errorMessage + assert( m_type != ResultType::LogicError ); + assert( m_type != ResultType::RuntimeError ); + if ( m_type != ResultType::Ok ) + std::abort(); + } + + std::string + m_errorMessage; // Only populated if resultType is an error + + BasicResult( ResultType type, + std::string&& message ): + ResultValueBase( type ), m_errorMessage( CATCH_MOVE(message) ) { + assert( m_type != ResultType::Ok ); + } + + using ResultValueBase::ResultValueBase; + using ResultBase::m_type; + }; + + class ParseState { + public: + ParseState( ParseResultType type, + TokenStream remainingTokens ); + + ParseResultType type() const { return m_type; } + TokenStream const& remainingTokens() const& { + return m_remainingTokens; + } + TokenStream&& remainingTokens() && { + return CATCH_MOVE( m_remainingTokens ); + } + + private: + ParseResultType m_type; + TokenStream m_remainingTokens; + }; + + using Result = BasicResult; + using ParserResult = BasicResult; + using InternalParseResult = BasicResult; + + struct HelpColumns { + std::string left; + StringRef descriptions; + }; + + template + ParserResult convertInto( std::string const& source, T& target ) { + std::stringstream ss( source ); + ss >> target; + if ( ss.fail() ) { + return ParserResult::runtimeError( + "Unable to convert '" + source + + "' to destination type" ); + } else { + return ParserResult::ok( ParseResultType::Matched ); + } + } + ParserResult convertInto( std::string const& source, + std::string& target ); + ParserResult convertInto( std::string const& source, bool& target ); + +#ifdef CLARA_CONFIG_OPTIONAL_TYPE + template + auto convertInto( std::string const& source, + CLARA_CONFIG_OPTIONAL_TYPE& target ) + -> ParserResult { + T temp; + auto result = convertInto( source, temp ); + if ( result ) + target = CATCH_MOVE( temp ); + return result; + } +#endif // CLARA_CONFIG_OPTIONAL_TYPE + + struct BoundRef : Catch::Detail::NonCopyable { + virtual ~BoundRef() = default; + virtual bool isContainer() const; + virtual bool isFlag() const; + }; + struct BoundValueRefBase : BoundRef { + virtual auto setValue( std::string const& arg ) + -> ParserResult = 0; + }; + struct BoundFlagRefBase : BoundRef { + virtual auto setFlag( bool flag ) -> ParserResult = 0; + bool isFlag() const override; + }; + + template struct BoundValueRef : BoundValueRefBase { + T& m_ref; + + explicit BoundValueRef( T& ref ): m_ref( ref ) {} + + ParserResult setValue( std::string const& arg ) override { + return convertInto( arg, m_ref ); + } + }; + + template + struct BoundValueRef> : BoundValueRefBase { + std::vector& m_ref; + + explicit BoundValueRef( std::vector& ref ): m_ref( ref ) {} + + auto isContainer() const -> bool override { return true; } + + auto setValue( std::string const& arg ) + -> ParserResult override { + T temp; + auto result = convertInto( arg, temp ); + if ( result ) + m_ref.push_back( temp ); + return result; + } + }; + + struct BoundFlagRef : BoundFlagRefBase { + bool& m_ref; + + explicit BoundFlagRef( bool& ref ): m_ref( ref ) {} + + ParserResult setFlag( bool flag ) override; + }; + + template struct LambdaInvoker { + static_assert( + std::is_same::value, + "Lambda must return void or clara::ParserResult" ); + + template + static auto invoke( L const& lambda, ArgType const& arg ) + -> ParserResult { + return lambda( arg ); + } + }; + + template <> struct LambdaInvoker { + template + static auto invoke( L const& lambda, ArgType const& arg ) + -> ParserResult { + lambda( arg ); + return ParserResult::ok( ParseResultType::Matched ); + } + }; + + template + auto invokeLambda( L const& lambda, std::string const& arg ) + -> ParserResult { + ArgType temp{}; + auto result = convertInto( arg, temp ); + return !result ? result + : LambdaInvoker::ReturnType>::invoke( lambda, temp ); + } + + template struct BoundLambda : BoundValueRefBase { + L m_lambda; + + static_assert( + UnaryLambdaTraits::isValid, + "Supplied lambda must take exactly one argument" ); + explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {} + + auto setValue( std::string const& arg ) + -> ParserResult override { + return invokeLambda::ArgType>( + m_lambda, arg ); + } + }; + + template struct BoundManyLambda : BoundLambda { + explicit BoundManyLambda( L const& lambda ): BoundLambda( lambda ) {} + bool isContainer() const override { return true; } + }; + + template struct BoundFlagLambda : BoundFlagRefBase { + L m_lambda; + + static_assert( + UnaryLambdaTraits::isValid, + "Supplied lambda must take exactly one argument" ); + static_assert( + std::is_same::ArgType, + bool>::value, + "flags must be boolean" ); + + explicit BoundFlagLambda( L const& lambda ): + m_lambda( lambda ) {} + + auto setFlag( bool flag ) -> ParserResult override { + return LambdaInvoker::ReturnType>::invoke( m_lambda, flag ); + } + }; + + enum class Optionality { Optional, Required }; + + class ParserBase { + public: + virtual ~ParserBase() = default; + virtual auto validate() const -> Result { return Result::ok(); } + virtual auto parse( std::string const& exeName, + TokenStream tokens ) const + -> InternalParseResult = 0; + virtual size_t cardinality() const; + + InternalParseResult parse( Args const& args ) const; + }; + + template + class ComposableParserImpl : public ParserBase { + public: + template + auto operator|( T const& other ) const -> Parser; + }; + + // Common code and state for Args and Opts + template + class ParserRefImpl : public ComposableParserImpl { + protected: + Optionality m_optionality = Optionality::Optional; + std::shared_ptr m_ref; + StringRef m_hint; + StringRef m_description; + + explicit ParserRefImpl( std::shared_ptr const& ref ): + m_ref( ref ) {} + + public: + template + ParserRefImpl( accept_many_t, + LambdaT const& ref, + StringRef hint ): + m_ref( std::make_shared>( ref ) ), + m_hint( hint ) {} + + template ::value>> + ParserRefImpl( T& ref, StringRef hint ): + m_ref( std::make_shared>( ref ) ), + m_hint( hint ) {} + + template ::value>> + ParserRefImpl( LambdaT const& ref, StringRef hint ): + m_ref( std::make_shared>( ref ) ), + m_hint( hint ) {} + + DerivedT& operator()( StringRef description ) & { + m_description = description; + return static_cast( *this ); + } + DerivedT&& operator()( StringRef description ) && { + m_description = description; + return static_cast( *this ); + } + + auto optional() -> DerivedT& { + m_optionality = Optionality::Optional; + return static_cast( *this ); + } + + auto required() -> DerivedT& { + m_optionality = Optionality::Required; + return static_cast( *this ); + } + + auto isOptional() const -> bool { + return m_optionality == Optionality::Optional; + } + + auto cardinality() const -> size_t override { + if ( m_ref->isContainer() ) + return 0; + else + return 1; + } + + StringRef hint() const { return m_hint; } + }; + + } // namespace detail + + + // A parser for arguments + class Arg : public Detail::ParserRefImpl { + public: + using ParserRefImpl::ParserRefImpl; + using ParserBase::parse; + + Detail::InternalParseResult + parse(std::string const&, + Detail::TokenStream tokens) const override; + }; + + // A parser for options + class Opt : public Detail::ParserRefImpl { + protected: + std::vector m_optNames; + + public: + template + explicit Opt(LambdaT const& ref) : + ParserRefImpl( + std::make_shared>(ref)) {} + + explicit Opt(bool& ref); + + template ::value>> + Opt( LambdaT const& ref, StringRef hint ): + ParserRefImpl( ref, hint ) {} + + template + Opt( accept_many_t, LambdaT const& ref, StringRef hint ): + ParserRefImpl( accept_many, ref, hint ) {} + + template ::value>> + Opt( T& ref, StringRef hint ): + ParserRefImpl( ref, hint ) {} + + Opt& operator[]( StringRef optName ) & { + m_optNames.push_back(optName); + return *this; + } + Opt&& operator[]( StringRef optName ) && { + m_optNames.push_back( optName ); + return CATCH_MOVE(*this); + } + + Detail::HelpColumns getHelpColumns() const; + + bool isMatch(StringRef optToken) const; + + using ParserBase::parse; + + Detail::InternalParseResult + parse(std::string const&, + Detail::TokenStream tokens) const override; + + Detail::Result validate() const override; + }; + + // Specifies the name of the executable + class ExeName : public Detail::ComposableParserImpl { + std::shared_ptr m_name; + std::shared_ptr m_ref; + + public: + ExeName(); + explicit ExeName(std::string& ref); + + template + explicit ExeName(LambdaT const& lambda) : ExeName() { + m_ref = std::make_shared>(lambda); + } + + // The exe name is not parsed out of the normal tokens, but is + // handled specially + Detail::InternalParseResult + parse(std::string const&, + Detail::TokenStream tokens) const override; + + std::string const& name() const { return *m_name; } + Detail::ParserResult set(std::string const& newName); + }; + + + // A Combined parser + class Parser : Detail::ParserBase { + mutable ExeName m_exeName; + std::vector m_options; + std::vector m_args; + + public: + + auto operator|=(ExeName const& exeName) -> Parser& { + m_exeName = exeName; + return *this; + } + + auto operator|=(Arg const& arg) -> Parser& { + m_args.push_back(arg); + return *this; + } + + friend Parser& operator|=( Parser& p, Opt const& opt ) { + p.m_options.push_back( opt ); + return p; + } + friend Parser& operator|=( Parser& p, Opt&& opt ) { + p.m_options.push_back( CATCH_MOVE(opt) ); + return p; + } + + Parser& operator|=(Parser const& other); + + template + friend Parser operator|( Parser const& p, T&& rhs ) { + Parser temp( p ); + temp |= rhs; + return temp; + } + + template + friend Parser operator|( Parser&& p, T&& rhs ) { + p |= CATCH_FORWARD(rhs); + return CATCH_MOVE(p); + } + + std::vector getHelpColumns() const; + + void writeToStream(std::ostream& os) const; + + friend auto operator<<(std::ostream& os, Parser const& parser) + -> std::ostream& { + parser.writeToStream(os); + return os; + } + + Detail::Result validate() const override; + + using ParserBase::parse; + Detail::InternalParseResult + parse(std::string const& exeName, + Detail::TokenStream tokens) const override; + }; + + /** + * Wrapper over argc + argv, assumes that the inputs outlive it + */ + class Args { + friend Detail::TokenStream; + StringRef m_exeName; + std::vector m_args; + + public: + Args(int argc, char const* const* argv); + // Helper constructor for testing + Args(std::initializer_list args); + + StringRef exeName() const { return m_exeName; } + }; + + + // Convenience wrapper for option parser that specifies the help option + struct Help : Opt { + Help(bool& showHelpFlag); + }; + + // Result type for parser operation + using Detail::ParserResult; + + namespace Detail { + template + template + Parser + ComposableParserImpl::operator|(T const& other) const { + return Parser() | static_cast(*this) | other; + } + } + + } // namespace Clara +} // namespace Catch + +#if defined( __clang__ ) +# pragma clang diagnostic pop +#endif + +#if defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif + +#endif // CATCH_CLARA_HPP_INCLUDED + +namespace Catch { + + struct ConfigData; + + Clara::Parser makeCommandLineParser( ConfigData& config ); + +} // end namespace Catch + +#endif // CATCH_COMMANDLINE_HPP_INCLUDED + +namespace Catch { + + class Session : Detail::NonCopyable { + public: + + Session(); + ~Session(); + + void showHelp() const; + void libIdentify(); + + int applyCommandLine( int argc, char const * const * argv ); + #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE) + int applyCommandLine( int argc, wchar_t const * const * argv ); + #endif + + void useConfigData( ConfigData const& configData ); + + template + int run(int argc, CharT const * const argv[]) { + if (m_startupExceptions) + return 1; + int returnCode = applyCommandLine(argc, argv); + if (returnCode == 0) + returnCode = run(); + return returnCode; + } + + int run(); + + Clara::Parser const& cli() const; + void cli( Clara::Parser const& newParser ); + ConfigData& configData(); + Config& config(); + private: + int runInternal(); + + Clara::Parser m_cli; + ConfigData m_configData; + Detail::unique_ptr m_config; + bool m_startupExceptions = false; + }; + +} // end namespace Catch + +#endif // CATCH_SESSION_HPP_INCLUDED + + +#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED +#define CATCH_TAG_ALIAS_HPP_INCLUDED + + +#include + +namespace Catch { + + struct TagAlias { + TagAlias(std::string const& _tag, SourceLineInfo _lineInfo): + tag(_tag), + lineInfo(_lineInfo) + {} + + std::string tag; + SourceLineInfo lineInfo; + }; + +} // end namespace Catch + +#endif // CATCH_TAG_ALIAS_HPP_INCLUDED + + +#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED +#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED + + +namespace Catch { + + struct RegistrarForTagAliases { + RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + }; + +} // end namespace Catch + +#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED + + +#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED +#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED + +// We need this suppression to leak, because it took until GCC 10 +// for the front end to handle local suppression via _Pragma properly +// inside templates (so `TEMPLATE_TEST_CASE` and co). +// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT** +#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10 +#pragma GCC diagnostic ignored "-Wparentheses" +#endif + + + + +#ifndef CATCH_TEST_MACROS_HPP_INCLUDED +#define CATCH_TEST_MACROS_HPP_INCLUDED + + + +#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED +#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED + + + +#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED +#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED + + + +#ifndef CATCH_DECOMPOSER_HPP_INCLUDED +#define CATCH_DECOMPOSER_HPP_INCLUDED + + + +#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED +#define CATCH_COMPARE_TRAITS_HPP_INCLUDED + + +#include + +namespace Catch { + namespace Detail { + +#if defined( __GNUC__ ) && !defined( __clang__ ) +# pragma GCC diagnostic push + // GCC likes to complain about comparing bool with 0, in the decltype() + // that defines the comparable traits below. +# pragma GCC diagnostic ignored "-Wbool-compare" + // "ordered comparison of pointer with integer zero" same as above, + // but it does not have a separate warning flag to suppress +# pragma GCC diagnostic ignored "-Wextra" + // Did you know that comparing floats with `0` directly + // is super-duper dangerous in unevaluated context? +# pragma GCC diagnostic ignored "-Wfloat-equal" +#endif + +#if defined( __clang__ ) +# pragma clang diagnostic push + // Did you know that comparing floats with `0` directly + // is super-duper dangerous in unevaluated context? +# pragma clang diagnostic ignored "-Wfloat-equal" +#endif + +#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \ + template \ + struct is_##id##_comparable : std::false_type {}; \ + template \ + struct is_##id##_comparable< \ + T, \ + U, \ + void_t() op std::declval() )>> \ + : std::true_type {}; \ + template \ + struct is_##id##_0_comparable : std::false_type {}; \ + template \ + struct is_##id##_0_comparable() op 0 )>> \ + : std::true_type {}; + + // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, != + CATCH_DEFINE_COMPARABLE_TRAIT( lt, < ) + CATCH_DEFINE_COMPARABLE_TRAIT( le, <= ) + CATCH_DEFINE_COMPARABLE_TRAIT( gt, > ) + CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= ) + CATCH_DEFINE_COMPARABLE_TRAIT( eq, == ) + CATCH_DEFINE_COMPARABLE_TRAIT( ne, != ) + +#undef CATCH_DEFINE_COMPARABLE_TRAIT + +#if defined( __GNUC__ ) && !defined( __clang__ ) +# pragma GCC diagnostic pop +#endif +#if defined( __clang__ ) +# pragma clang diagnostic pop +#endif + + + } // namespace Detail +} // namespace Catch + +#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED + + +#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED +#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED + +#include + +namespace Catch { +namespace Detail { + +#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510 + + using std::conjunction; + using std::disjunction; + using std::negation; + +#else + + template struct conjunction : std::true_type {}; + template struct conjunction : B1 {}; + template + struct conjunction + : std::conditional_t, B1> {}; + + template struct disjunction : std::false_type {}; + template struct disjunction : B1 {}; + template + struct disjunction + : std::conditional_t> {}; + + template + struct negation : std::integral_constant {}; + +#endif + +} // namespace Detail +} // namespace Catch + +#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED + +#include +#include + +/** \file + * Why does decomposing look the way it does: + * + * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into + * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first, + * and our custom operator is used for `a == b`, because `a` is transformed + * into `ExprLhs` and then into `BinaryExpr`. + * + * In practice, decomposing ends up a mess, because we have to support + * various fun things. + * + * 1) Types that are only comparable with literal 0, and they do this by + * comparing against a magic type with pointer constructor and deleted + * other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++ + * + * 2) Types that are only comparable with literal 0, and they do this by + * comparing against a magic type with consteval integer constructor. + * Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL. + * + * 3) Types that have no linkage, and so we cannot form a reference to + * them. Example: some implementations of traits. + * + * 4) Starting with C++20, when the compiler sees `a == b`, it also uses + * `b == a` when constructing the overload set. For us this means that + * when the compiler handles `ExprLhs == b`, it also tries to resolve + * the overload set for `b == ExprLhs`. + * + * To accomodate these use cases, decomposer ended up rather complex. + * + * 1) These types are handled by adding SFINAE overloads to our comparison + * operators, checking whether `T == U` are comparable with the given + * operator, and if not, whether T (or U) are comparable with literal 0. + * If yes, the overload compares T (or U) with 0 literal inline in the + * definition. + * + * Note that for extra correctness, we check that the other type is + * either an `int` (literal 0 is captured as `int` by templates), or + * a `long` (some platforms use 0L for `NULL` and we want to support + * that for pointer comparisons). + * + * 2) For these types, `is_foo_comparable` is true, but letting + * them fall into the overload that actually does `T == int` causes + * compilation error. Handling them requires that the decomposition + * is `constexpr`, so that P2564R3 applies and the `consteval` from + * their accompanying magic type is propagated through the `constexpr` + * call stack. + * + * However this is not enough to handle these types automatically, + * because our default is to capture types by reference, to avoid + * runtime copies. While these references cannot become dangling, + * they outlive the constexpr context and thus the default capture + * path cannot be actually constexpr. + * + * The solution is to capture these types by value, by explicitly + * specializing `Catch::capture_by_value` for them. Catch2 provides + * specialization for `std::foo_ordering`s, but users can specialize + * the trait for their own types as well. + * + * 3) If a type has no linkage, we also cannot capture it by reference. + * The solution is once again to capture them by value. We handle + * the common cases by using `std::is_arithmetic` as the default + * for `Catch::capture_by_value`, but that is only a some-effort + * heuristic. But as with 2), users can specialize `capture_by_value` + * for their own types as needed. + * + * 4) To support C++20 and make the SFINAE on our decomposing operators + * work, the SFINAE has to happen in return type, rather than in + * a template type. This is due to our use of logical type traits + * (`conjunction`/`disjunction`/`negation`), that we use to workaround + * an issue in older (9-) versions of GCC. I still blame C++20 for + * this, because without the comparison order switching, the logical + * traits could still be used in template type. + * + * There are also other side concerns, e.g. supporting both `REQUIRE(a)` + * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot + * nicely into the same expression handling logic, but these are rather + * straightforward and add only a bit of complexity (e.g. common base + * class for decomposed expressions). + */ + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4389) // '==' : signed/unsigned mismatch +#pragma warning(disable:4018) // more "signed/unsigned mismatch" +#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform) +#pragma warning(disable:4180) // qualifier applied to function type has no meaning +#pragma warning(disable:4800) // Forcing result to true or false +#endif + +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wsign-compare" +# pragma clang diagnostic ignored "-Wnon-virtual-dtor" +#elif defined __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wsign-compare" +# pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#endif + +#if defined(CATCH_CPP20_OR_GREATER) && __has_include() +# include +# if defined( __cpp_lib_three_way_comparison ) && \ + __cpp_lib_three_way_comparison >= 201907L +# define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS +# endif +#endif + +namespace Catch { + + namespace Detail { + // This was added in C++20, but we require only C++14 for now. + template + using RemoveCVRef_t = std::remove_cv_t>; + } + + // Note: There is nothing that stops us from extending this, + // e.g. to `std::is_scalar`, but the more encompassing + // traits are usually also more expensive. For now we + // keep this as it used to be and it can be changed later. + template + struct capture_by_value + : std::integral_constant{}> {}; + +#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS ) + template <> + struct capture_by_value : std::true_type {}; + template <> + struct capture_by_value : std::true_type {}; + template <> + struct capture_by_value : std::true_type {}; +#endif + + template + struct always_false : std::false_type {}; + + class ITransientExpression { + bool m_isBinaryExpression; + bool m_result; + + protected: + ~ITransientExpression() = default; + + public: + constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; } + constexpr auto getResult() const -> bool { return m_result; } + //! This function **has** to be overriden by the derived class. + virtual void streamReconstructedExpression( std::ostream& os ) const; + + constexpr ITransientExpression( bool isBinaryExpression, bool result ) + : m_isBinaryExpression( isBinaryExpression ), + m_result( result ) + {} + + constexpr ITransientExpression( ITransientExpression const& ) = default; + constexpr ITransientExpression& operator=( ITransientExpression const& ) = default; + + friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) { + expr.streamReconstructedExpression(out); + return out; + } + }; + + void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ); + + template + class BinaryExpr : public ITransientExpression { + LhsT m_lhs; + StringRef m_op; + RhsT m_rhs; + + void streamReconstructedExpression( std::ostream &os ) const override { + formatReconstructedExpression + ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) ); + } + + public: + constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs ) + : ITransientExpression{ true, comparisonResult }, + m_lhs( lhs ), + m_op( op ), + m_rhs( rhs ) + {} + + template + auto operator && ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator || ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator == ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator != ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator > ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator < ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator >= ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + auto operator <= ( T ) const -> BinaryExpr const { + static_assert(always_false::value, + "chained comparisons are not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + }; + + template + class UnaryExpr : public ITransientExpression { + LhsT m_lhs; + + void streamReconstructedExpression( std::ostream &os ) const override { + os << Catch::Detail::stringify( m_lhs ); + } + + public: + explicit constexpr UnaryExpr( LhsT lhs ) + : ITransientExpression{ false, static_cast(lhs) }, + m_lhs( lhs ) + {} + }; + + + template + class ExprLhs { + LhsT m_lhs; + public: + explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {} + +#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction, \ + Detail::negation>>>::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction, \ + capture_by_value>::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction< \ + Detail::negation>, \ + Detail::is_eq_0_comparable, \ + /* We allow long because we want `ptr op NULL` to be accepted */ \ + Detail::disjunction, \ + std::is_same>>::value, \ + BinaryExpr> { \ + if ( rhs != 0 ) { throw_test_failure_exception(); } \ + return { \ + static_cast( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction< \ + Detail::negation>, \ + Detail::is_eq_0_comparable, \ + /* We allow long because we want `ptr op NULL` to be accepted */ \ + Detail::disjunction, \ + std::is_same>>::value, \ + BinaryExpr> { \ + if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \ + return { static_cast( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } + + CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == ) + CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != ) + + #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR + + +#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction, \ + Detail::negation>>>::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction, \ + capture_by_value>::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction< \ + Detail::negation>, \ + Detail::is_##id##_0_comparable, \ + std::is_same>::value, \ + BinaryExpr> { \ + if ( rhs != 0 ) { throw_test_failure_exception(); } \ + return { \ + static_cast( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t< \ + Detail::conjunction< \ + Detail::negation>, \ + Detail::is_##id##_0_comparable, \ + std::is_same>::value, \ + BinaryExpr> { \ + if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \ + return { static_cast( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } + + CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < ) + CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= ) + CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > ) + CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= ) + + #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR + + +#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \ + -> std::enable_if_t< \ + !capture_by_value>::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } \ + template \ + constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \ + -> std::enable_if_t::value, \ + BinaryExpr> { \ + return { \ + static_cast( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \ + } + + CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|) + CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&) + CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^) + + #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR + + template + friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr { + static_assert(always_false::value, + "operator&& is not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + template + friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr { + static_assert(always_false::value, + "operator|| is not supported inside assertions, " + "wrap the expression inside parentheses, or decompose it"); + } + + constexpr auto makeUnaryExpr() const -> UnaryExpr { + return UnaryExpr{ m_lhs }; + } + }; + + struct Decomposer { + template >::value, + int> = 0> + constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs { + return ExprLhs{ lhs }; + } + + template ::value, int> = 0> + constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs { + return ExprLhs{ value }; + } + }; + +} // end namespace Catch + +#ifdef _MSC_VER +#pragma warning(pop) +#endif +#ifdef __clang__ +# pragma clang diagnostic pop +#elif defined __GNUC__ +# pragma GCC diagnostic pop +#endif + +#endif // CATCH_DECOMPOSER_HPP_INCLUDED + +#include + +namespace Catch { + + struct AssertionReaction { + bool shouldDebugBreak = false; + bool shouldThrow = false; + bool shouldSkip = false; + }; + + class AssertionHandler { + AssertionInfo m_assertionInfo; + AssertionReaction m_reaction; + bool m_completed = false; + IResultCapture& m_resultCapture; + + public: + AssertionHandler + ( StringRef macroName, + SourceLineInfo const& lineInfo, + StringRef capturedExpression, + ResultDisposition::Flags resultDisposition ); + ~AssertionHandler() { + if ( !m_completed ) { + m_resultCapture.handleIncomplete( m_assertionInfo ); + } + } + + + template + constexpr void handleExpr( ExprLhs const& expr ) { + handleExpr( expr.makeUnaryExpr() ); + } + void handleExpr( ITransientExpression const& expr ); + + void handleMessage(ResultWas::OfType resultType, std::string&& message); + + void handleExceptionThrownAsExpected(); + void handleUnexpectedExceptionNotThrown(); + void handleExceptionNotThrownAsExpected(); + void handleThrowingCallSkipped(); + void handleUnexpectedInflightException(); + + void complete(); + + // query + auto allowThrows() const -> bool; + }; + + void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ); + +} // namespace Catch + +#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED + + +#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED +#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED + + +#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION) + #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr +#else + #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr +#endif + +#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED + +// We need this suppression to leak, because it took until GCC 10 +// for the front end to handle local suppression via _Pragma properly +#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9 + #pragma GCC diagnostic ignored "-Wparentheses" +#endif + +#if !defined(CATCH_CONFIG_DISABLE) + +#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) + +/////////////////////////////////////////////////////////////////////////////// +// Another way to speed-up compilation is to omit local try-catch for REQUIRE* +// macros. +#define INTERNAL_CATCH_TRY +#define INTERNAL_CATCH_CATCH( capturer ) + +#else // CATCH_CONFIG_FAST_COMPILE + +#define INTERNAL_CATCH_TRY try +#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); } + +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \ + do { /* NOLINT(bugprone-infinite-loop) */ \ + /* The expression should not be evaluated, but warnings should hopefully be checked */ \ + CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \ + INTERNAL_CATCH_TRY { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \ + catchAssertionHandler.complete(); \ + } while( (void)0, (false) && static_cast( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look + // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&. + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \ + INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \ + if( Catch::getResultCapture().lastAssertionPassed() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \ + INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \ + if( !Catch::getResultCapture().lastAssertionPassed() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \ + do { \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \ + try { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \ + static_cast(__VA_ARGS__); \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + catchAssertionHandler.handleExceptionNotThrownAsExpected(); \ + } \ + catch( ... ) { \ + catchAssertionHandler.handleUnexpectedInflightException(); \ + } \ + catchAssertionHandler.complete(); \ + } while( false ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \ + do { \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \ + if( catchAssertionHandler.allowThrows() ) \ + try { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \ + CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \ + static_cast(__VA_ARGS__); \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \ + } \ + catch( ... ) { \ + catchAssertionHandler.handleExceptionThrownAsExpected(); \ + } \ + else \ + catchAssertionHandler.handleThrowingCallSkipped(); \ + catchAssertionHandler.complete(); \ + } while( false ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \ + do { \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \ + if( catchAssertionHandler.allowThrows() ) \ + try { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \ + CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \ + static_cast(expr); \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \ + } \ + catch( exceptionType const& ) { \ + catchAssertionHandler.handleExceptionThrownAsExpected(); \ + } \ + catch( ... ) { \ + catchAssertionHandler.handleUnexpectedInflightException(); \ + } \ + else \ + catchAssertionHandler.handleThrowingCallSkipped(); \ + catchAssertionHandler.complete(); \ + } while( false ) + + + +/////////////////////////////////////////////////////////////////////////////// +// Although this is matcher-based, it can be used with just a string +#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \ + do { \ + Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \ + if( catchAssertionHandler.allowThrows() ) \ + try { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \ + CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \ + static_cast(__VA_ARGS__); \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \ + } \ + catch( ... ) { \ + Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \ + } \ + else \ + catchAssertionHandler.handleThrowingCallSkipped(); \ + catchAssertionHandler.complete(); \ + } while( false ) + +#endif // CATCH_CONFIG_DISABLE + +#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED + + +#ifndef CATCH_SECTION_HPP_INCLUDED +#define CATCH_SECTION_HPP_INCLUDED + + + + +/** \file + * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option + * + * Some of Catch2's macros can be defined differently to work better with + * static analysis tools, like clang-tidy or coverity. + * Currently the main use case is to show that `SECTION`s are executed + * exclusively, and not all in one run of a `TEST_CASE`. + */ + +#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED +#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED + + +#if defined(__clang_analyzer__) || defined(__COVERITY__) + #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT +#endif + +#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \ + !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \ + !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) +# define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT +#endif + + +#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED + + +#ifndef CATCH_TIMER_HPP_INCLUDED +#define CATCH_TIMER_HPP_INCLUDED + +#include + +namespace Catch { + + class Timer { + uint64_t m_nanoseconds = 0; + public: + void start(); + auto getElapsedNanoseconds() const -> uint64_t; + auto getElapsedMicroseconds() const -> uint64_t; + auto getElapsedMilliseconds() const -> unsigned int; + auto getElapsedSeconds() const -> double; + }; + +} // namespace Catch + +#endif // CATCH_TIMER_HPP_INCLUDED + +namespace Catch { + + class Section : Detail::NonCopyable { + public: + Section( SectionInfo&& info ); + Section( SourceLineInfo const& _lineInfo, + StringRef _name, + const char* const = nullptr ); + ~Section(); + + // This indicates whether the section should be executed or not + explicit operator bool() const; + + private: + SectionInfo m_info; + + Counts m_assertions; + bool m_sectionIncluded; + Timer m_timer; + }; + +} // end namespace Catch + +#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT) +# define INTERNAL_CATCH_SECTION( ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \ + catch_internal_Section ) = \ + Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \ + catch_internal_Section ) = \ + Catch::SectionInfo( \ + CATCH_INTERNAL_LINEINFO, \ + ( Catch::ReusableStringStream() << __VA_ARGS__ ) \ + .str() ) ) \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +#else + +// These section definitions imply that at most one section at one level +// will be intered (because only one section's __LINE__ can be equal to +// the dummy `catchInternalSectionHint` variable from `TEST_CASE`). + +namespace Catch { + namespace Detail { + // Intentionally without linkage, as it should only be used as a dummy + // symbol for static analysis. + // The arguments are used as a dummy for checking warnings in the passed + // expressions. + int GetNewSectionHint( StringRef, const char* const = nullptr ); + } // namespace Detail +} // namespace Catch + + +# define INTERNAL_CATCH_SECTION( ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \ + if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \ + catchInternalSectionHint, \ + catchInternalSectionHint = \ + Catch::Detail::GetNewSectionHint(__VA_ARGS__); \ + catchInternalPreviousSectionHint == __LINE__ ) \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \ + if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \ + catchInternalSectionHint, \ + catchInternalSectionHint = Catch::Detail::GetNewSectionHint( \ + ( Catch::ReusableStringStream() << __VA_ARGS__ ).str()); \ + catchInternalPreviousSectionHint == __LINE__ ) \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +#endif + + +#endif // CATCH_SECTION_HPP_INCLUDED + + +#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED +#define CATCH_TEST_REGISTRY_HPP_INCLUDED + + + +#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED +#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED + +namespace Catch { + + class ITestInvoker { + public: + virtual void prepareTestCase(); + virtual void tearDownTestCase(); + virtual void invoke() const = 0; + virtual ~ITestInvoker(); // = default + }; + +} // namespace Catch + +#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED + + +#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED +#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED + +#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param ) +#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__ +#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__ +#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF + +#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \ + INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ ) + +#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED + +// GCC 5 and older do not properly handle disabling unused-variable warning +// with a _Pragma. This means that we have to leak the suppression to the +// user code as well :-( +#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5 +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + + + +namespace Catch { + +template +class TestInvokerAsMethod : public ITestInvoker { + void (C::*m_testAsMethod)(); +public: + constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept: + m_testAsMethod( testAsMethod ) {} + + void invoke() const override { + C obj; + (obj.*m_testAsMethod)(); + } +}; + +Detail::unique_ptr makeTestInvoker( void(*testAsFunction)() ); + +template +Detail::unique_ptr makeTestInvoker( void (C::*testAsMethod)() ) { + return Detail::make_unique>( testAsMethod ); +} + +template +class TestInvokerFixture : public ITestInvoker { + void ( C::*m_testAsMethod )() const; + Detail::unique_ptr m_fixture = nullptr; + +public: + constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept: + m_testAsMethod( testAsMethod ) {} + + void prepareTestCase() override { + m_fixture = Detail::make_unique(); + } + + void tearDownTestCase() override { + m_fixture.reset(); + } + + void invoke() const override { + auto* f = m_fixture.get(); + ( f->*m_testAsMethod )(); + } +}; + +template +Detail::unique_ptr makeTestInvokerFixture( void ( C::*testAsMethod )() const ) { + return Detail::make_unique>( testAsMethod ); +} + +struct NameAndTags { + constexpr NameAndTags( StringRef name_ = StringRef(), + StringRef tags_ = StringRef() ) noexcept: + name( name_ ), tags( tags_ ) {} + StringRef name; + StringRef tags; +}; + +struct AutoReg : Detail::NonCopyable { + AutoReg( Detail::unique_ptr invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept; +}; + +} // end namespace Catch + +#if defined(CATCH_CONFIG_DISABLE) + #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \ + static inline void TestName() + #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \ + namespace{ \ + struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \ + void test(); \ + }; \ + } \ + void TestName::test() +#endif + + +#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \ + static void TestName(); \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + static void TestName() + #define INTERNAL_CATCH_TESTCASE( ... ) \ + INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ ) + +#else // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT + + +// Dummy registrator for the dumy test case macros +namespace Catch { + namespace Detail { + struct DummyUse { + DummyUse( void ( * )( int ), Catch::NameAndTags const& ); + }; + } // namespace Detail +} // namespace Catch + +// Note that both the presence of the argument and its exact name are +// necessary for the section support. + +// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE` +// tests can compile. The redefined `TEST_CASE` shadows this with param. +static int catchInternalSectionHint = 0; + +# define INTERNAL_CATCH_TESTCASE2( fname, ... ) \ + static void fname( int ); \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME( \ + dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } ); \ + CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \ + static void fname( [[maybe_unused]] int catchInternalSectionHint ) \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION +# define INTERNAL_CATCH_TESTCASE( ... ) \ + INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ ) + + +#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + namespace{ \ + struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \ + void test(); \ + }; \ + const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \ + Catch::makeTestInvoker( &TestName::test ), \ + CATCH_INTERNAL_LINEINFO, \ + #ClassName##_catch_sr, \ + Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \ + } \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + void TestName::test() + #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \ + INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ ) + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + namespace { \ + struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) { \ + void test() const; \ + }; \ + const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \ + Catch::makeTestInvokerFixture( &TestName::test ), \ + CATCH_INTERNAL_LINEINFO, \ + #ClassName##_catch_sr, \ + Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \ + } \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + void TestName::test() const + #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... ) \ + INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ ) + + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + namespace { \ + const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \ + Catch::makeTestInvoker( &QualifiedMethod ), \ + CATCH_INTERNAL_LINEINFO, \ + "&" #QualifiedMethod##_catch_sr, \ + Catch::NameAndTags{ __VA_ARGS__ } ); \ + } /* NOLINT */ \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \ + do { \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \ + } while(false) + + +#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED + + +// All of our user-facing macros support configuration toggle, that +// forces them to be defined prefixed with CATCH_. We also like to +// support another toggle that can minimize (disable) their implementation. +// Given this, we have 4 different configuration options below + +#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) + + #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ ) + + #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr ) + #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + + #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ ) + #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + + #define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr ) + #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + + #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ ) + #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) + #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ ) + #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ ) + + + #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE) + #define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ ) + #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ ) + #define CATCH_STATIC_CHECK( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ ) + #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ ) + #else + #define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ ) + #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ ) + #define CATCH_STATIC_CHECK( ... ) CATCH_CHECK( __VA_ARGS__ ) + #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ ) + #endif + + + // "BDD-style" convenience wrappers + #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) + #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) + #define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc ) + #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc ) + #define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc ) + #define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc ) + #define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc ) + #define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc ) + +#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled + + #define CATCH_REQUIRE( ... ) (void)(0) + #define CATCH_REQUIRE_FALSE( ... ) (void)(0) + + #define CATCH_REQUIRE_THROWS( ... ) (void)(0) + #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0) + #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0) + + #define CATCH_CHECK( ... ) (void)(0) + #define CATCH_CHECK_FALSE( ... ) (void)(0) + #define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__) + #define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__)) + #define CATCH_CHECK_NOFAIL( ... ) (void)(0) + + #define CATCH_CHECK_THROWS( ... ) (void)(0) + #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0) + #define CATCH_CHECK_NOTHROW( ... ) (void)(0) + + #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ )) + #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ )) + #define CATCH_METHOD_AS_TEST_CASE( method, ... ) + #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ )) + #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0) + #define CATCH_SECTION( ... ) + #define CATCH_DYNAMIC_SECTION( ... ) + #define CATCH_FAIL( ... ) (void)(0) + #define CATCH_FAIL_CHECK( ... ) (void)(0) + #define CATCH_SUCCEED( ... ) (void)(0) + #define CATCH_SKIP( ... ) (void)(0) + + #define CATCH_STATIC_REQUIRE( ... ) (void)(0) + #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0) + #define CATCH_STATIC_CHECK( ... ) (void)(0) + #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0) + + // "BDD-style" convenience wrappers + #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ )) + #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className ) + #define CATCH_GIVEN( desc ) + #define CATCH_AND_GIVEN( desc ) + #define CATCH_WHEN( desc ) + #define CATCH_AND_WHEN( desc ) + #define CATCH_THEN( desc ) + #define CATCH_AND_THEN( desc ) + +#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented + + #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ ) + + #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr ) + #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ ) + + #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ ) + #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ ) + + #define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr ) + #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + + #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ ) + #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) + #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ ) + #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ ) + + + #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE) + #define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ ) + #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" ) + #define STATIC_CHECK( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ ) + #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" ) + #else + #define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ ) + #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ ) + #define STATIC_CHECK( ... ) CHECK( __VA_ARGS__ ) + #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ ) + #endif + + // "BDD-style" convenience wrappers + #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) + #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) + #define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc ) + #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc ) + #define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc ) + #define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc ) + #define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc ) + #define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc ) + +#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled + + #define REQUIRE( ... ) (void)(0) + #define REQUIRE_FALSE( ... ) (void)(0) + + #define REQUIRE_THROWS( ... ) (void)(0) + #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0) + #define REQUIRE_NOTHROW( ... ) (void)(0) + + #define CHECK( ... ) (void)(0) + #define CHECK_FALSE( ... ) (void)(0) + #define CHECKED_IF( ... ) if (__VA_ARGS__) + #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__)) + #define CHECK_NOFAIL( ... ) (void)(0) + + #define CHECK_THROWS( ... ) (void)(0) + #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0) + #define CHECK_NOTHROW( ... ) (void)(0) + + #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__) + #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ )) + #define METHOD_AS_TEST_CASE( method, ... ) + #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__) + #define REGISTER_TEST_CASE( Function, ... ) (void)(0) + #define SECTION( ... ) + #define DYNAMIC_SECTION( ... ) + #define FAIL( ... ) (void)(0) + #define FAIL_CHECK( ... ) (void)(0) + #define SUCCEED( ... ) (void)(0) + #define SKIP( ... ) (void)(0) + + #define STATIC_REQUIRE( ... ) (void)(0) + #define STATIC_REQUIRE_FALSE( ... ) (void)(0) + #define STATIC_CHECK( ... ) (void)(0) + #define STATIC_CHECK_FALSE( ... ) (void)(0) + + // "BDD-style" convenience wrappers + #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) ) + #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className ) + + #define GIVEN( desc ) + #define AND_GIVEN( desc ) + #define WHEN( desc ) + #define AND_WHEN( desc ) + #define THEN( desc ) + #define AND_THEN( desc ) + +#endif // ^^ unprefixed, disabled + +// end of user facing macros + +#endif // CATCH_TEST_MACROS_HPP_INCLUDED + + +#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED +#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED + + + +#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED +#define CATCH_PREPROCESSOR_HPP_INCLUDED + + +#if defined(__GNUC__) +// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work +#pragma GCC system_header +#endif + + +#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ +#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) + +#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ +// MSVC needs more evaluations +#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) +#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) +#else +#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) +#endif + +#define CATCH_REC_END(...) +#define CATCH_REC_OUT + +#define CATCH_EMPTY() +#define CATCH_DEFER(id) id CATCH_EMPTY() + +#define CATCH_REC_GET_END2() 0, CATCH_REC_END +#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 +#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 +#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT +#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) +#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) + +#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) + +#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) + +// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, +// and passes userdata as the first parameter to each invocation, +// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) +#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) + +#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) + +#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) +#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ +#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) +#else +// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF +#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) +#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ +#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) +#endif + +#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ +#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) + +#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) +#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) +#else +#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) +#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) +#endif + +#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ + CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) + +#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) +#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) +#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) +#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) +#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) +#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) +#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6) +#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) +#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) +#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) +#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) + +#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N + +#define INTERNAL_CATCH_TYPE_GEN\ + template struct TypeList {};\ + template\ + constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ + template class...> struct TemplateTypeList{};\ + template class...Cs>\ + constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ + template\ + struct append;\ + template\ + struct rewrap;\ + template class, typename...>\ + struct create;\ + template class, typename>\ + struct convert;\ + \ + template \ + struct append { using type = T; };\ + template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ + struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ + template< template class L1, typename...E1, typename...Rest>\ + struct append, TypeList, Rest...> { using type = L1; };\ + \ + template< template class Container, template class List, typename...elems>\ + struct rewrap, List> { using type = TypeList>; };\ + template< template class Container, template class List, class...Elems, typename...Elements>\ + struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ + \ + template