[{"data":1,"prerenderedAt":1096},["ShallowReactive",2],{"doc-filtering-execution-path":3},{"id":4,"title":5,"body":6,"description":71,"extension":1087,"meta":1088,"navigation":1089,"path":1090,"seo":1091,"slug":1092,"source":1093,"stem":1094,"__hash__":1095},"docs\u002Fdocs\u002Ffiltering-execution-path.md","How to run specific section\u002Fgenerator",{"type":7,"value":8,"toc":1079},"minimark",[9,50,54,59,62,72,97,100,113,118,123,129,137,142,147,150,316,336,340,348,474,498,502,505,606,624,628,633,639,646,649,656,664,671,674,678,769,825,829,909,933,937,940,1036,1069,1075],[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},"how-to-run-specific-sectiongenerator",[10,55,56],{},[13,57,58],{},"The generator and generic path filtering was added in Catch2 3.13.0",[13,60,61],{},"Catch2 supports picking specific path through a test case by filtering\nsections and generator indices to run through. This is done by using one\nof the three commandline parameters, one or more times.",[63,64,69],"pre",{"className":65,"code":67,"language":68},[66],"language-text","-c, --section=NAME\n-g, --generator-index=INDEX\n-p, --path-filter=c:SECTION|g:INDEX\n","text",[21,70,67],{"__ignoreMap":71},"",[13,73,74,75,78,79,82,83,78,86,89,90,78,93,96],{},"All the variants form a shared stack of filters, but if you use only\n",[21,76,77],{},"-c","\u002F",[21,80,81],{},"--section"," form to specify section filters, you will get the old\nbehaviour, which does not affect generators at all. If you also use either\n",[21,84,85],{},"-g",[21,87,88],{},"--generator-index",", or ",[21,91,92],{},"-p",[21,94,95],{},"--path-filter",", you will get the new\nbehaviour, which can also filter generator elements.",[13,98,99],{},"Both the new and old filter behaviours include some potentially surprising\nthings:",[101,102,103,107,110],"ul",{},[104,105,106],"li",{},"Code outside of sections being skipped will still be executed. E.g.\nany setup code in the TEST_CASE that lives outside of sections.",[104,108,109],{},"Path filters filter the prefix of the path. So if you specify single\nfilter, it affects only the top level sections\u002Fgenerator, with their\nchild sections\u002Fgenerators being unfiltered.",[104,111,112],{},"Path filters are independent of test case selection, Catch2 will try\nto follow the path filters in all selected test cases. This means\nthat if you specify path filters without a test case filter, Catch2\nwill try to apply the path filters inside every registered test case.",[114,115,117],"h2",{"id":116},"old-behaviour","Old behaviour",[10,119,120],{},[13,121,122],{},"The old behaviour was deprecated in Catch2 3.13.0",[63,124,127],{"className":125,"code":126,"language":68},[66],"-c, --section           \u003Csection name>\n",[21,128,126],{"__ignoreMap":71},[13,130,131,132,78,134,136],{},"The argument to ",[21,133,77],{},[21,135,81],{}," can be any arbitrary string. When Catch2\nis deciding whether to enter a section, it will check its trimmed name\nagainst the appropriate trimmed section filter. If they are the same,\nthe section can be opened. If not, Catch2 will skip over that section.",[138,139,141],"h3",{"id":140},"examples","Examples",[143,144,146],"h4",{"id":145},"simple-section-nesting","Simple section nesting",[13,148,149],{},"Given",[63,151,155],{"className":152,"code":153,"language":154,"meta":71,"style":71},"language-cpp shiki shiki-themes github-dark","TEST_CASE( \"foo\" ) {\n    REQUIRE( true );\n    SECTION( \"A\" ) {\n        SECTION( \"A1\" ) { REQUIRE( true ); }\n        SECTION( \"A2\" ) { REQUIRE( true ); }\n    }\n    SECTION( \"B\" ) {\n        SECTION( \"B1\" ) { REQUIRE( true ); }\n        SECTION( \"B2\" ) { REQUIRE( true ); }\n    }\n}\n","cpp",[21,156,157,176,191,204,227,247,253,265,285,305,310],{"__ignoreMap":71},[158,159,162,165,169,173],"span",{"class":160,"line":161},"line",1,[158,163,23],{"class":164},"svObZ",[158,166,168],{"class":167},"s95oV","( ",[158,170,172],{"class":171},"sU2Wk","\"foo\"",[158,174,175],{"class":167}," ) {\n",[158,177,179,182,184,188],{"class":160,"line":178},2,[158,180,181],{"class":164},"    REQUIRE",[158,183,168],{"class":167},[158,185,187],{"class":186},"sDLfK","true",[158,189,190],{"class":167}," );\n",[158,192,194,197,199,202],{"class":160,"line":193},3,[158,195,196],{"class":164},"    SECTION",[158,198,168],{"class":167},[158,200,201],{"class":171},"\"A\"",[158,203,175],{"class":167},[158,205,207,210,212,215,218,220,222,224],{"class":160,"line":206},4,[158,208,209],{"class":164},"        SECTION",[158,211,168],{"class":167},[158,213,214],{"class":171},"\"A1\"",[158,216,217],{"class":167}," ) { ",[158,219,27],{"class":164},[158,221,168],{"class":167},[158,223,187],{"class":186},[158,225,226],{"class":167}," ); }\n",[158,228,230,232,234,237,239,241,243,245],{"class":160,"line":229},5,[158,231,209],{"class":164},[158,233,168],{"class":167},[158,235,236],{"class":171},"\"A2\"",[158,238,217],{"class":167},[158,240,27],{"class":164},[158,242,168],{"class":167},[158,244,187],{"class":186},[158,246,226],{"class":167},[158,248,250],{"class":160,"line":249},6,[158,251,252],{"class":167},"    }\n",[158,254,256,258,260,263],{"class":160,"line":255},7,[158,257,196],{"class":164},[158,259,168],{"class":167},[158,261,262],{"class":171},"\"B\"",[158,264,175],{"class":167},[158,266,268,270,272,275,277,279,281,283],{"class":160,"line":267},8,[158,269,209],{"class":164},[158,271,168],{"class":167},[158,273,274],{"class":171},"\"B1\"",[158,276,217],{"class":167},[158,278,27],{"class":164},[158,280,168],{"class":167},[158,282,187],{"class":186},[158,284,226],{"class":167},[158,286,288,290,292,295,297,299,301,303],{"class":160,"line":287},9,[158,289,209],{"class":164},[158,291,168],{"class":167},[158,293,294],{"class":171},"\"B2\"",[158,296,217],{"class":167},[158,298,27],{"class":164},[158,300,168],{"class":167},[158,302,187],{"class":186},[158,304,226],{"class":167},[158,306,308],{"class":160,"line":307},10,[158,309,252],{"class":167},[158,311,313],{"class":160,"line":312},11,[158,314,315],{"class":167},"}\n",[101,317,318,324,330],{},[104,319,320,323],{},[21,321,322],{},".\u002Ftests foo -c A"," runs section \"A\" and both of its subsections,\nresulting in 4 assertions.",[104,325,326,329],{},[21,327,328],{},".\u002Ftests foo -c A -c B"," runs section \"A\", but none of its subsections,\nresulting in 1 assertion (the one before \"A\").",[104,331,332,335],{},[21,333,334],{},".\u002Ftests foo -c A -c A1"," runs section \"A\" and only the \"A1\" subsection,\nresulting in 2 assertions.",[143,337,339],{"id":338},"sections-with-nested-generators","Sections with nested generators",[13,341,342,343,347],{},"Note that old behaviour completely ",[344,345,346],"em",{},"ignores"," generators. This means both\nthat they can't be filtered, but also that they aren't taken into account\nfor the filter depth. In other words, given",[63,349,351],{"className":152,"code":350,"language":154,"meta":71,"style":71},"TEST_CASE( \"bar\" ) {\n    REQUIRE( true );\n    SECTION( \"A\" ) { REQUIRE( true ); }\n    SECTION( \"B\" ) {\n        auto i = GENERATE( 1, 2, 3 );\n        DYNAMIC_SECTION( \"i=\" \u003C\u003C i ) {\n            REQUIRE( true );\n        }\n    }\n}\n",[21,352,353,364,374,392,402,434,450,461,466,470],{"__ignoreMap":71},[158,354,355,357,359,362],{"class":160,"line":161},[158,356,23],{"class":164},[158,358,168],{"class":167},[158,360,361],{"class":171},"\"bar\"",[158,363,175],{"class":167},[158,365,366,368,370,372],{"class":160,"line":178},[158,367,181],{"class":164},[158,369,168],{"class":167},[158,371,187],{"class":186},[158,373,190],{"class":167},[158,375,376,378,380,382,384,386,388,390],{"class":160,"line":193},[158,377,196],{"class":164},[158,379,168],{"class":167},[158,381,201],{"class":171},[158,383,217],{"class":167},[158,385,27],{"class":164},[158,387,168],{"class":167},[158,389,187],{"class":186},[158,391,226],{"class":167},[158,393,394,396,398,400],{"class":160,"line":206},[158,395,196],{"class":164},[158,397,168],{"class":167},[158,399,262],{"class":171},[158,401,175],{"class":167},[158,403,404,408,411,414,417,419,422,424,427,429,432],{"class":160,"line":229},[158,405,407],{"class":406},"snl16","        auto",[158,409,410],{"class":167}," i ",[158,412,413],{"class":406},"=",[158,415,416],{"class":164}," GENERATE",[158,418,168],{"class":167},[158,420,421],{"class":186},"1",[158,423,36],{"class":167},[158,425,426],{"class":186},"2",[158,428,36],{"class":167},[158,430,431],{"class":186},"3",[158,433,190],{"class":167},[158,435,436,439,441,444,447],{"class":160,"line":249},[158,437,438],{"class":164},"        DYNAMIC_SECTION",[158,440,168],{"class":167},[158,442,443],{"class":171},"\"i=\"",[158,445,446],{"class":406}," \u003C\u003C",[158,448,449],{"class":167}," i ) {\n",[158,451,452,455,457,459],{"class":160,"line":255},[158,453,454],{"class":164},"            REQUIRE",[158,456,168],{"class":167},[158,458,187],{"class":186},[158,460,190],{"class":167},[158,462,463],{"class":160,"line":267},[158,464,465],{"class":167},"        }\n",[158,467,468],{"class":160,"line":287},[158,469,252],{"class":167},[158,471,472],{"class":160,"line":307},[158,473,315],{"class":167},[101,475,476,482,492],{},[104,477,478,481],{},[21,479,480],{},".\u002Ftests bar -c A"," results in 2 assertions.",[104,483,484,487,488,491],{},[21,485,486],{},".\u002Ftests bar -c B -c i=2"," results in 4 assertions, because the whole\ngenerator in section \"B\" has to be used up, but the dynamic section is\nonly entered when the generator returns 2 as the value for ",[21,489,490],{},"i",".",[104,493,494,497],{},[21,495,496],{},".\u002Ftests bar -c B -c i=4"," results in 3 assertions, because the assertion\noutside of section is executed every time the test case is entered, and\nthe generator forces the test case to rerun 3 times before it is used up,\neven though the dynamic section will never be entered.",[143,499,501],{"id":500},"section-with-sibling-generators","Section with sibling generators",[13,503,504],{},"For cases where sections have sibling generators, the filtering can get\neven more surprising.",[63,506,508],{"className":152,"code":507,"language":154,"meta":71,"style":71},"TEST_CASE( \"qux\" ) {\n    REQUIRE( true );\n    SECTION( \"A\" ) { REQUIRE( true ); }\n    auto i = GENERATE( 1, 2, 3 );\n    DYNAMIC_SECTION( \"i=\" \u003C\u003C i ) {\n        REQUIRE( true );\n    }\n}\n",[21,509,510,521,531,549,574,587,598,602],{"__ignoreMap":71},[158,511,512,514,516,519],{"class":160,"line":161},[158,513,23],{"class":164},[158,515,168],{"class":167},[158,517,518],{"class":171},"\"qux\"",[158,520,175],{"class":167},[158,522,523,525,527,529],{"class":160,"line":178},[158,524,181],{"class":164},[158,526,168],{"class":167},[158,528,187],{"class":186},[158,530,190],{"class":167},[158,532,533,535,537,539,541,543,545,547],{"class":160,"line":193},[158,534,196],{"class":164},[158,536,168],{"class":167},[158,538,201],{"class":171},[158,540,217],{"class":167},[158,542,27],{"class":164},[158,544,168],{"class":167},[158,546,187],{"class":186},[158,548,226],{"class":167},[158,550,551,554,556,558,560,562,564,566,568,570,572],{"class":160,"line":206},[158,552,553],{"class":406},"    auto",[158,555,410],{"class":167},[158,557,413],{"class":406},[158,559,416],{"class":164},[158,561,168],{"class":167},[158,563,421],{"class":186},[158,565,36],{"class":167},[158,567,426],{"class":186},[158,569,36],{"class":167},[158,571,431],{"class":186},[158,573,190],{"class":167},[158,575,576,579,581,583,585],{"class":160,"line":229},[158,577,578],{"class":164},"    DYNAMIC_SECTION",[158,580,168],{"class":167},[158,582,443],{"class":171},[158,584,446],{"class":406},[158,586,449],{"class":167},[158,588,589,592,594,596],{"class":160,"line":249},[158,590,591],{"class":164},"        REQUIRE",[158,593,168],{"class":167},[158,595,187],{"class":186},[158,597,190],{"class":167},[158,599,600],{"class":160,"line":255},[158,601,252],{"class":167},[158,603,604],{"class":160,"line":267},[158,605,315],{"class":167},[101,607,608,618],{},[104,609,610,613,614,617],{},[21,611,612],{},".\u002Ftests qux -c A"," results in ",[16,615,616],{},"4"," assertions, because section \"A\" is\nentered once, but the sibling generator has to be exhausted, and\nthe first assertion is executed once per generator element.",[104,619,620,623],{},[21,621,622],{},".\u002Ftests qux -c i=2"," also results in 4 assertions. Once again,\nthe generator has to be exhausted and the dynamic section is entered\nonce.",[114,625,627],{"id":626},"new-behaviour","New behaviour",[10,629,630],{},[13,631,632],{},"The new behaviour was introduced in Catch2 3.13.0",[63,634,637],{"className":635,"code":636,"language":68},[66],"-g, --generator-index=INDEX\n-p, --path-filter=c:SECTION|g:INDEX\n",[21,638,636],{"__ignoreMap":71},[13,640,131,641,78,643,645],{},[21,642,85],{},[21,644,88],{}," must be either a non-negative\nnumber, which is interpreted as the index of the desired element from\nthe generator, or \"*\", which allows all elements from the generator.",[13,647,648],{},"Providing index outside of the generator is an error.",[13,650,131,651,78,653,655],{},[21,652,92],{},[21,654,95],{}," must start with either \"c:\" for\na section filter, or with \"g:\" for a generator filter. Everything past\nthe colon is then parsed as either a section filter, or a generator filter.",[13,657,658,659,78,661,663],{},"Note that using ",[21,660,13],{},[21,662,95],{}," enables new filtering behaviour, even\nif it is only used to add section filters.",[13,665,666,667,670],{},"There is another important difference between filtering out sections and\ngenerators. A section can be left un-entered, but a generator always has\nto be active. For this reason, if generator fails a filter\n(e.g. there is a section filter at given depth instead), it has to stop\nthe execution of the test case. Currently, this is done via ",[21,668,669],{},"SKIP()","\nequivalent, causing the section to be considered skipped.",[138,672,141],{"id":673},"examples-1",[143,675,677],{"id":676},"nested-generators","Nested generators",[63,679,681],{"className":152,"code":680,"language":154,"meta":71,"style":71},"TEST_CASE( \"waldo\" ) {\n    auto i = GENERATE( 1, 10, 100 );\n    auto j = GENERATE( 2, 20, 200 );\n    CAPTURE( i, j );\n    REQUIRE( true );\n}\n",[21,682,683,694,720,747,755,765],{"__ignoreMap":71},[158,684,685,687,689,692],{"class":160,"line":161},[158,686,23],{"class":164},[158,688,168],{"class":167},[158,690,691],{"class":171},"\"waldo\"",[158,693,175],{"class":167},[158,695,696,698,700,702,704,706,708,710,713,715,718],{"class":160,"line":178},[158,697,553],{"class":406},[158,699,410],{"class":167},[158,701,413],{"class":406},[158,703,416],{"class":164},[158,705,168],{"class":167},[158,707,421],{"class":186},[158,709,36],{"class":167},[158,711,712],{"class":186},"10",[158,714,36],{"class":167},[158,716,717],{"class":186},"100",[158,719,190],{"class":167},[158,721,722,724,727,729,731,733,735,737,740,742,745],{"class":160,"line":193},[158,723,553],{"class":406},[158,725,726],{"class":167}," j ",[158,728,413],{"class":406},[158,730,416],{"class":164},[158,732,168],{"class":167},[158,734,426],{"class":186},[158,736,36],{"class":167},[158,738,739],{"class":186},"20",[158,741,36],{"class":167},[158,743,744],{"class":186},"200",[158,746,190],{"class":167},[158,748,749,752],{"class":160,"line":206},[158,750,751],{"class":164},"    CAPTURE",[158,753,754],{"class":167},"( i, j );\n",[158,756,757,759,761,763],{"class":160,"line":229},[158,758,181],{"class":164},[158,760,168],{"class":167},[158,762,187],{"class":186},[158,764,190],{"class":167},[158,766,767],{"class":160,"line":249},[158,768,315],{"class":167},[101,770,771,781,790,799,806,816],{},[104,772,773,776,777,780],{},[21,774,775],{},".\u002Ftests waldo -g 1"," results in 3 assertions, with ",[21,778,779],{},"i := 10",", because\nthe second nested generator is unfiltered.",[104,782,783,786,787,491],{},[21,784,785],{},".\u002Ftests waldo -g 1 -g 2"," results in 1 assertion, with ",[21,788,789],{},"i := 10, j := 200",[104,791,792,795,796,491],{},[21,793,794],{},".\u002Ftests waldo -g * -g 2"," results in 3 assertions, all with ",[21,797,798],{},"j := 200",[104,800,801,795,804,491],{},[21,802,803],{},".\u002Ftests waldo -g 1 -g *",[21,805,779],{},[104,807,808,811,812,815],{},[21,809,810],{},".\u002Ftests waldo -g 3"," results in 1 ",[16,813,814],{},"failed"," assertion, because the first\ngenerator does not have 3rd element.",[104,817,818,821,822,824],{},[21,819,820],{},".\u002Ftests waldo -g * -g 3"," results in 3 ",[16,823,814],{}," assertions, as the\nsecond generator does not have 3rd element, but we have to exhaust the\nfirst generator.",[143,826,828],{"id":827},"generator-with-a-nested-dynamic-section","Generator with a nested dynamic section",[63,830,832],{"className":152,"code":831,"language":154,"meta":71,"style":71},"TEST_CASE( \"grault\" ) {\n    REQUIRE( true );\n    auto i = GENERATE( 1, 2, 3 );\n    DYNAMIC_SECTION( \"i=\" \u003C\u003C i ) {\n        REQUIRE( true );\n    }\n}\n",[21,833,834,845,855,879,891,901,905],{"__ignoreMap":71},[158,835,836,838,840,843],{"class":160,"line":161},[158,837,23],{"class":164},[158,839,168],{"class":167},[158,841,842],{"class":171},"\"grault\"",[158,844,175],{"class":167},[158,846,847,849,851,853],{"class":160,"line":178},[158,848,181],{"class":164},[158,850,168],{"class":167},[158,852,187],{"class":186},[158,854,190],{"class":167},[158,856,857,859,861,863,865,867,869,871,873,875,877],{"class":160,"line":193},[158,858,553],{"class":406},[158,860,410],{"class":167},[158,862,413],{"class":406},[158,864,416],{"class":164},[158,866,168],{"class":167},[158,868,421],{"class":186},[158,870,36],{"class":167},[158,872,426],{"class":186},[158,874,36],{"class":167},[158,876,431],{"class":186},[158,878,190],{"class":167},[158,880,881,883,885,887,889],{"class":160,"line":206},[158,882,578],{"class":164},[158,884,168],{"class":167},[158,886,443],{"class":171},[158,888,446],{"class":406},[158,890,449],{"class":167},[158,892,893,895,897,899],{"class":160,"line":229},[158,894,591],{"class":164},[158,896,168],{"class":167},[158,898,187],{"class":186},[158,900,190],{"class":167},[158,902,903],{"class":160,"line":249},[158,904,252],{"class":167},[158,906,907],{"class":160,"line":255},[158,908,315],{"class":167},[101,910,911,917,923],{},[104,912,913,916],{},[21,914,915],{},".\u002Ftests grault -p g:1"," results in 2 assertions, as there is no filter\non the dynamic section.",[104,918,919,922],{},[21,920,921],{},".\u002Ftests grault -p g:1 -p c:i=2"," results in 2 assertions, as the filter\non the dynamic section matches the element given from the generator.",[104,924,925,928,929,932],{},[21,926,927],{},".\u002Ftests grault -p g:1 -p c:i=3"," results in 1 assertion, as the generator\nis limited to only try ",[21,930,931],{},"i := 2"," and the dynamic section is filtered out.",[143,934,936],{"id":935},"section-with-a-sibling-generator","Section with a sibling generator",[13,938,939],{},"Because generators have to stop test execution when they don't pass filter,\nit is impossible to run only a section with sibling generator without\ntriggering a test case skip. Consider this test case from an earlier example:",[63,941,942],{"className":152,"code":507,"language":154,"meta":71,"style":71},[21,943,944,954,964,982,1006,1018,1028,1032],{"__ignoreMap":71},[158,945,946,948,950,952],{"class":160,"line":161},[158,947,23],{"class":164},[158,949,168],{"class":167},[158,951,518],{"class":171},[158,953,175],{"class":167},[158,955,956,958,960,962],{"class":160,"line":178},[158,957,181],{"class":164},[158,959,168],{"class":167},[158,961,187],{"class":186},[158,963,190],{"class":167},[158,965,966,968,970,972,974,976,978,980],{"class":160,"line":193},[158,967,196],{"class":164},[158,969,168],{"class":167},[158,971,201],{"class":171},[158,973,217],{"class":167},[158,975,27],{"class":164},[158,977,168],{"class":167},[158,979,187],{"class":186},[158,981,226],{"class":167},[158,983,984,986,988,990,992,994,996,998,1000,1002,1004],{"class":160,"line":206},[158,985,553],{"class":406},[158,987,410],{"class":167},[158,989,413],{"class":406},[158,991,416],{"class":164},[158,993,168],{"class":167},[158,995,421],{"class":186},[158,997,36],{"class":167},[158,999,426],{"class":186},[158,1001,36],{"class":167},[158,1003,431],{"class":186},[158,1005,190],{"class":167},[158,1007,1008,1010,1012,1014,1016],{"class":160,"line":229},[158,1009,578],{"class":164},[158,1011,168],{"class":167},[158,1013,443],{"class":171},[158,1015,446],{"class":406},[158,1017,449],{"class":167},[158,1019,1020,1022,1024,1026],{"class":160,"line":249},[158,1021,591],{"class":164},[158,1023,168],{"class":167},[158,1025,187],{"class":186},[158,1027,190],{"class":167},[158,1029,1030],{"class":160,"line":255},[158,1031,252],{"class":167},[158,1033,1034],{"class":160,"line":267},[158,1035,315],{"class":167},[101,1037,1038,1044,1050,1060],{},[104,1039,1040,1043],{},[21,1041,1042],{},".\u002Ftests qux -p g:1"," results in 2 assertions, as the dynamic section is\nentered only once.",[104,1045,1046,1049],{},[21,1047,1048],{},".\u002Ftests qux -p g:1 -p c:i=1"," results in 1 assertion, as the dynamic\nsection filter is incompatible with the generator filter.",[104,1051,1052,1055,1056,1059],{},[21,1053,1054],{},".\u002Ftests qux -p c:A"," results in 2 assertions ",[16,1057,1058],{},"and a skipped test case",".\nThis is because the generator is sibling to section \"A\", and thus reads\nthe same section filter. However, it is not a section and as thus cannot\nproceed.",[104,1061,1062,1065,1066,1068],{},[21,1063,1064],{},".\u002Ftests qux -p c:i=2"," results in 1 assertion ",[16,1067,1058],{},".\nOnce again, the first filter in the filter stack is a section filter,\nand thus the generator cannot proceed.",[13,1070,1071,1072,1074],{},"Compare this with the old filter behaviour, where ",[21,1073,622],{},"\nwould instead result in 4 assertions, because the generator would go\nthrough all elements.",[1076,1077,1078],"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 .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}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}",{"title":71,"searchDepth":178,"depth":178,"links":1080},[1081,1084],{"id":116,"depth":178,"text":117,"children":1082},[1083],{"id":140,"depth":193,"text":141},{"id":626,"depth":178,"text":627,"children":1085},[1086],{"id":673,"depth":193,"text":141},"md",{},true,"\u002Fdocs\u002Ffiltering-execution-path",{"title":5,"description":71},"filtering-execution-path","docs\u002Ffiltering-execution-path.md","docs\u002Ffiltering-execution-path","C4_nXMudFGjzsGdzzJ-SN3VOoeMh0dQstPHVty0Kb3k",1794961591527]