[{"data":1,"prerenderedAt":1151},["ShallowReactive",2],{"doc-progmasoft-catch3":3},{"id":4,"title":5,"body":6,"description":1142,"extension":1143,"meta":1144,"navigation":99,"path":1145,"seo":1146,"slug":1147,"source":1148,"stem":1149,"__hash__":1150},"docs\u002Fdocs\u002Fprogmasoft-catch3.md","Progmasoft Catch3 additions",{"type":7,"value":8,"toc":1132},"minimark",[9,13,36,41,62,72,264,267,330,339,346,360,388,392,395,593,624,635,645,652,656,666,681,738,742,787,794,798,810,839,880,891,894,903,913,920,931,951,983,990,994,997,1006,1009,1102,1117,1121,1128],[10,11,5],"h1",{"id":12},"progmasoft-catch3-additions",[14,15,16,17,21,22,27,28,31,32,35],"p",{},"Progmasoft Catch3 keeps Catch2's API for writing tests, its macros and the\n",[18,19,20],"code",{},"Catch::"," namespace, and replaces Catch2's runner with its own. The\n",[23,24,26],"a",{"href":25},"\u002Fdocs\u002Fprogmasoft-runner\u002F","Catch3 runner"," runs tests in parallel worker\nprocesses and adds retries, flaky-test detection, quarantine, history,\npredictive ordering, test selection, sharding, time limits and failure\nanalysis. Every header is in the ",[18,29,30],{},"Progmasoft\u002FCatch3"," include tree; the files\nof the engine that come from Catch2 keep its BSL-1.0 license, and\nProgmasoft's own API is in the ",[18,33,34],{},"Progmasoft::Catch3"," namespace.",[37,38,40],"h2",{"id":39},"property-testing","Property testing",[14,42,43,44,48,49,52,53,56,57,61],{},"Catch3 has two property APIs. ",[23,45,47],{"href":46},"\u002Fdocs\u002Fprogmasoft-properties\u002F","Native property testing","\nwith ",[18,50,51],{},"ForAll"," and strategies is the full engine: every combination of\nstrategies shrinks, failures replay from a token and from an example database,\nand it adds state machines, statistics, targeted search and differential and\nmetamorphic oracles. New tests should use it. The value-shrinking\n",[18,54,55],{},"CheckProperty"," API described here remains supported for existing tests.\n",[23,58,60],{"href":59},"\u002Fdocs\u002Fprogmasoft-roadmap\u002F","The roadmap"," lists what comes next.",[14,63,64,67,68,71],{},[18,65,66],{},"\u003CProgmasoft\u002FCatch3.hpp>"," is the umbrella header. It brings in the engine's\n",[18,69,70],{},"Progmasoft\u002FCatch3\u002FAll.hpp"," as well as the Progmasoft extensions, so it is convenient but\nincreases compile time. Include individual headers when a translation unit only\nneeds a narrow part of the API.",[73,74,79],"pre",{"className":75,"code":76,"language":77,"meta":78,"style":78},"language-cpp shiki shiki-themes github-dark","#include \u003CProgmasoft\u002FCatch3.hpp>\n\nTEST_CASE(\"integer values stay in their requested domain\", \"[property]\") {\n    CATCH3_CHECK_PROPERTY(\n        Progmasoft::Catch3::Integer\u003Cint>(1, 100),\n        [](int value) { return value > 0; },\n        Progmasoft::Catch3::PropertyOptions{\n            .Trials = 250,\n            .Seed = 0xC0FFEE,\n            .MaxShrinkSteps = 200});\n}\n","cpp","",[18,80,81,94,101,124,133,171,201,213,228,244,258],{"__ignoreMap":78},[82,83,86,90],"span",{"class":84,"line":85},"line",1,[82,87,89],{"class":88},"snl16","#include",[82,91,93],{"class":92},"sU2Wk"," \u003CProgmasoft\u002FCatch3.hpp>\n",[82,95,97],{"class":84,"line":96},2,[82,98,100],{"emptyLinePlaceholder":99},true,"\n",[82,102,104,108,112,115,118,121],{"class":84,"line":103},3,[82,105,107],{"class":106},"svObZ","TEST_CASE",[82,109,111],{"class":110},"s95oV","(",[82,113,114],{"class":92},"\"integer values stay in their requested domain\"",[82,116,117],{"class":110},", ",[82,119,120],{"class":92},"\"[property]\"",[82,122,123],{"class":110},") {\n",[82,125,127,130],{"class":84,"line":126},4,[82,128,129],{"class":106},"    CATCH3_CHECK_PROPERTY",[82,131,132],{"class":110},"(\n",[82,134,136,139,142,145,147,150,153,156,159,163,165,168],{"class":84,"line":135},5,[82,137,138],{"class":106},"        Progmasoft",[82,140,141],{"class":110},"::",[82,143,144],{"class":106},"Catch3",[82,146,141],{"class":110},[82,148,149],{"class":106},"Integer",[82,151,152],{"class":110},"\u003C",[82,154,155],{"class":88},"int",[82,157,158],{"class":110},">(",[82,160,162],{"class":161},"sDLfK","1",[82,164,117],{"class":110},[82,166,167],{"class":161},"100",[82,169,170],{"class":110},"),\n",[82,172,174,177,179,183,186,189,192,195,198],{"class":84,"line":173},6,[82,175,176],{"class":110},"        [](",[82,178,155],{"class":88},[82,180,182],{"class":181},"s9osk"," value",[82,184,185],{"class":110},") { ",[82,187,188],{"class":88},"return",[82,190,191],{"class":110}," value ",[82,193,194],{"class":88},">",[82,196,197],{"class":161}," 0",[82,199,200],{"class":110},"; },\n",[82,202,204,206,208,210],{"class":84,"line":203},7,[82,205,138],{"class":106},[82,207,141],{"class":110},[82,209,144],{"class":106},[82,211,212],{"class":110},"::PropertyOptions{\n",[82,214,216,219,222,225],{"class":84,"line":215},8,[82,217,218],{"class":110},"            .Trials ",[82,220,221],{"class":88},"=",[82,223,224],{"class":161}," 250",[82,226,227],{"class":110},",\n",[82,229,231,234,236,239,242],{"class":84,"line":230},9,[82,232,233],{"class":110},"            .Seed ",[82,235,221],{"class":88},[82,237,238],{"class":88}," 0x",[82,240,241],{"class":161},"C0FFEE",[82,243,227],{"class":110},[82,245,247,250,252,255],{"class":84,"line":246},10,[82,248,249],{"class":110},"            .MaxShrinkSteps ",[82,251,221],{"class":88},[82,253,254],{"class":161}," 200",[82,256,257],{"class":110},"});\n",[82,259,261],{"class":84,"line":260},11,[82,262,263],{"class":110},"}\n",[14,265,266],{},"The current property API is split into these headers:",[268,269,270,277,283,293,314,320],"ul",{},[271,272,273,276],"li",{},[18,274,275],{},"\u003CProgmasoft\u002FCatch3\u002FRandom.hpp>",": portable SplitMix64 sequence, unbiased\nbounded sampling, inclusive integer ranges, and per-trial seed derivation.",[271,278,279,282],{},[18,280,281],{},"\u003CProgmasoft\u002FCatch3\u002FGenerator.hpp>",": user-defined generation\u002Fshrinking pair.",[271,284,285,288,289,292],{},[18,286,287],{},"\u003CProgmasoft\u002FCatch3\u002FGenerators\u002FInteger.hpp>"," and ",[18,290,291],{},"Boolean.hpp",": built-in\nscalar strategies with deterministic shrink candidates.",[271,294,295,117,298,117,301,304,305,308,309,313],{},[18,296,297],{},"\u003CProgmasoft\u002FCatch3\u002FGenerators\u002FVector.hpp>",[18,299,300],{},"Tuple.hpp",[18,302,303],{},"Element.hpp"," and\n",[18,306,307],{},"Text.hpp",": composite strategies described under\n",[23,310,312],{"href":311},"#composite-generators","Composite generators",".",[271,315,316,319],{},[18,317,318],{},"\u003CProgmasoft\u002FCatch3\u002FProperty.hpp>",": trial execution and structured results.",[271,321,322,325,326,329],{},[18,323,324],{},"\u003CProgmasoft\u002FCatch3\u002FAssertions.hpp>",": ",[18,327,328],{},"CATCH3_CHECK_PROPERTY",", which reports\nthe failing trial, replay seed, reason, and minimized counterexample through\nCatch2's normal assertion\u002Freporting path.",[14,331,332,335,336,313],{},[18,333,334],{},"PropertyOptions::Seed"," is a stable root seed. Each trial receives a seed derived\nfrom the root and its zero-based trial index, so the reported replay seed can be\nused to reproduce that trial independently. The default generator is also stable\nacross standard-library implementations; it does not rely on the implementation-\ndefined output sequence of ",[18,337,338],{},"std::uniform_int_distribution",[14,340,341,342,345],{},"Shrinking is deterministic and greedy: candidates are tested in the order\nprovided by the generator, and the first still-failing candidate is selected.\n",[18,343,344],{},"MaxShrinkSteps"," bounds predicate evaluations during minimization. The result is\ntherefore a useful locally minimized counterexample, not a claim of a globally\nminimal value. A false predicate or an exception from the predicate fails the\nproperty. Exceptions from generation or shrinking are reported as execution\nerrors, distinct from an ordinary failing property.",[14,347,348,349,352,353,288,356,359],{},"A failing report ends with the line\n",[18,350,351],{},"replay: set PropertyOptions::ReplayTrialSeed to \u003Cseed>",". Setting that option\nruns exactly one trial with the given seed, including its shrinking, and\nignores ",[18,354,355],{},"Seed",[18,357,358],{},"Trials","; the reported trial number is then 1. This\nreproduces a failure from a CI log without rerunning the trials before it.",[73,361,363],{"className":75,"code":362,"language":77,"meta":78,"style":78},"Progmasoft::Catch3::PropertyOptions{ .ReplayTrialSeed = 1234567890123456789ULL }\n",[18,364,365],{"__ignoreMap":78},[82,366,367,370,372,374,377,379,382,385],{"class":84,"line":85},[82,368,369],{"class":106},"Progmasoft",[82,371,141],{"class":110},[82,373,144],{"class":106},[82,375,376],{"class":110},"::PropertyOptions{ .ReplayTrialSeed ",[82,378,221],{"class":88},[82,380,381],{"class":161}," 1234567890123456789",[82,383,384],{"class":88},"ULL",[82,386,387],{"class":110}," }\n",[389,390,312],"h3",{"id":391},"composite-generators",[14,393,394],{},"A property still receives one generated value. Several arguments are passed\nas one tuple:",[73,396,398],{"className":75,"code":397,"language":77,"meta":78,"style":78},"using namespace Progmasoft::Catch3;\n\nCATCH3_CHECK_PROPERTY(\n    Tuple(Vector(Integer\u003Cint>(0, 100), 0, 20), Text(\"abc\", 1, 8)),\n    [](const std::tuple\u003Cstd::vector\u003Cint>, std::string> &input) {\n        return Accepts(std::get\u003C0>(input), std::get\u003C1>(input));\n    },\n    PropertyOptions{ .Trials = 500 });\n",[18,399,400,418,422,428,487,538,575,580],{"__ignoreMap":78},[82,401,402,405,408,411,413,415],{"class":84,"line":85},[82,403,404],{"class":88},"using",[82,406,407],{"class":88}," namespace",[82,409,410],{"class":106}," Progmasoft",[82,412,141],{"class":110},[82,414,144],{"class":106},[82,416,417],{"class":110},";\n",[82,419,420],{"class":84,"line":96},[82,421,100],{"emptyLinePlaceholder":99},[82,423,424,426],{"class":84,"line":103},[82,425,328],{"class":106},[82,427,132],{"class":110},[82,429,430,433,435,438,440,442,444,446,448,451,453,455,458,460,462,465,467,470,472,475,477,479,481,484],{"class":84,"line":126},[82,431,432],{"class":106},"    Tuple",[82,434,111],{"class":110},[82,436,437],{"class":106},"Vector",[82,439,111],{"class":110},[82,441,149],{"class":106},[82,443,152],{"class":110},[82,445,155],{"class":88},[82,447,158],{"class":110},[82,449,450],{"class":161},"0",[82,452,117],{"class":110},[82,454,167],{"class":161},[82,456,457],{"class":110},"), ",[82,459,450],{"class":161},[82,461,117],{"class":110},[82,463,464],{"class":161},"20",[82,466,457],{"class":110},[82,468,469],{"class":106},"Text",[82,471,111],{"class":110},[82,473,474],{"class":92},"\"abc\"",[82,476,117],{"class":110},[82,478,162],{"class":161},[82,480,117],{"class":110},[82,482,483],{"class":161},"8",[82,485,486],{"class":110},")),\n",[82,488,489,492,495,498,500,503,505,508,510,513,515,517,520,522,524,527,530,533,536],{"class":84,"line":135},[82,490,491],{"class":110},"    [](",[82,493,494],{"class":88},"const",[82,496,497],{"class":106}," std",[82,499,141],{"class":110},[82,501,502],{"class":106},"tuple",[82,504,152],{"class":110},[82,506,507],{"class":106},"std",[82,509,141],{"class":110},[82,511,512],{"class":106},"vector",[82,514,152],{"class":110},[82,516,155],{"class":88},[82,518,519],{"class":110},">, ",[82,521,507],{"class":106},[82,523,141],{"class":110},[82,525,526],{"class":106},"string",[82,528,529],{"class":110},"> ",[82,531,532],{"class":88},"&",[82,534,535],{"class":181},"input",[82,537,123],{"class":110},[82,539,540,543,546,548,550,552,555,557,559,562,564,566,568,570,572],{"class":84,"line":173},[82,541,542],{"class":88},"        return",[82,544,545],{"class":106}," Accepts",[82,547,111],{"class":110},[82,549,507],{"class":106},[82,551,141],{"class":110},[82,553,554],{"class":106},"get",[82,556,152],{"class":110},[82,558,450],{"class":161},[82,560,561],{"class":110},">(input), ",[82,563,507],{"class":106},[82,565,141],{"class":110},[82,567,554],{"class":106},[82,569,152],{"class":110},[82,571,162],{"class":161},[82,573,574],{"class":110},">(input));\n",[82,576,577],{"class":84,"line":203},[82,578,579],{"class":110},"    },\n",[82,581,582,585,587,590],{"class":84,"line":215},[82,583,584],{"class":110},"    PropertyOptions{ .Trials ",[82,586,221],{"class":88},[82,588,589],{"class":161}," 500",[82,591,592],{"class":110}," });\n",[268,594,595,601,615],{},[271,596,597,600],{},[18,598,599],{},"Tuple(generators...)"," draws its components strictly left to right from the\ntrial's random source and shrinks one component at a time: every candidate\nof the first component, then every candidate of the second, and so on.",[271,602,603,606,607,610,611,614],{},[18,604,605],{},"Vector(element, minimumSize, maximumSize)"," draws a length in the inclusive\nrange and then the elements in index order. ",[18,608,609],{},"Text(alphabet, minimumLength, maximumLength)"," does the same for byte strings over the given alphabet;\n",[18,612,613],{},"PrintableAscii()"," is the default alphabet. Both shrink in a fixed order:\nthe shortest allowed prefix, the first and second half, the value with one\nelement removed, and finally the value with one element simplified. A\nshrunk value is never shorter than its minimum, each step offers at most\n256 candidates, and a size limit above 1,048,576 elements is rejected.",[271,616,617,620,621,623],{},[18,618,619],{},"Element(values)"," picks uniformly from a fixed non-empty list. The list\norder is the simplicity order: a value shrinks to the values listed before\nit. ",[18,622,469],{}," treats its alphabet the same way, so put the simplest value or\ncharacter first.",[14,625,626,627,630,631,634],{},"Counterexamples of tuples, pairs and vectors are printed element by element,\nfor example ",[18,628,629],{},"{ 7, { true, false }, \"text\" }",". This does not depend on Catch2's\noptional tuple or range string makers, so the report is the same whatever\nconfiguration macros a client defines. Scalars still use ",[18,632,633],{},"Catch::StringMaker",",\nincluding user specializations.",[14,636,637,638,641,642,313],{},"Invalid factory arguments, such as an empty alphabet or a minimum above its\nmaximum, throw ",[18,639,640],{},"std::invalid_argument","; a client built without exceptions\ngets the message on standard error followed by ",[18,643,644],{},"std::abort",[14,646,647,648,651],{},"Mapped, filtered and dependent generators and state machines are not part of\nthis module; the strategies of ",[23,649,650],{"href":46},"native property testing","\nprovide them. Shrinking a composite value here is greedy and local like scalar\nshrinking: it finds a small counterexample, not a provably smallest one.",[37,653,655],{"id":654},"snapshots","Snapshots",[14,657,658,661,662,665],{},[18,659,660],{},"\u003CProgmasoft\u002FCatch3\u002FSnapshot.hpp>"," provides file-backed text snapshots through\n",[18,663,664],{},"CompareSnapshot(name, actual, options)",". The directory is supplied explicitly;\nnames are restricted to portable ASCII filename characters and cannot contain\npath separators. CRLF and CR are normalized to LF by default, with no trimming\nor other content rewriting.",[14,667,668,669,672,673,676,677,680],{},"Ordinary comparisons never write files. ",[18,670,671],{},"SnapshotUpdateMode::kCreateMissing","\ncreates only absent snapshots, while ",[18,674,675],{},"kAlways"," explicitly permits replacement.\nThe result reports a match, create\u002Fupdate, mismatch with a one-based first\ndifference location, invalid input, or I\u002FO failure. ",[18,678,679],{},"CATCH3_CHECK_SNAPSHOT","\ncombines this result with Catch2's normal assertion reporting. Keep snapshots\nunder a directory owned by the test suite and enable replacement only for an\nintentional update run.",[73,682,684],{"className":75,"code":683,"language":77,"meta":78,"style":78},"const Progmasoft::Catch3::SnapshotOptions options{\n    .Directory = \"tests\u002Fsnapshots\",\n};\nCATCH3_CHECK_SNAPSHOT(\"rendered-report\", RenderReport(), options);\n",[18,685,686,704,716,721],{"__ignoreMap":78},[82,687,688,690,692,694,696,698,701],{"class":84,"line":85},[82,689,494],{"class":88},[82,691,410],{"class":106},[82,693,141],{"class":110},[82,695,144],{"class":106},[82,697,141],{"class":110},[82,699,700],{"class":106},"SnapshotOptions",[82,702,703],{"class":110}," options{\n",[82,705,706,709,711,714],{"class":84,"line":96},[82,707,708],{"class":110},"    .Directory ",[82,710,221],{"class":88},[82,712,713],{"class":92}," \"tests\u002Fsnapshots\"",[82,715,227],{"class":110},[82,717,718],{"class":84,"line":103},[82,719,720],{"class":110},"};\n",[82,722,723,725,727,730,732,735],{"class":84,"line":126},[82,724,679],{"class":106},[82,726,111],{"class":110},[82,728,729],{"class":92},"\"rendered-report\"",[82,731,117],{"class":110},[82,733,734],{"class":106},"RenderReport",[82,736,737],{"class":110},"(), options);\n",[37,739,741],{"id":740},"structured-results-and-xml","Structured results and XML",[14,743,744,747,748,751,752,755,756,759,760,763,764,767,768,771,772,775,776,779,780,304,783,786],{},[18,745,746],{},"\u003CProgmasoft\u002FCatch3\u002FResults.hpp>"," defines the model the runner's reports are\nwritten from: a ",[18,749,750],{},"RunResult"," holds a ",[18,753,754],{},"TestResult"," per test, with its verdict,\nfailure category, history classification, flakiness, quarantine, failure\nsignature, analysis and replay command, and every ",[18,757,758],{},"Attempt"," with its\nassertions, sections, benchmarks, captured output and the tests that ran\nbefore it in the same process. ",[18,761,762],{},"Summarize"," counts the verdicts, and\n",[18,765,766],{},"DescribeFailure"," writes a failed attempt as text.\n",[18,769,770],{},"\u003CProgmasoft\u002FCatch3\u002FXmlWriter.hpp>"," writes a run as deterministic JUnit XML\nthrough ",[18,773,774],{},"JUnitXmlWriter::Write"," or ",[18,777,778],{},"ToString",", with ",[18,781,782],{},"\u003CrerunFailure>",[18,784,785],{},"\u003CflakyFailure>"," for retries. It escapes XML markup, replaces malformed UTF-8\nand XML-forbidden control characters, and omits timestamps so identical\nresults produce identical output.",[14,788,789,790,793],{},"The results, the JUnit writer, the runner, property testing and the\nsnapshot API are compiled into the ",[18,791,792],{},"Catch3::Catch3"," library. Generator\ntemplates and convenience macros remain in headers where their types or\ncall-site expansion require it.",[37,795,797],{"id":796},"build-and-integration","Build and integration",[14,799,800,801,803,804,304,806,809],{},"The CMake package is ",[18,802,144],{},", with the targets ",[18,805,792],{},[18,807,808],{},"Catch3::Catch3WithMain",". The library is C++17, and its headers work in C++17\nand later. After installation,\nconsumers can use:",[73,811,815],{"className":812,"code":813,"language":814,"meta":78,"style":78},"language-cmake shiki shiki-themes github-dark","find_package(Catch3 0.3 CONFIG REQUIRED)\ntarget_link_libraries(MyTests PRIVATE Catch3::Catch3WithMain)\n","cmake",[18,816,817,825],{"__ignoreMap":78},[82,818,819,822],{"class":84,"line":85},[82,820,821],{"class":88},"find_package",[82,823,824],{"class":110},"(Catch3 0.3 CONFIG REQUIRED)\n",[82,826,827,830,833,836],{"class":84,"line":96},[82,828,829],{"class":88},"target_link_libraries",[82,831,832],{"class":110},"(MyTests ",[82,834,835],{"class":106},"PRIVATE",[82,837,838],{"class":110}," Catch3::Catch3WithMain)\n",[14,840,841,842,844,845,848,849,852,853,304,856,859,860,288,863,866,867,288,870,873,874,876,877,879],{},"Without a build system, an installed Catch3 links by its name: the library is\n",[18,843,144],{}," and the one that brings ",[18,846,847],{},"main"," is ",[18,850,851],{},"Catch3Main",", as ",[18,854,855],{},"libCatch3.a",[18,857,858],{},"libCatch3Main.a"," (",[18,861,862],{},"Catch3.lib",[18,864,865],{},"Catch3Main.lib"," on Windows). The released\narchives and packages hold these release builds; a debug build made with\nCMake is named apart, ",[18,868,869],{},"Catch3d",[18,871,872],{},"Catch3Maind",". ",[18,875,851],{}," comes first,\nsince it uses ",[18,878,144],{},":",[73,881,885],{"className":882,"code":883,"language":884,"meta":78,"style":78},"language-sh shiki shiki-themes github-dark","c++ -std=c++17 tests.cpp -lCatch3Main -lCatch3\n","sh",[18,886,887],{"__ignoreMap":78},[82,888,889],{"class":84,"line":85},[82,890,883],{},[14,892,893],{},"When Catch3 is installed outside the compiler's search paths, pkg-config\ngives the same flags with the include and library directories:",[73,895,897],{"className":882,"code":896,"language":884,"meta":78,"style":78},"c++ -std=c++17 tests.cpp $(pkg-config --cflags --libs catch3-with-main)\n",[18,898,899],{"__ignoreMap":78},[82,900,901],{"class":84,"line":85},[82,902,896],{},[14,904,905,906,288,909,912],{},"The pkg-config modules are ",[18,907,908],{},"catch3",[18,910,911],{},"catch3-with-main",". CMake, Meson,\nXmake and Premake build the files under the same names.",[14,914,915,916,919],{},"In the Bazel Central Registry, from 0.5.0 on, the module is\n",[18,917,918],{},"progmasoft_catch3",", for Bazel 8 and later:",[73,921,925],{"className":922,"code":923,"language":924,"meta":78,"style":78},"language-starlark shiki shiki-themes github-dark","bazel_dep(name = \"progmasoft_catch3\", version = \"0.5.0\")\n","starlark",[18,926,927],{"__ignoreMap":78},[82,928,929],{"class":84,"line":85},[82,930,923],{},[14,932,933,934,304,937,940,941,943,944,859,947,950],{},"Its targets are ",[18,935,936],{},"@progmasoft_catch3\u002F\u002F:catch3",[18,938,939],{},"@progmasoft_catch3\u002F\u002F:catch3_main",", which brings ",[18,942,847],{},". Code that includes\nthe headers is C++17 or later, so a module that is not already set to it\npasses ",[18,945,946],{},"--cxxopt=-std=c++17",[18,948,949],{},"--cxxopt=\u002Fstd:c++17"," with MSVC, which defaults\nto C++14).",[14,952,953,954,957,958,961,962,965,966,117,969,117,972,961,975,978,979,982],{},"In this repository the Bazel target is ",[18,955,956],{},"\u002F\u002F:catch3","; its tests are\n",[18,959,960],{},"\u002F\u002Ftests\u002FProgmasoft:property_tests",", and ",[18,963,964],{},"tests\u002FProgmasoft\u002FBazelModule"," is a\nmodule that depends on Catch3 as a user's does. Bazel is the primary\nbuild path; CMake, Meson, Xmake, and Premake are also maintained as alternate\nways to build the same engine and property tests. Their root files are\n",[18,967,968],{},"CMakeLists.txt",[18,970,971],{},"meson.build",[18,973,974],{},"xmake.lua",[18,976,977],{},"premake5.lua",". Xmake and\nPremake materialize the default generated configuration header,\n",[18,980,981],{},"Progmasoft\u002FCatch3\u002FUserConfig.hpp",", from the checked-in template. Meson 1.1.0 or newer is required for the Clang-CL\nC++17 test target.",[14,984,985,986,313],{},"For project history, compatibility intent, license split, and current feature\nlimits, read ",[23,987,989],{"href":988},"\u002Fdocs\u002Fwhy-catch3\u002F","Why Progmasoft Catch3?",[37,991,993],{"id":992},"build-quick-start","Build quick start",[14,995,996],{},"Bazel is the primary build path:",[73,998,1000],{"className":882,"code":999,"language":884,"meta":78,"style":78},"bazel test \u002F\u002Ftests\u002FProgmasoft:property_tests\n",[18,1001,1002],{"__ignoreMap":78},[82,1003,1004],{"class":84,"line":85},[82,1005,999],{},[14,1007,1008],{},"The alternate project builds exercise the same property suite:",[73,1010,1012],{"className":882,"code":1011,"language":884,"meta":78,"style":78},"# CMake\ncmake -S . -B build\u002Fcmake -DCATCH3_DEVELOPMENT_BUILD=ON -DCATCH3_BUILD_TESTING=ON\ncmake --build build\u002Fcmake --target ProgmasoftSelfTest\nctest --test-dir build\u002Fcmake -R Progmasoft --output-on-failure\n\n# Xmake\nxmake build ProgmasoftPropertyTests\nxmake run ProgmasoftPropertyTests\n\n# Meson (Windows PowerShell; requires the Visual C++ SDK\u002FCRT)\n$env:CC = 'clang-cl'; $env:CXX = 'clang-cl'\nmeson setup build\u002Fmeson --vsenv -Dtests=true -Dinstall=false\nmeson compile -C build\u002Fmeson\nmeson test -C build\u002Fmeson --print-errorlogs\n\n# Premake (choose an action supported by the host)\npremake5 vs2022\n",[18,1013,1014,1019,1024,1029,1034,1038,1043,1048,1053,1057,1062,1067,1073,1079,1085,1090,1096],{"__ignoreMap":78},[82,1015,1016],{"class":84,"line":85},[82,1017,1018],{},"# CMake\n",[82,1020,1021],{"class":84,"line":96},[82,1022,1023],{},"cmake -S . -B build\u002Fcmake -DCATCH3_DEVELOPMENT_BUILD=ON -DCATCH3_BUILD_TESTING=ON\n",[82,1025,1026],{"class":84,"line":103},[82,1027,1028],{},"cmake --build build\u002Fcmake --target ProgmasoftSelfTest\n",[82,1030,1031],{"class":84,"line":126},[82,1032,1033],{},"ctest --test-dir build\u002Fcmake -R Progmasoft --output-on-failure\n",[82,1035,1036],{"class":84,"line":135},[82,1037,100],{"emptyLinePlaceholder":99},[82,1039,1040],{"class":84,"line":173},[82,1041,1042],{},"# Xmake\n",[82,1044,1045],{"class":84,"line":203},[82,1046,1047],{},"xmake build ProgmasoftPropertyTests\n",[82,1049,1050],{"class":84,"line":215},[82,1051,1052],{},"xmake run ProgmasoftPropertyTests\n",[82,1054,1055],{"class":84,"line":230},[82,1056,100],{"emptyLinePlaceholder":99},[82,1058,1059],{"class":84,"line":246},[82,1060,1061],{},"# Meson (Windows PowerShell; requires the Visual C++ SDK\u002FCRT)\n",[82,1063,1064],{"class":84,"line":260},[82,1065,1066],{},"$env:CC = 'clang-cl'; $env:CXX = 'clang-cl'\n",[82,1068,1070],{"class":84,"line":1069},12,[82,1071,1072],{},"meson setup build\u002Fmeson --vsenv -Dtests=true -Dinstall=false\n",[82,1074,1076],{"class":84,"line":1075},13,[82,1077,1078],{},"meson compile -C build\u002Fmeson\n",[82,1080,1082],{"class":84,"line":1081},14,[82,1083,1084],{},"meson test -C build\u002Fmeson --print-errorlogs\n",[82,1086,1088],{"class":84,"line":1087},15,[82,1089,100],{"emptyLinePlaceholder":99},[82,1091,1093],{"class":84,"line":1092},16,[82,1094,1095],{},"# Premake (choose an action supported by the host)\n",[82,1097,1099],{"class":84,"line":1098},17,[82,1100,1101],{},"premake5 vs2022\n",[14,1103,1104,1105,1108,1109,1112,1113,1116],{},"Premake generates projects rather than compiling directly; build the generated\nsolution with the corresponding host toolchain. On macOS, use\n",[18,1106,1107],{},"premake5 gmake",", then build the generated makefiles with ",[18,1110,1111],{},"make",". Meson users on\nmacOS can select Apple Clang with ",[18,1114,1115],{},"CC=clang CXX=clang++"," before configuration.",[37,1118,1120],{"id":1119},"compatibility-and-licensing-boundary","Compatibility and licensing boundary",[14,1122,1123,1124,1127],{},"Do not rename or rewrite Catch2 headers, ",[18,1125,1126],{},"Catch"," symbols, macros, runner options,\nor upstream coding style as part of this extension. New functionality belongs\nin separately licensed Progmasoft headers and uses Progmasoft's PascalCase C++\ntypes\u002Ffunctions and project naming conventions. Catch2-originated source files\nremain under BSL-1.0; Progmasoft-authored source files are under\nLGPL-3.0-or-later, as their headers say. The two\nareas are not relicensed as a whole. Any proposed upstream PR must be prepared\nunder Catch2's contribution rules as a separate contribution, rather than\nreusing a source file whose license header says otherwise.",[1129,1130,1131],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html pre.shiki code .snl16, html code.shiki .snl16{--shiki-default:#F97583}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html pre.shiki code .s95oV, html code.shiki .s95oV{--shiki-default:#E1E4E8}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}",{"title":78,"searchDepth":96,"depth":96,"links":1133},[1134,1137,1138,1139,1140,1141],{"id":39,"depth":96,"text":40,"children":1135},[1136],{"id":391,"depth":103,"text":312},{"id":654,"depth":96,"text":655},{"id":740,"depth":96,"text":741},{"id":796,"depth":96,"text":797},{"id":992,"depth":96,"text":993},{"id":1119,"depth":96,"text":1120},"Progmasoft Catch3 keeps Catch2's API for writing tests, its macros and the\nCatch:: namespace, and replaces Catch2's runner with its own. The\nCatch3 runner runs tests in parallel worker\nprocesses and adds retries, flaky-test detection, quarantine, history,\npredictive ordering, test selection, sharding, time limits and failure\nanalysis. Every header is in the Progmasoft\u002FCatch3 include tree; the files\nof the engine that come from Catch2 keep its BSL-1.0 license, and\nProgmasoft's own API is in the Progmasoft::Catch3 namespace.","md",{},"\u002Fdocs\u002Fprogmasoft-catch3",{"title":5,"description":1142},"progmasoft-catch3","docs\u002Fprogmasoft-catch3.md","docs\u002Fprogmasoft-catch3","qSEmgeOaI6x94GzXM_9Tc32d9HdlXKPIMod5MTN1E4A",1794961594445]