[{"data":1,"prerenderedAt":2342},["ShallowReactive",2],{"doc-test-cases-and-sections":3},{"id":4,"title":5,"body":6,"description":192,"extension":2335,"meta":2336,"navigation":727,"path":2337,"seo":2338,"slug":53,"source":2339,"stem":2340,"__hash__":2341},"docs\u002Fdocs\u002Ftest-cases-and-sections.md","Test cases and sections",{"type":7,"value":8,"toc":2323},"minimark",[9,50,54,92,95,103,106,142,165,170,177,180,183,186,288,304,311,325,328,333,336,431,434,437,445,451,457,468,471,488,502,508,538,564,602,631,657,917,920,926,935,949,952,960,963,987,1012,1022,1043,1053,1056,1461,1494,1503,1522,1555,1557,1683,1689,1775,1791,1800,1819,1825,1827,1909,1912,1921,1942,1946,1949,1989,1992,1996,2017,2025,2158,2185,2319],[10,11,12],"blockquote",{},[13,14,15,19,20,24,25,28,29,32,33,36,37,36,40,43,44,49],"p",{},[16,17,18],"strong",{},"Catch3 compatibility reference:"," This page describes the test-writing API Catch3 shares with Catch2: the macros, such as ",[21,22,23],"code",{},"TEST_CASE"," and ",[21,26,27],{},"REQUIRE",", and the ",[21,30,31],{},"Catch::"," namespace keep Catch2's names. Headers and build names are Catch3's own (",[21,34,35],{},"\u003CProgmasoft\u002FCatch3\u002FTestMacros.hpp>",", ",[21,38,39],{},"find_package(Catch3)",[21,41,42],{},"Catch3::Catch3WithMain","). See ",[45,46,48],"a",{"href":47},"\u002Fdocs\u002Fprogmasoft-catch3\u002F","Catch3 additions"," for Progmasoft APIs.",[51,52,5],"h1",{"id":53},"test-cases-and-sections",[13,55,56,59,62,66,68,72,74,78,80,84,86,90],{},[16,57,58],{},"Contents",[60,61],"br",{},[45,63,65],{"href":64},"#tags","Tags",[60,67],{},[45,69,71],{"href":70},"#tag-aliases","Tag aliases",[60,73],{},[45,75,77],{"href":76},"#bdd-style-test-cases","BDD-style test cases",[60,79],{},[45,81,83],{"href":82},"#type-parametrised-test-cases","Type parametrised test cases",[60,85],{},[45,87,89],{"href":88},"#signature-based-parametrised-test-cases","Signature based parametrised test cases",[60,91],{},[13,93,94],{},"While Catch fully supports the traditional, xUnit, style of class-based fixtures containing test case methods this is not the preferred style.",[13,96,97,98,102],{},"Instead Catch provides a powerful mechanism for nesting test case sections within a test case. For a more detailed discussion see the ",[45,99,101],{"href":100},"\u002Fdocs\u002Ftutorial\u002F#test-cases-and-sections","tutorial",".",[13,104,105],{},"Test cases and sections are very easy to use in practice:",[107,108,109,128],"ul",{},[110,111,112,115,116,120,121,124,125],"li",{},[16,113,114],{},"TEST_CASE("," ",[117,118,119],"em",{},"test name"," [, ",[117,122,123],{},"tags"," ] ",[16,126,127],{},")",[110,129,130,115,133,136,137,124,140],{},[16,131,132],{},"SECTION(",[117,134,135],{},"section name",", [, ",[117,138,139],{},"section description",[16,141,127],{},[13,143,144,24,146,148,149,151,152,154,155,157,158,102],{},[117,145,119],{},[117,147,135],{}," are free form, quoted, strings.\nThe optional ",[117,150,123],{}," argument is a quoted string containing one or more\ntags enclosed in square brackets, and are discussed below.\n",[117,153,139],{}," can be used to provide long form description\nof a section while keeping the ",[117,156,135],{}," short for use with the\n",[45,159,161,164],{"href":160},"\u002Fdocs\u002Fcommand-line\u002F#specify-the-section-to-run",[21,162,163],{},"-c"," command line parameter",[13,166,167],{},[16,168,169],{},"The combination of test names and tags must be unique within the Catch2\nexecutable.",[13,171,172,173],{},"For examples see the ",[45,174,176],{"href":175},"\u002Fdocs\u002Ftutorial\u002F","Tutorial",[178,179,65],"h2",{"id":123},[13,181,182],{},"Tags allow an arbitrary number of additional strings to be associated with a test case. Test cases can be selected (for running, or just for listing) by tag - or even by an expression that combines several tags. At their most basic level they provide a simple way to group several related tests together.",[13,184,185],{},"As an example - given the following test cases:",[187,188,193],"pre",{"className":189,"code":190,"language":191,"meta":192,"style":192},"language-cpp shiki shiki-themes github-dark","TEST_CASE( \"A\", \"[widget]\" ) { \u002F* ... *\u002F }\nTEST_CASE( \"B\", \"[widget]\" ) { \u002F* ... *\u002F }\nTEST_CASE( \"C\", \"[gadget]\" ) { \u002F* ... *\u002F }\nTEST_CASE( \"D\", \"[widget][gadget]\" ) { \u002F* ... *\u002F }\n","cpp","",[21,194,195,226,246,267],{"__ignoreMap":192},[196,197,200,203,207,211,213,216,219,223],"span",{"class":198,"line":199},"line",1,[196,201,23],{"class":202},"svObZ",[196,204,206],{"class":205},"s95oV","( ",[196,208,210],{"class":209},"sU2Wk","\"A\"",[196,212,36],{"class":205},[196,214,215],{"class":209},"\"[widget]\"",[196,217,218],{"class":205}," ) {",[196,220,222],{"class":221},"sAwPA"," \u002F* ... *\u002F",[196,224,225],{"class":205}," }\n",[196,227,229,231,233,236,238,240,242,244],{"class":198,"line":228},2,[196,230,23],{"class":202},[196,232,206],{"class":205},[196,234,235],{"class":209},"\"B\"",[196,237,36],{"class":205},[196,239,215],{"class":209},[196,241,218],{"class":205},[196,243,222],{"class":221},[196,245,225],{"class":205},[196,247,249,251,253,256,258,261,263,265],{"class":198,"line":248},3,[196,250,23],{"class":202},[196,252,206],{"class":205},[196,254,255],{"class":209},"\"C\"",[196,257,36],{"class":205},[196,259,260],{"class":209},"\"[gadget]\"",[196,262,218],{"class":205},[196,264,222],{"class":221},[196,266,225],{"class":205},[196,268,270,272,274,277,279,282,284,286],{"class":198,"line":269},4,[196,271,23],{"class":202},[196,273,206],{"class":205},[196,275,276],{"class":209},"\"D\"",[196,278,36],{"class":205},[196,280,281],{"class":209},"\"[widget][gadget]\"",[196,283,218],{"class":205},[196,285,222],{"class":221},[196,287,225],{"class":205},[13,289,290,291,293,294,296,297,299,300,303],{},"The tag expression, ",[21,292,215],{}," selects A, B & D. ",[21,295,260],{}," selects C & D. ",[21,298,281],{}," selects just D and ",[21,301,302],{},"\"[widget],[gadget]\""," selects all four test cases.",[13,305,306,307],{},"For more detail on command line selection see ",[45,308,310],{"href":309},"\u002Fdocs\u002Fcommand-line\u002F#specifying-which-tests-to-run","the command line docs",[13,312,313,314,24,317,320,321,324],{},"Tag names are not case sensitive and can contain any ASCII characters.\nThis means that tags ",[21,315,316],{},"[tag with spaces]",[21,318,319],{},"[I said \"good day\"]","\nare both allowed tags and can be filtered on. However, escapes are not\nsupported and ",[21,322,323],{},"[\\]]"," is not a valid tag.",[13,326,327],{},"The same tag can be specified multiple times for a single test case,\nbut only one of the instances of identical tags will be kept. Which one\nis kept is functionally random.",[329,330,332],"h3",{"id":331},"special-tags","Special Tags",[13,334,335],{},"All tag names beginning with non-alphanumeric characters are reserved by Catch. Catch defines a number of \"special\" tags, which have meaning to the test runner itself. These special tags all begin with a symbol character. Following is a list of currently defined special tags and their meanings.",[107,337,338,358,371,377,394,400,415,425],{},[110,339,340,343,344,347,348,351,352,354,355,102],{},[21,341,342],{},"[.]"," - causes test cases to be skipped from the default list (i.e. when no test cases have been explicitly selected through tag expressions or name wildcards). The hide tag is often combined with another, user, tag (for example ",[21,345,346],{},"[.][integration]"," - so all integration tests are excluded from the default run but can be run by passing ",[21,349,350],{},"[integration]"," on the command line). As a short-cut you can combine these by simply prefixing your user tag with a ",[21,353,102],{}," - e.g. ",[21,356,357],{},"[.integration]",[110,359,360,363,364,367,368,102],{},[21,361,362],{},"[!throws]"," - lets Catch know that this test is likely to throw an exception even if successful. This causes the test to be excluded when running with ",[21,365,366],{},"-e"," or ",[21,369,370],{},"--nothrow",[110,372,373,376],{},[21,374,375],{},"[!mayfail]"," - doesn't fail the test if any given assertion fails (but still reports it). This can be useful to flag a work-in-progress, or a known issue that you don't want to immediately fix but still want to track in your tests.",[110,378,379,382,383,385,386,389,390,393],{},[21,380,381],{},"[!shouldfail]"," - like ",[21,384,375],{}," but ",[117,387,388],{},"fails"," the test if it ",[117,391,392],{},"passes",". This can be useful if you want to be notified of accidental, or third-party, fixes.",[110,395,396,399],{},[21,397,398],{},"[!nonportable]"," - Indicates that behaviour may vary between platforms or compilers.",[110,401,402,405,406,102],{},[21,403,404],{},"[#\u003Cfilename>]"," - these tags are added to test cases when you run Catch2\nwith ",[45,407,409,367,412],{"href":408},"\u002Fdocs\u002Fcommand-line\u002F#filenames-as-tags",[21,410,411],{},"-#",[21,413,414],{},"--filenames-as-tags",[110,416,417,420,421,424],{},[21,418,419],{},"[@\u003Calias>]"," - tag aliases all begin with ",[21,422,423],{},"@"," (see below).",[110,426,427,430],{},[21,428,429],{},"[!benchmark]"," - this test case is actually a benchmark. Currently this only serves to hide the test case by default, to avoid the execution time costs.",[178,432,71],{"id":433},"tag-aliases",[13,435,436],{},"Between tag expressions and wildcarded test names (as well as combinations of the two) quite complex patterns can be constructed to direct which test cases are run. If a complex pattern is used often it is convenient to be able to create an alias for the expression. This can be done, in code, using the following form:",[187,438,443],{"className":439,"code":441,"language":442},[440],"language-text","CATCH_REGISTER_TAG_ALIAS( \u003Calias string>, \u003Ctag expression> )\n","text",[21,444,441],{"__ignoreMap":192},[13,446,447,448,450],{},"Aliases must begin with the ",[21,449,423],{}," character. An example of a tag alias is:",[187,452,455],{"className":453,"code":454,"language":442},[440],"CATCH_REGISTER_TAG_ALIAS( \"[@nhf]\", \"[failing]~[.]\" )\n",[21,456,454],{"__ignoreMap":192},[13,458,459,460,463,464,467],{},"Now when ",[21,461,462],{},"[@nhf]"," is used on the command line this matches all tests that are tagged ",[21,465,466],{},"[failing]",", but which are not also hidden.",[178,469,77],{"id":470},"bdd-style-test-cases",[13,472,473,474,480,481,483,484,487],{},"In addition to Catch's take on the classic style of test cases, Catch supports an alternative syntax that allow tests to be written as \"executable specifications\" (one of the early goals of ",[45,475,479],{"href":476,"rel":477},"http:\u002F\u002Fdannorth.net\u002Fintroducing-bdd\u002F",[478],"nofollow","Behaviour Driven Development","). This set of macros map on to ",[21,482,23],{},"s and ",[21,485,486],{},"SECTION","s, with a little internal support to make them smoother to work with.",[107,489,490],{},[110,491,492,115,495,120,498,124,500],{},[16,493,494],{},"SCENARIO(",[117,496,497],{},"scenario name",[117,499,123],{},[16,501,127],{},[13,503,504,505,507],{},"This macro maps onto ",[21,506,23],{}," and works in the same way, except that the test case name will be prefixed by \"Scenario: \"",[107,509,510,520,529],{},[110,511,512,115,515,115,518],{},[16,513,514],{},"GIVEN(",[117,516,517],{},"something",[16,519,127],{},[110,521,522,115,525,115,527],{},[16,523,524],{},"WHEN(",[117,526,517],{},[16,528,127],{},[110,530,531,115,534,115,536],{},[16,532,533],{},"THEN(",[117,535,517],{},[16,537,127],{},[13,539,540,541,543,544,546,547,551,552,557,558,563],{},"These macros map onto ",[21,542,486],{},"s except that the section names are the ",[117,545,517],{}," texts prefixed by\n\"given: \", \"when: \" or \"then: \" respectively. These macros also map onto the AAA or A",[548,549,550],"sup",{},"3"," test pattern\n(standing either for ",[45,553,556],{"href":554,"rel":555},"http:\u002F\u002Fwiki.c2.com\u002F?AssembleActivateAssert",[478],"Assemble-Activate-Assert"," or\n",[45,559,562],{"href":560,"rel":561},"http:\u002F\u002Fwiki.c2.com\u002F?ArrangeActAssert",[478],"Arrange-Act-Assert","), and in this context, the macros provide both code\ndocumentation and reporting of these parts of a test case without the need for extra comments or code to do so.",[13,565,566,567,570,571,115,574,577,578,580,581,583,584,587,588,590,591,594,595,597,598,601],{},"Semantically, a ",[21,568,569],{},"GIVEN"," clause may have multiple ",[117,572,573],{},"independent",[21,575,576],{},"WHEN"," clauses within it. This allows a test\nto have, e.g., one set of \"given\" objects and multiple subtests using those objects in various ways in each\nof the ",[21,579,576],{}," clauses without repeating the initialisation from the ",[21,582,569],{}," clause. When there are ",[117,585,586],{},"dependent","\nclauses -- such as a second ",[21,589,576],{}," clause that should only happen ",[117,592,593],{},"after"," the previous ",[21,596,576],{}," clause has been\nexecuted and validated -- there are additional macros starting with ",[21,599,600],{},"AND_",":",[107,603,604,613,622],{},[110,605,606,115,609,115,611],{},[16,607,608],{},"AND_GIVEN(",[117,610,517],{},[16,612,127],{},[110,614,615,115,618,115,620],{},[16,616,617],{},"AND_WHEN(",[117,619,517],{},[16,621,127],{},[110,623,624,115,627,115,629],{},[16,625,626],{},"AND_THEN(",[117,628,517],{},[16,630,127],{},[13,632,633,634,636,637,483,639,642,643,646,647,650,651,653,654,656],{},"These are used to chain ",[21,635,569],{},"s, ",[21,638,576],{},[21,640,641],{},"THEN","s together. The ",[21,644,645],{},"AND_*"," clause is placed\n",[117,648,649],{},"inside"," the clause on which it depends. There can be multiple ",[117,652,573],{}," clauses that are all ",[117,655,586],{},"\non a single outer clause.",[187,658,660],{"className":189,"code":659,"language":191,"meta":192,"style":192},"SCENARIO( \"vector can be sized and resized\" ) {\n    GIVEN( \"An empty vector\" ) {\n        auto v = std::vector\u003Cstd::string>{};\n\n        \u002F\u002F Validate assumption of the GIVEN clause\n        THEN( \"The size and capacity start at 0\" ) {\n            REQUIRE( v.size() == 0 );\n            REQUIRE( v.capacity() == 0 );\n        }\n\n        \u002F\u002F Validate one use case for the GIVEN object\n        WHEN( \"push_back() is called\" ) {\n            v.push_back(\"hullo\");\n\n            THEN( \"The size changes\" ) {\n                REQUIRE( v.size() == 1 );\n                REQUIRE( v.capacity() >= 1 );\n            }\n        }\n    }\n}\n",[21,661,662,675,687,723,729,735,748,773,791,797,802,808,821,839,844,857,876,894,900,905,911],{"__ignoreMap":192},[196,663,664,667,669,672],{"class":198,"line":199},[196,665,666],{"class":202},"SCENARIO",[196,668,206],{"class":205},[196,670,671],{"class":209},"\"vector can be sized and resized\"",[196,673,674],{"class":205}," ) {\n",[196,676,677,680,682,685],{"class":198,"line":228},[196,678,679],{"class":202},"    GIVEN",[196,681,206],{"class":205},[196,683,684],{"class":209},"\"An empty vector\"",[196,686,674],{"class":205},[196,688,689,693,696,699,702,705,708,711,714,717,720],{"class":198,"line":248},[196,690,692],{"class":691},"snl16","        auto",[196,694,695],{"class":205}," v ",[196,697,698],{"class":691},"=",[196,700,701],{"class":202}," std",[196,703,704],{"class":205},"::vector",[196,706,707],{"class":691},"\u003C",[196,709,710],{"class":202},"std",[196,712,713],{"class":205},"::",[196,715,716],{"class":205},"string",[196,718,719],{"class":691},">",[196,721,722],{"class":205},"{};\n",[196,724,725],{"class":198,"line":269},[196,726,728],{"emptyLinePlaceholder":727},true,"\n",[196,730,732],{"class":198,"line":731},5,[196,733,734],{"class":221},"        \u002F\u002F Validate assumption of the GIVEN clause\n",[196,736,738,741,743,746],{"class":198,"line":737},6,[196,739,740],{"class":202},"        THEN",[196,742,206],{"class":205},[196,744,745],{"class":209},"\"The size and capacity start at 0\"",[196,747,674],{"class":205},[196,749,751,754,757,760,763,766,770],{"class":198,"line":750},7,[196,752,753],{"class":202},"            REQUIRE",[196,755,756],{"class":205},"( v.",[196,758,759],{"class":202},"size",[196,761,762],{"class":205},"() ",[196,764,765],{"class":691},"==",[196,767,769],{"class":768},"sDLfK"," 0",[196,771,772],{"class":205}," );\n",[196,774,776,778,780,783,785,787,789],{"class":198,"line":775},8,[196,777,753],{"class":202},[196,779,756],{"class":205},[196,781,782],{"class":202},"capacity",[196,784,762],{"class":205},[196,786,765],{"class":691},[196,788,769],{"class":768},[196,790,772],{"class":205},[196,792,794],{"class":198,"line":793},9,[196,795,796],{"class":205},"        }\n",[196,798,800],{"class":198,"line":799},10,[196,801,728],{"emptyLinePlaceholder":727},[196,803,805],{"class":198,"line":804},11,[196,806,807],{"class":221},"        \u002F\u002F Validate one use case for the GIVEN object\n",[196,809,811,814,816,819],{"class":198,"line":810},12,[196,812,813],{"class":202},"        WHEN",[196,815,206],{"class":205},[196,817,818],{"class":209},"\"push_back() is called\"",[196,820,674],{"class":205},[196,822,824,827,830,833,836],{"class":198,"line":823},13,[196,825,826],{"class":205},"            v.",[196,828,829],{"class":202},"push_back",[196,831,832],{"class":205},"(",[196,834,835],{"class":209},"\"hullo\"",[196,837,838],{"class":205},");\n",[196,840,842],{"class":198,"line":841},14,[196,843,728],{"emptyLinePlaceholder":727},[196,845,847,850,852,855],{"class":198,"line":846},15,[196,848,849],{"class":202},"            THEN",[196,851,206],{"class":205},[196,853,854],{"class":209},"\"The size changes\"",[196,856,674],{"class":205},[196,858,860,863,865,867,869,871,874],{"class":198,"line":859},16,[196,861,862],{"class":202},"                REQUIRE",[196,864,756],{"class":205},[196,866,759],{"class":202},[196,868,762],{"class":205},[196,870,765],{"class":691},[196,872,873],{"class":768}," 1",[196,875,772],{"class":205},[196,877,879,881,883,885,887,890,892],{"class":198,"line":878},17,[196,880,862],{"class":202},[196,882,756],{"class":205},[196,884,782],{"class":202},[196,886,762],{"class":205},[196,888,889],{"class":691},">=",[196,891,873],{"class":768},[196,893,772],{"class":205},[196,895,897],{"class":198,"line":896},18,[196,898,899],{"class":205},"            }\n",[196,901,903],{"class":198,"line":902},19,[196,904,796],{"class":205},[196,906,908],{"class":198,"line":907},20,[196,909,910],{"class":205},"    }\n",[196,912,914],{"class":198,"line":913},21,[196,915,916],{"class":205},"}\n",[13,918,919],{},"This code will result in two runs through the scenario:",[187,921,924],{"className":922,"code":923,"language":442},[440],"Scenario : vector can be sized and resized\n  Given  : An empty vector\n  Then   : The size and capacity start at 0\n\nScenario : vector can be sized and resized\n  Given  : An empty vector\n  When   : push_back() is called\n  Then   : The size changes\n",[21,925,923],{"__ignoreMap":192},[13,927,928,929,934],{},"See also ",[45,930,933],{"href":931,"rel":932},"https:\u002F\u002Fgodbolt.org\u002Fz\u002FeY5a64r99",[478],"runnable example on godbolt",",\nwith a more complicated (and failing) example.",[10,936,937],{},[13,938,939,942,943,948],{},[21,940,941],{},"AND_GIVEN"," was ",[45,944,947],{"href":945,"rel":946},"https:\u002F\u002Fgithub.com\u002Fcatchorg\u002FCatch2\u002Fissues\u002F1360",[478],"introduced"," in Catch2 2.4.0.",[13,950,951],{},"When any of these macros are used the console reporter recognises them and formats the test case header such that the Givens, Whens and Thens are aligned to aid readability.",[13,953,954,955,483,957,959],{},"Other than the additional prefixes and the formatting in the console reporter these macros behave exactly as ",[21,956,23],{},[21,958,486],{},"s. As such there is nothing enforcing the correct sequencing of these macros - that's up to the programmer!",[178,961,83],{"id":962},"type-parametrised-test-cases",[13,964,965,966,968,969,972,973,24,976,979,980,983,984,102],{},"In addition to ",[21,967,23],{},"s, Catch2 also supports test cases parametrised\nby types, in the form of ",[21,970,971],{},"TEMPLATE_TEST_CASE",",\n",[21,974,975],{},"TEMPLATE_PRODUCT_TEST_CASE",[21,977,978],{},"TEMPLATE_LIST_TEST_CASE",". These macros\nare defined in the ",[21,981,982],{},"Progmasoft\u002FCatch3\u002FTemplateTestMacros.hpp"," header, so compiling\nthe code examples below also requires\n",[21,985,986],{},"#include \u003CProgmasoft\u002FCatch3\u002FTemplateTestMacros.hpp>",[107,988,989],{},[110,990,991,115,994,996,997,999,1000,36,1003,1006,1007,115,1010],{},[16,992,993],{},"TEMPLATE_TEST_CASE(",[117,995,119],{}," , ",[117,998,123],{},",  ",[117,1001,1002],{},"type1",[117,1004,1005],{},"type2",", ..., ",[117,1008,1009],{},"typen",[16,1011,127],{},[10,1013,1014],{},[13,1015,1016,1021],{},[45,1017,1020],{"href":1018,"rel":1019},"https:\u002F\u002Fgithub.com\u002Fcatchorg\u002FCatch2\u002Fissues\u002F1437",[478],"Introduced"," in Catch2 2.5.0.",[13,1023,1024,24,1026,1029,1030,1032,1033,1035,1036,1038,1039,1042],{},[117,1025,119],{},[117,1027,1028],{},"tag"," are exactly the same as they are in ",[21,1031,23],{},",\nwith the difference that the tag string must be provided (however, it\ncan be empty). ",[117,1034,1002],{}," through ",[117,1037,1009],{}," is the list of types for which\nthis test case should run, and, inside the test code, the current type\nis available as the ",[21,1040,1041],{},"TestType"," type.",[13,1044,1045,1046,1049,1050,102],{},"Because of limitations of the C++ preprocessor, if you want to specify\na type with multiple template parameters, you need to enclose it in\nparentheses, e.g. ",[21,1047,1048],{},"std::map\u003Cint, std::string>"," needs to be passed as\n",[21,1051,1052],{},"(std::map\u003Cint, std::string>)",[13,1054,1055],{},"Example:",[187,1057,1059],{"className":189,"code":1058,"language":191,"meta":192,"style":192},"TEMPLATE_TEST_CASE( \"vectors can be sized and resized\", \"[vector][template]\", int, std::string, (std::tuple\u003Cint,float>) ) {\n\n    std::vector\u003CTestType> v( 5 );\n\n    REQUIRE( v.size() == 5 );\n    REQUIRE( v.capacity() >= 5 );\n\n    SECTION( \"resizing bigger changes size and capacity\" ) {\n        v.resize( 10 );\n\n        REQUIRE( v.size() == 10 );\n        REQUIRE( v.capacity() >= 10 );\n    }\n    SECTION( \"resizing smaller changes size but not capacity\" ) {\n        v.resize( 0 );\n\n        REQUIRE( v.size() == 0 );\n        REQUIRE( v.capacity() >= 5 );\n\n        SECTION( \"We can use the 'swap trick' to reset the capacity\" ) {\n            std::vector\u003CTestType> empty;\n            empty.swap( v );\n\n            REQUIRE( v.capacity() == 0 );\n        }\n    }\n    SECTION( \"reserving smaller does not change size or capacity\" ) {\n        v.reserve( 0 );\n\n        REQUIRE( v.size() == 5 );\n        REQUIRE( v.capacity() >= 5 );\n    }\n}\n",[21,1060,1061,1108,1112,1139,1143,1161,1177,1181,1193,1208,1212,1230,1246,1250,1261,1274,1278,1294,1310,1314,1326,1342,1354,1359,1376,1381,1386,1398,1412,1417,1434,1451,1456],{"__ignoreMap":192},[196,1062,1063,1065,1067,1070,1072,1075,1077,1080,1082,1084,1086,1088,1091,1093,1096,1099,1102,1105],{"class":198,"line":199},[196,1064,971],{"class":202},[196,1066,206],{"class":205},[196,1068,1069],{"class":209},"\"vectors can be sized and resized\"",[196,1071,36],{"class":205},[196,1073,1074],{"class":209},"\"[vector][template]\"",[196,1076,36],{"class":205},[196,1078,1079],{"class":691},"int",[196,1081,36],{"class":205},[196,1083,710],{"class":202},[196,1085,713],{"class":205},[196,1087,716],{"class":205},[196,1089,1090],{"class":205},", (",[196,1092,710],{"class":202},[196,1094,1095],{"class":205},"::tuple",[196,1097,1098],{"class":691},"\u003Cint",[196,1100,1101],{"class":205},",",[196,1103,1104],{"class":691},"float>",[196,1106,1107],{"class":205},") ) {\n",[196,1109,1110],{"class":198,"line":228},[196,1111,728],{"emptyLinePlaceholder":727},[196,1113,1114,1117,1119,1122,1124,1126,1129,1132,1134,1137],{"class":198,"line":248},[196,1115,1116],{"class":202},"    std",[196,1118,713],{"class":205},[196,1120,1121],{"class":202},"vector",[196,1123,707],{"class":205},[196,1125,1041],{"class":202},[196,1127,1128],{"class":205},"> ",[196,1130,1131],{"class":202},"v",[196,1133,206],{"class":205},[196,1135,1136],{"class":768},"5",[196,1138,772],{"class":205},[196,1140,1141],{"class":198,"line":269},[196,1142,728],{"emptyLinePlaceholder":727},[196,1144,1145,1148,1150,1152,1154,1156,1159],{"class":198,"line":731},[196,1146,1147],{"class":202},"    REQUIRE",[196,1149,756],{"class":205},[196,1151,759],{"class":202},[196,1153,762],{"class":205},[196,1155,765],{"class":691},[196,1157,1158],{"class":768}," 5",[196,1160,772],{"class":205},[196,1162,1163,1165,1167,1169,1171,1173,1175],{"class":198,"line":737},[196,1164,1147],{"class":202},[196,1166,756],{"class":205},[196,1168,782],{"class":202},[196,1170,762],{"class":205},[196,1172,889],{"class":691},[196,1174,1158],{"class":768},[196,1176,772],{"class":205},[196,1178,1179],{"class":198,"line":750},[196,1180,728],{"emptyLinePlaceholder":727},[196,1182,1183,1186,1188,1191],{"class":198,"line":775},[196,1184,1185],{"class":202},"    SECTION",[196,1187,206],{"class":205},[196,1189,1190],{"class":209},"\"resizing bigger changes size and capacity\"",[196,1192,674],{"class":205},[196,1194,1195,1198,1201,1203,1206],{"class":198,"line":793},[196,1196,1197],{"class":205},"        v.",[196,1199,1200],{"class":202},"resize",[196,1202,206],{"class":205},[196,1204,1205],{"class":768},"10",[196,1207,772],{"class":205},[196,1209,1210],{"class":198,"line":799},[196,1211,728],{"emptyLinePlaceholder":727},[196,1213,1214,1217,1219,1221,1223,1225,1228],{"class":198,"line":804},[196,1215,1216],{"class":202},"        REQUIRE",[196,1218,756],{"class":205},[196,1220,759],{"class":202},[196,1222,762],{"class":205},[196,1224,765],{"class":691},[196,1226,1227],{"class":768}," 10",[196,1229,772],{"class":205},[196,1231,1232,1234,1236,1238,1240,1242,1244],{"class":198,"line":810},[196,1233,1216],{"class":202},[196,1235,756],{"class":205},[196,1237,782],{"class":202},[196,1239,762],{"class":205},[196,1241,889],{"class":691},[196,1243,1227],{"class":768},[196,1245,772],{"class":205},[196,1247,1248],{"class":198,"line":823},[196,1249,910],{"class":205},[196,1251,1252,1254,1256,1259],{"class":198,"line":841},[196,1253,1185],{"class":202},[196,1255,206],{"class":205},[196,1257,1258],{"class":209},"\"resizing smaller changes size but not capacity\"",[196,1260,674],{"class":205},[196,1262,1263,1265,1267,1269,1272],{"class":198,"line":846},[196,1264,1197],{"class":205},[196,1266,1200],{"class":202},[196,1268,206],{"class":205},[196,1270,1271],{"class":768},"0",[196,1273,772],{"class":205},[196,1275,1276],{"class":198,"line":859},[196,1277,728],{"emptyLinePlaceholder":727},[196,1279,1280,1282,1284,1286,1288,1290,1292],{"class":198,"line":878},[196,1281,1216],{"class":202},[196,1283,756],{"class":205},[196,1285,759],{"class":202},[196,1287,762],{"class":205},[196,1289,765],{"class":691},[196,1291,769],{"class":768},[196,1293,772],{"class":205},[196,1295,1296,1298,1300,1302,1304,1306,1308],{"class":198,"line":896},[196,1297,1216],{"class":202},[196,1299,756],{"class":205},[196,1301,782],{"class":202},[196,1303,762],{"class":205},[196,1305,889],{"class":691},[196,1307,1158],{"class":768},[196,1309,772],{"class":205},[196,1311,1312],{"class":198,"line":902},[196,1313,728],{"emptyLinePlaceholder":727},[196,1315,1316,1319,1321,1324],{"class":198,"line":907},[196,1317,1318],{"class":202},"        SECTION",[196,1320,206],{"class":205},[196,1322,1323],{"class":209},"\"We can use the 'swap trick' to reset the capacity\"",[196,1325,674],{"class":205},[196,1327,1328,1331,1333,1335,1337,1339],{"class":198,"line":913},[196,1329,1330],{"class":202},"            std",[196,1332,713],{"class":205},[196,1334,1121],{"class":202},[196,1336,707],{"class":205},[196,1338,1041],{"class":202},[196,1340,1341],{"class":205},"> empty;\n",[196,1343,1345,1348,1351],{"class":198,"line":1344},22,[196,1346,1347],{"class":205},"            empty.",[196,1349,1350],{"class":202},"swap",[196,1352,1353],{"class":205},"( v );\n",[196,1355,1357],{"class":198,"line":1356},23,[196,1358,728],{"emptyLinePlaceholder":727},[196,1360,1362,1364,1366,1368,1370,1372,1374],{"class":198,"line":1361},24,[196,1363,753],{"class":202},[196,1365,756],{"class":205},[196,1367,782],{"class":202},[196,1369,762],{"class":205},[196,1371,765],{"class":691},[196,1373,769],{"class":768},[196,1375,772],{"class":205},[196,1377,1379],{"class":198,"line":1378},25,[196,1380,796],{"class":205},[196,1382,1384],{"class":198,"line":1383},26,[196,1385,910],{"class":205},[196,1387,1389,1391,1393,1396],{"class":198,"line":1388},27,[196,1390,1185],{"class":202},[196,1392,206],{"class":205},[196,1394,1395],{"class":209},"\"reserving smaller does not change size or capacity\"",[196,1397,674],{"class":205},[196,1399,1401,1403,1406,1408,1410],{"class":198,"line":1400},28,[196,1402,1197],{"class":205},[196,1404,1405],{"class":202},"reserve",[196,1407,206],{"class":205},[196,1409,1271],{"class":768},[196,1411,772],{"class":205},[196,1413,1415],{"class":198,"line":1414},29,[196,1416,728],{"emptyLinePlaceholder":727},[196,1418,1420,1422,1424,1426,1428,1430,1432],{"class":198,"line":1419},30,[196,1421,1216],{"class":202},[196,1423,756],{"class":205},[196,1425,759],{"class":202},[196,1427,762],{"class":205},[196,1429,765],{"class":691},[196,1431,1158],{"class":768},[196,1433,772],{"class":205},[196,1435,1437,1439,1441,1443,1445,1447,1449],{"class":198,"line":1436},31,[196,1438,1216],{"class":202},[196,1440,756],{"class":205},[196,1442,782],{"class":202},[196,1444,762],{"class":205},[196,1446,889],{"class":691},[196,1448,1158],{"class":768},[196,1450,772],{"class":205},[196,1452,1454],{"class":198,"line":1453},32,[196,1455,910],{"class":205},[196,1457,1459],{"class":198,"line":1458},33,[196,1460,916],{"class":205},[107,1462,1463],{},[110,1464,1465,115,1468,996,1470,1090,1472,36,1475,1006,1478,1481,1482,36,1485,1006,1488,1491,1492],{},[16,1466,1467],{},"TEMPLATE_PRODUCT_TEST_CASE(",[117,1469,119],{},[117,1471,123],{},[117,1473,1474],{},"template-type1",[117,1476,1477],{},"template-type2",[117,1479,1480],{},"template-typen","), (",[117,1483,1484],{},"template-arg1",[117,1486,1487],{},"template-arg2",[117,1489,1490],{},"template-argm",") ",[16,1493,127],{},[10,1495,1496],{},[13,1497,1498,1502],{},[45,1499,1020],{"href":1500,"rel":1501},"https:\u002F\u002Fgithub.com\u002Fcatchorg\u002FCatch2\u002Fissues\u002F1468",[478]," in Catch2 2.6.0.",[13,1504,1505,1035,1507,1509,1510,1512,1513,1515,1516,1519,1520,102],{},[117,1506,1474],{},[117,1508,1480],{}," is list of template\ntypes which should be combined with each of ",[117,1511,1484],{}," through\n",[117,1514,1490],{},", resulting in ",[117,1517,1518],{},"n * m"," test cases. Inside the test case,\nthe resulting type is available under the name of ",[21,1521,1041],{},[13,1523,1524,1525,367,1528,1531,1532,1535,1536,36,1538,24,1541,36,1544,1547,1548,1551,1552,102],{},"To specify more than 1 type as a single ",[117,1526,1527],{},"template-type",[117,1529,1530],{},"template-arg",",\nyou must enclose the types in an additional set of parentheses, e.g.\n",[21,1533,1534],{},"((int, float), (char, double))"," specifies 2 template-args, each\nconsisting of 2 concrete types (",[21,1537,1079],{},[21,1539,1540],{},"float",[21,1542,1543],{},"char",[21,1545,1546],{},"double","\nrespectively). You can also omit the outer set of parentheses if you\nspecify only one type as the full set of either the ",[117,1549,1550],{},"template-types",",\nor the ",[117,1553,1554],{},"template-args",[13,1556,1055],{},[187,1558,1560],{"className":189,"code":1559,"language":191,"meta":192,"style":192},"template\u003C typename T>\nstruct Foo {\n    size_t size() {\n        return 0;\n    }\n};\n\nTEMPLATE_PRODUCT_TEST_CASE(\"A Template product test case\", \"[template][product]\", (std::vector, Foo), (int, float)) {\n    TestType x;\n    REQUIRE(x.size() == 0);\n}\n",[21,1561,1562,1579,1590,1601,1611,1615,1620,1624,1654,1662,1679],{"__ignoreMap":192},[196,1563,1564,1567,1570,1573,1576],{"class":198,"line":199},[196,1565,1566],{"class":691},"template",[196,1568,1569],{"class":205},"\u003C ",[196,1571,1572],{"class":691},"typename",[196,1574,1575],{"class":202}," T",[196,1577,1578],{"class":205},">\n",[196,1580,1581,1584,1587],{"class":198,"line":228},[196,1582,1583],{"class":691},"struct",[196,1585,1586],{"class":202}," Foo",[196,1588,1589],{"class":205}," {\n",[196,1591,1592,1595,1598],{"class":198,"line":248},[196,1593,1594],{"class":691},"    size_t",[196,1596,1597],{"class":202}," size",[196,1599,1600],{"class":205},"() {\n",[196,1602,1603,1606,1608],{"class":198,"line":269},[196,1604,1605],{"class":691},"        return",[196,1607,769],{"class":768},[196,1609,1610],{"class":205},";\n",[196,1612,1613],{"class":198,"line":731},[196,1614,910],{"class":205},[196,1616,1617],{"class":198,"line":737},[196,1618,1619],{"class":205},"};\n",[196,1621,1622],{"class":198,"line":750},[196,1623,728],{"emptyLinePlaceholder":727},[196,1625,1626,1628,1630,1633,1635,1638,1640,1642,1645,1647,1649,1651],{"class":198,"line":775},[196,1627,975],{"class":202},[196,1629,832],{"class":205},[196,1631,1632],{"class":209},"\"A Template product test case\"",[196,1634,36],{"class":205},[196,1636,1637],{"class":209},"\"[template][product]\"",[196,1639,1090],{"class":205},[196,1641,710],{"class":202},[196,1643,1644],{"class":205},"::vector, Foo), (",[196,1646,1079],{"class":691},[196,1648,36],{"class":205},[196,1650,1540],{"class":691},[196,1652,1653],{"class":205},")) {\n",[196,1655,1656,1659],{"class":198,"line":793},[196,1657,1658],{"class":202},"    TestType",[196,1660,1661],{"class":205}," x;\n",[196,1663,1664,1666,1669,1671,1673,1675,1677],{"class":198,"line":799},[196,1665,1147],{"class":202},[196,1667,1668],{"class":205},"(x.",[196,1670,759],{"class":202},[196,1672,762],{"class":205},[196,1674,765],{"class":691},[196,1676,769],{"class":768},[196,1678,838],{"class":205},[196,1680,1681],{"class":198,"line":804},[196,1682,916],{"class":205},[13,1684,1685,1686,1688],{},"You can also have different arities in the ",[117,1687,1530],{}," packs:",[187,1690,1692],{"className":189,"code":1691,"language":191,"meta":192,"style":192},"TEMPLATE_PRODUCT_TEST_CASE(\"Product with differing arities\", \"[template][product]\", std::tuple, (int, (int, double), (int, double, float))) {\n    TestType x;\n    REQUIRE(std::tuple_size\u003CTestType>::value >= 1);\n}\n",[21,1693,1694,1739,1745,1771],{"__ignoreMap":192},[196,1695,1696,1698,1700,1703,1705,1707,1709,1711,1714,1716,1718,1720,1722,1724,1726,1728,1730,1732,1734,1736],{"class":198,"line":199},[196,1697,975],{"class":202},[196,1699,832],{"class":205},[196,1701,1702],{"class":209},"\"Product with differing arities\"",[196,1704,36],{"class":205},[196,1706,1637],{"class":209},[196,1708,36],{"class":205},[196,1710,710],{"class":202},[196,1712,1713],{"class":205},"::tuple, (",[196,1715,1079],{"class":691},[196,1717,1090],{"class":205},[196,1719,1079],{"class":691},[196,1721,36],{"class":205},[196,1723,1546],{"class":691},[196,1725,1481],{"class":205},[196,1727,1079],{"class":691},[196,1729,36],{"class":205},[196,1731,1546],{"class":691},[196,1733,36],{"class":205},[196,1735,1540],{"class":691},[196,1737,1738],{"class":205},"))) {\n",[196,1740,1741,1743],{"class":198,"line":228},[196,1742,1658],{"class":202},[196,1744,1661],{"class":205},[196,1746,1747,1749,1751,1753,1755,1758,1760,1762,1765,1767,1769],{"class":198,"line":248},[196,1748,1147],{"class":202},[196,1750,832],{"class":205},[196,1752,710],{"class":202},[196,1754,713],{"class":205},[196,1756,1757],{"class":202},"tuple_size",[196,1759,707],{"class":205},[196,1761,1041],{"class":202},[196,1763,1764],{"class":205},">::value ",[196,1766,889],{"class":691},[196,1768,873],{"class":768},[196,1770,838],{"class":205},[196,1772,1773],{"class":198,"line":269},[196,1774,916],{"class":205},[107,1776,1777],{},[110,1778,1779,115,1782,36,1784,36,1786,115,1789],{},[16,1780,1781],{},"TEMPLATE_LIST_TEST_CASE(",[117,1783,119],{},[117,1785,123],{},[117,1787,1788],{},"type list",[16,1790,127],{},[10,1792,1793],{},[13,1794,1795,1799],{},[45,1796,1020],{"href":1797,"rel":1798},"https:\u002F\u002Fgithub.com\u002Fcatchorg\u002FCatch2\u002Fissues\u002F1627",[478]," in Catch2 2.9.0.",[13,1801,1802,1804,1805,36,1808,36,1811,1814,1815,1818],{},[117,1803,1788],{}," is a generic list of types on which test case should be instantiated.\nList can be ",[21,1806,1807],{},"std::tuple",[21,1809,1810],{},"boost::mpl::list",[21,1812,1813],{},"boost::mp11::mp_list"," or anything with\n",[21,1816,1817],{},"template \u003Ctypename...>"," signature.",[13,1820,1821,1822,1824],{},"This allows you to reuse the ",[117,1823,1788],{}," in multiple test cases.",[13,1826,1055],{},[187,1828,1830],{"className":189,"code":1829,"language":191,"meta":192,"style":192},"using MyTypes = std::tuple\u003Cint, char, float>;\nTEMPLATE_LIST_TEST_CASE(\"Template test case with test types specified inside std::tuple\", \"[template][list]\", MyTypes)\n{\n    REQUIRE(sizeof(TestType) > 0);\n}\n",[21,1831,1832,1865,1882,1887,1905],{"__ignoreMap":192},[196,1833,1834,1837,1840,1843,1845,1847,1850,1852,1854,1856,1858,1860,1862],{"class":198,"line":199},[196,1835,1836],{"class":691},"using",[196,1838,1839],{"class":202}," MyTypes",[196,1841,1842],{"class":691}," =",[196,1844,701],{"class":202},[196,1846,713],{"class":205},[196,1848,1849],{"class":202},"tuple",[196,1851,707],{"class":205},[196,1853,1079],{"class":691},[196,1855,36],{"class":205},[196,1857,1543],{"class":691},[196,1859,36],{"class":205},[196,1861,1540],{"class":691},[196,1863,1864],{"class":205},">;\n",[196,1866,1867,1869,1871,1874,1876,1879],{"class":198,"line":228},[196,1868,978],{"class":202},[196,1870,832],{"class":205},[196,1872,1873],{"class":209},"\"Template test case with test types specified inside std::tuple\"",[196,1875,36],{"class":205},[196,1877,1878],{"class":209},"\"[template][list]\"",[196,1880,1881],{"class":205},", MyTypes)\n",[196,1883,1884],{"class":198,"line":248},[196,1885,1886],{"class":205},"{\n",[196,1888,1889,1891,1893,1896,1899,1901,1903],{"class":198,"line":269},[196,1890,1147],{"class":202},[196,1892,832],{"class":205},[196,1894,1895],{"class":691},"sizeof",[196,1897,1898],{"class":205},"(TestType) ",[196,1900,719],{"class":691},[196,1902,769],{"class":768},[196,1904,838],{"class":205},[196,1906,1907],{"class":198,"line":731},[196,1908,916],{"class":205},[178,1910,89],{"id":1911},"signature-based-parametrised-test-cases",[10,1913,1914],{},[13,1915,1916,1920],{},[45,1917,1020],{"href":1918,"rel":1919},"https:\u002F\u002Fgithub.com\u002Fcatchorg\u002FCatch2\u002Fissues\u002F1609",[478]," in Catch2 2.8.0.",[13,1922,965,1923,1926,1927,24,1930,1933,1934,1936,1937,1939,1940,102],{},[45,1924,1925],{"href":82},"type parametrised test cases"," Catch2 also supports\nsignature base parametrised test cases, in form of ",[21,1928,1929],{},"TEMPLATE_TEST_CASE_SIG",[21,1931,1932],{},"TEMPLATE_PRODUCT_TEST_CASE_SIG",".\nThese test cases have similar syntax like ",[45,1935,1925],{"href":82},", with one\nadditional positional argument which specifies the signature. These macros are defined in the\n",[21,1938,982],{}," header, so compiling the code examples below also requires\n",[21,1941,986],{},[329,1943,1945],{"id":1944},"signature","Signature",[13,1947,1948],{},"Signature has some strict rules for these tests cases to work properly:",[107,1950,1951,1961,1970,1980],{},[110,1952,1953,1954,1957,1958],{},"signature with multiple template parameters e.g. ",[21,1955,1956],{},"typename T, size_t S"," must have this format in test case declaration\n",[21,1959,1960],{},"((typename T, size_t S), T, S)",[110,1962,1963,1964,1957,1967],{},"signature with variadic template arguments e.g. ",[21,1965,1966],{},"typename T, size_t S, typename...Ts",[21,1968,1969],{},"((typename T, size_t S, typename...Ts), T, S, Ts...)",[110,1971,1972,1973,1976,1977],{},"signature with single non type template parameter e.g. ",[21,1974,1975],{},"int V"," must have this format in test case declaration ",[21,1978,1979],{},"((int V), V)",[110,1981,1982,1983,1986,1987],{},"signature with single type template parameter e.g. ",[21,1984,1985],{},"typename T"," should not be used as it is in fact ",[21,1988,971],{},[13,1990,1991],{},"Currently Catch2 support up to 11 template parameters in signature",[329,1993,1995],{"id":1994},"examples","Examples",[107,1997,1998],{},[110,1999,2000,115,2003,996,2005,999,2007,36,2009,36,2011,1006,2013,115,2015],{},[16,2001,2002],{},"TEMPLATE_TEST_CASE_SIG(",[117,2004,119],{},[117,2006,123],{},[117,2008,1944],{},[117,2010,1002],{},[117,2012,1005],{},[117,2014,1009],{},[16,2016,127],{},[13,2018,2019,2020,2022,2023,102],{},"Inside ",[21,2021,1929],{}," test case you can use the names of template parameters as defined in ",[117,2024,1944],{},[187,2026,2028],{"className":189,"code":2027,"language":191,"meta":192,"style":192},"TEMPLATE_TEST_CASE_SIG(\"TemplateTestSig: arrays can be created from NTTP arguments\", \"[vector][template][nttp]\",\n  ((typename T, int V), T, V), (int,5), (float,4), (std::string,15), ((std::tuple\u003Cint, float>), 6)) {\n\n    std::array\u003CT, V> v;\n    REQUIRE(v.size() > 1);\n}\n",[21,2029,2030,2046,2111,2115,2137,2154],{"__ignoreMap":192},[196,2031,2032,2034,2036,2039,2041,2044],{"class":198,"line":199},[196,2033,1929],{"class":202},[196,2035,832],{"class":205},[196,2037,2038],{"class":209},"\"TemplateTestSig: arrays can be created from NTTP arguments\"",[196,2040,36],{"class":205},[196,2042,2043],{"class":209},"\"[vector][template][nttp]\"",[196,2045,972],{"class":205},[196,2047,2048,2051,2053,2055,2057,2059,2062,2064,2066,2068,2070,2072,2074,2077,2079,2081,2083,2085,2087,2090,2093,2095,2097,2099,2101,2103,2106,2109],{"class":198,"line":228},[196,2049,2050],{"class":205},"  ((",[196,2052,1572],{"class":691},[196,2054,1575],{"class":202},[196,2056,36],{"class":205},[196,2058,1079],{"class":691},[196,2060,2061],{"class":205}," V), T, V), (",[196,2063,1079],{"class":691},[196,2065,1101],{"class":205},[196,2067,1136],{"class":768},[196,2069,1481],{"class":205},[196,2071,1540],{"class":691},[196,2073,1101],{"class":205},[196,2075,2076],{"class":768},"4",[196,2078,1481],{"class":205},[196,2080,710],{"class":202},[196,2082,713],{"class":205},[196,2084,716],{"class":205},[196,2086,1101],{"class":205},[196,2088,2089],{"class":768},"15",[196,2091,2092],{"class":205},"), ((",[196,2094,710],{"class":202},[196,2096,1095],{"class":205},[196,2098,1098],{"class":691},[196,2100,36],{"class":205},[196,2102,1104],{"class":691},[196,2104,2105],{"class":205},"), ",[196,2107,2108],{"class":768},"6",[196,2110,1653],{"class":205},[196,2112,2113],{"class":198,"line":248},[196,2114,728],{"emptyLinePlaceholder":727},[196,2116,2117,2119,2121,2124,2126,2129,2131,2134],{"class":198,"line":269},[196,2118,1116],{"class":202},[196,2120,713],{"class":205},[196,2122,2123],{"class":202},"array",[196,2125,707],{"class":205},[196,2127,2128],{"class":202},"T",[196,2130,36],{"class":205},[196,2132,2133],{"class":202},"V",[196,2135,2136],{"class":205},"> v;\n",[196,2138,2139,2141,2144,2146,2148,2150,2152],{"class":198,"line":731},[196,2140,1147],{"class":202},[196,2142,2143],{"class":205},"(v.",[196,2145,759],{"class":202},[196,2147,762],{"class":205},[196,2149,719],{"class":691},[196,2151,873],{"class":768},[196,2153,838],{"class":205},[196,2155,2156],{"class":198,"line":737},[196,2157,916],{"class":205},[107,2159,2160],{},[110,2161,2162,115,2165,996,2167,36,2169,1090,2171,36,2173,1006,2175,1481,2177,36,2179,1006,2181,1491,2183],{},[16,2163,2164],{},"TEMPLATE_PRODUCT_TEST_CASE_SIG(",[117,2166,119],{},[117,2168,123],{},[117,2170,1944],{},[117,2172,1474],{},[117,2174,1477],{},[117,2176,1480],{},[117,2178,1484],{},[117,2180,1487],{},[117,2182,1490],{},[16,2184,127],{},[187,2186,2188],{"className":189,"code":2187,"language":191,"meta":192,"style":192},"\ntemplate\u003Ctypename T, size_t S>\nstruct Bar {\n    size_t size() { return S; }\n};\n\nTEMPLATE_PRODUCT_TEST_CASE_SIG(\"A Template product test case with array signature\", \"[template][product][nttp]\", ((typename T, size_t S), T, S), (std::array, Bar), ((int, 9), (float, 42))) {\n    TestType x;\n    REQUIRE(x.size() > 0);\n}\n",[21,2189,2190,2210,2219,2234,2238,2242,2293,2299,2315],{"__ignoreMap":192},[196,2191,2192,2194,2196,2198,2200,2202,2205,2208],{"class":198,"line":199},[196,2193,1566],{"class":691},[196,2195,707],{"class":205},[196,2197,1572],{"class":691},[196,2199,1575],{"class":202},[196,2201,36],{"class":205},[196,2203,2204],{"class":691},"size_t",[196,2206,2207],{"class":202}," S",[196,2209,1578],{"class":205},[196,2211,2212,2214,2217],{"class":198,"line":228},[196,2213,1583],{"class":691},[196,2215,2216],{"class":202}," Bar",[196,2218,1589],{"class":205},[196,2220,2221,2223,2225,2228,2231],{"class":198,"line":248},[196,2222,1594],{"class":691},[196,2224,1597],{"class":202},[196,2226,2227],{"class":205},"() { ",[196,2229,2230],{"class":691},"return",[196,2232,2233],{"class":205}," S; }\n",[196,2235,2236],{"class":198,"line":269},[196,2237,1619],{"class":205},[196,2239,2240],{"class":198,"line":731},[196,2241,728],{"emptyLinePlaceholder":727},[196,2243,2244,2246,2248,2251,2253,2256,2259,2261,2263,2265,2267,2270,2272,2275,2277,2279,2282,2284,2286,2288,2291],{"class":198,"line":737},[196,2245,1932],{"class":202},[196,2247,832],{"class":205},[196,2249,2250],{"class":209},"\"A Template product test case with array signature\"",[196,2252,36],{"class":205},[196,2254,2255],{"class":209},"\"[template][product][nttp]\"",[196,2257,2258],{"class":205},", ((",[196,2260,1572],{"class":691},[196,2262,1575],{"class":202},[196,2264,36],{"class":205},[196,2266,2204],{"class":691},[196,2268,2269],{"class":205}," S), T, S), (",[196,2271,710],{"class":202},[196,2273,2274],{"class":205},"::array, Bar), ((",[196,2276,1079],{"class":691},[196,2278,36],{"class":205},[196,2280,2281],{"class":768},"9",[196,2283,1481],{"class":205},[196,2285,1540],{"class":691},[196,2287,36],{"class":205},[196,2289,2290],{"class":768},"42",[196,2292,1738],{"class":205},[196,2294,2295,2297],{"class":198,"line":750},[196,2296,1658],{"class":202},[196,2298,1661],{"class":205},[196,2300,2301,2303,2305,2307,2309,2311,2313],{"class":198,"line":775},[196,2302,1147],{"class":202},[196,2304,1668],{"class":205},[196,2306,759],{"class":202},[196,2308,762],{"class":205},[196,2310,719],{"class":691},[196,2312,769],{"class":768},[196,2314,838],{"class":205},[196,2316,2317],{"class":198,"line":793},[196,2318,916],{"class":205},[2320,2321,2322],"style",{},"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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}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 .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}",{"title":192,"searchDepth":228,"depth":228,"links":2324},[2325,2328,2329,2330,2331],{"id":123,"depth":228,"text":65,"children":2326},[2327],{"id":331,"depth":248,"text":332},{"id":433,"depth":228,"text":71},{"id":470,"depth":228,"text":77},{"id":962,"depth":228,"text":83},{"id":1911,"depth":228,"text":89,"children":2332},[2333,2334],{"id":1944,"depth":248,"text":1945},{"id":1994,"depth":248,"text":1995},"md",{},"\u002Fdocs\u002Ftest-cases-and-sections",{"title":5,"description":192},"docs\u002Ftest-cases-and-sections.md","docs\u002Ftest-cases-and-sections","7XQT4tBkkwMGncg1D_jOqa1X6FAlUE2f2W1Hp1j9EgQ",1794961595420]