Something went wrong. Try again.
The open source OpenXR runtime
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308830983108311831283138314831583168317831883198320832183228323832483258326832783288329833083318332833383348335833683378338833983408341834283438344834583468347834883498350835183528353835483558356835783588359836083618362836383648365836683678368836983708371837283738374837583768377837883798380838183828383838483858386838783888389839083918392839383948395839683978398839984008401840284038404840584068407840884098410841184128413841484158416841784188419842084218422842384248425842684278428842984308431843284338434843584368437843884398440844184428443844484458446844784488449845084518452845384548455845684578458845984608461846284638464846584668467846884698470847184728473847484758476847784788479848084818482848384848485848684878488848984908491849284938494849584968497849884998500850185028503850485058506850785088509851085118512851385148515851685178518851985208521852285238524852585268527852885298530853185328533853485358536853785388539854085418542854385448545854685478548854985508551855285538554855585568557855885598560856185628563856485658566856785688569857085718572857385748575857685778578857985808581858285838584858585868587858885898590859185928593859485958596859785988599860086018602860386048605860686078608860986108611861286138614861586168617861886198620862186228623862486258626862786288629863086318632863386348635863686378638863986408641864286438644864586468647864886498650865186528653865486558656865786588659866086618662866386648665866686678668866986708671867286738674867586768677867886798680868186828683868486858686868786888689869086918692869386948695869686978698869987008701870287038704870587068707870887098710871187128713871487158716871787188719872087218722872387248725872687278728872987308731873287338734873587368737873887398740874187428743874487458746874787488749875087518752875387548755875687578758875987608761876287638764876587668767876887698770877187728773877487758776877787788779878087818782878387848785878687878788878987908791879287938794879587968797879887998800880188028803880488058806880788088809881088118812881388148815881688178818881988208821882288238824882588268827882888298830883188328833883488358836883788388839884088418842884388448845884688478848884988508851885288538854885588568857885888598860886188628863886488658866886788688869887088718872887388748875887688778878887988808881888288838884888588868887888888898890889188928893889488958896889788988899890089018902890389048905890689078908890989108911891289138914891589168917891889198920892189228923892489258926892789288929893089318932893389348935893689378938893989408941894289438944894589468947894889498950895189528953895489558956895789588959896089618962896389648965896689678968896989708971897289738974897589768977897889798980898189828983898489858986898789888989899089918992899389948995899689978998899990009001900290039004900590069007900890099010901190129013901490159016901790189019902090219022902390249025902690279028902990309031903290339034903590369037903890399040904190429043904490459046904790489049905090519052905390549055905690579058905990609061906290639064906590669067906890699070907190729073907490759076907790789079908090819082908390849085908690879088908990909091909290939094909590969097909890999100910191029103910491059106910791089109911091119112911391149115911691179118911991209121912291239124912591269127912891299130913191329133913491359136913791389139914091419142914391449145914691479148914991509151915291539154915591569157915891599160916191629163916491659166916791689169917091719172917391749175917691779178917991809181918291839184918591869187918891899190919191929193919491959196919791989199920092019202920392049205920692079208920992109211921292139214921592169217921892199220922192229223922492259226922792289229923092319232923392349235923692379238923992409241924292439244924592469247924892499250925192529253925492559256925792589259926092619262926392649265926692679268926992709271927292739274927592769277927892799280928192829283928492859286928792889289929092919292929392949295929692979298929993009301930293039304930593069307930893099310931193129313931493159316931793189319932093219322932393249325932693279328932993309331933293339334933593369337933893399340934193429343934493459346934793489349935093519352935393549355935693579358935993609361936293639364936593669367936893699370937193729373937493759376937793789379938093819382938393849385938693879388938993909391939293939394939593969397939893999400940194029403940494059406940794089409941094119412941394149415941694179418941994209421942294239424942594269427942894299430943194329433943494359436943794389439944094419442944394449445944694479448944994509451945294539454945594569457945894599460946194629463946494659466946794689469947094719472947394749475947694779478947994809481948294839484948594869487948894899490949194929493949494959496949794989499950095019502950395049505950695079508950995109511951295139514951595169517951895199520952195229523952495259526952795289529953095319532953395349535953695379538953995409541954295439544954595469547954895499550955195529553955495559556955795589559956095619562956395649565956695679568956995709571957295739574957595769577957895799580958195829583958495859586958795889589959095919592959395949595959695979598959996009601960296039604960596069607960896099610961196129613961496159616961796189619962096219622962396249625962696279628962996309631963296339634963596369637963896399640964196429643964496459646964796489649965096519652965396549655965696579658965996609661966296639664966596669667966896699670967196729673967496759676967796789679968096819682968396849685968696879688968996909691969296939694969596969697969896999700970197029703970497059706970797089709971097119712971397149715971697179718971997209721972297239724972597269727972897299730973197329733973497359736973797389739974097419742974397449745974697479748974997509751975297539754975597569757975897599760976197629763976497659766976797689769977097719772977397749775977697779778977997809781978297839784978597869787978897899790979197929793979497959796979797989799980098019802980398049805980698079808980998109811981298139814981598169817981898199820982198229823982498259826982798289829983098319832983398349835983698379838983998409841984298439844984598469847984898499850985198529853985498559856985798589859986098619862986398649865986698679868986998709871987298739874987598769877987898799880988198829883988498859886988798889889989098919892989398949895989698979898989999009901990299039904990599069907990899099910991199129913991499159916991799189919992099219922992399249925992699279928992999309931993299339934993599369937993899399940994199429943994499459946994799489949995099519952995399549955995699579958995999609961996299639964996599669967996899699970997199729973997499759976997799789979998099819982998399849985998699879988998999909991999299939994999599969997999899991000010001100021000310004100051000610007100081000910010100111001210013100141001510016100171001810019100201002110022100231002410025100261002710028100291003010031100321003310034100351003610037100381003910040100411004210043100441004510046100471004810049100501005110052100531005410055100561005710058100591006010061100621006310064100651006610067100681006910070100711007210073100741007510076100771007810079100801008110082100831008410085100861008710088100891009010091100921009310094100951009610097100981009910100101011010210103101041010510106101071010810109101101011110112101131011410115101161011710118101191012010121101221012310124101251012610127101281012910130101311013210133101341013510136101371013810139101401014110142101431014410145101461014710148101491015010151101521015310154101551015610157101581015910160101611016210163101641016510166101671016810169101701017110172101731017410175101761017710178101791018010181101821018310184101851018610187101881018910190101911019210193101941019510196101971019810199102001020110202102031020410205102061020710208102091021010211102121021310214102151021610217102181021910220102211022210223102241022510226102271022810229102301023110232102331023410235102361023710238102391024010241102421024310244102451024610247102481024910250102511025210253102541025510256102571025810259102601026110262102631026410265102661026710268102691027010271102721027310274102751027610277102781027910280102811028210283102841028510286102871028810289102901029110292102931029410295102961029710298102991030010301103021030310304103051030610307103081030910310103111031210313103141031510316103171031810319103201032110322103231032410325103261032710328103291033010331103321033310334103351033610337103381033910340103411034210343103441034510346103471034810349103501035110352103531035410355103561035710358103591036010361103621036310364103651036610367103681036910370103711037210373103741037510376103771037810379103801038110382103831038410385103861038710388103891039010391103921039310394103951039610397103981039910400104011040210403104041040510406104071040810409104101041110412104131041410415104161041710418104191042010421104221042310424104251042610427104281042910430104311043210433104341043510436104371043810439104401044110442104431044410445104461044710448104491045010451104521045310454104551045610457104581045910460104611046210463104641046510466104671046810469104701047110472104731047410475104761047710478104791048010481104821048310484104851048610487104881048910490104911049210493104941049510496104971049810499105001050110502105031050410505105061050710508105091051010511105121051310514105151051610517105181051910520105211052210523105241052510526105271052810529105301053110532105331053410535105361053710538105391054010541105421054310544105451054610547105481054910550105511055210553105541055510556105571055810559105601056110562105631056410565105661056710568105691057010571105721057310574105751057610577105781057910580105811058210583105841058510586105871058810589105901059110592105931059410595105961059710598105991060010601106021060310604106051060610607106081060910610106111061210613106141061510616106171061810619106201062110622106231062410625106261062710628106291063010631106321063310634106351063610637106381063910640106411064210643106441064510646106471064810649106501065110652106531065410655106561065710658106591066010661106621066310664106651066610667106681066910670106711067210673106741067510676106771067810679106801068110682106831068410685106861068710688106891069010691106921069310694106951069610697106981069910700107011070210703107041070510706107071070810709107101071110712107131071410715107161071710718107191072010721107221072310724107251072610727107281072910730107311073210733107341073510736107371073810739107401074110742107431074410745107461074710748107491075010751107521075310754107551075610757107581075910760107611076210763107641076510766107671076810769107701077110772107731077410775107761077710778107791078010781107821078310784107851078610787107881078910790107911079210793107941079510796107971079810799108001080110802108031080410805108061080710808108091081010811108121081310814108151081610817108181081910820108211082210823108241082510826108271082810829108301083110832108331083410835108361083710838108391084010841108421084310844108451084610847108481084910850108511085210853108541085510856108571085810859108601086110862108631086410865108661086710868108691087010871108721087310874108751087610877108781087910880108811088210883108841088510886108871088810889108901089110892108931089410895108961089710898108991090010901109021090310904109051090610907109081090910910109111091210913109141091510916109171091810919109201092110922109231092410925109261092710928109291093010931109321093310934109351093610937109381093910940109411094210943109441094510946109471094810949109501095110952109531095410955109561095710958109591096010961109621096310964109651096610967109681096910970109711097210973109741097510976109771097810979109801098110982109831098410985109861098710988109891099010991109921099310994109951099610997109981099911000110011100211003110041100511006110071100811009110101101111012110131101411015110161101711018110191102011021110221102311024110251102611027110281102911030110311103211033110341103511036110371103811039110401104111042110431104411045110461104711048110491105011051110521105311054110551105611057110581105911060110611106211063110641106511066110671106811069110701107111072110731107411075110761107711078110791108011081110821108311084110851108611087110881108911090110911109211093110941109511096110971109811099111001110111102111031110411105111061110711108111091111011111111121111311114111151111611117111181111911120111211112211123111241112511126111271112811129111301113111132111331113411135111361113711138111391114011141111421114311144111451114611147111481114911150111511115211153111541115511156111571115811159111601116111162111631116411165111661116711168111691117011171111721117311174111751117611177111781117911180111811118211183111841118511186111871118811189111901119111192111931119411195111961119711198111991120011201112021120311204112051120611207112081120911210112111121211213112141121511216112171121811219112201122111222112231122411225112261122711228112291123011231112321123311234112351123611237112381123911240112411124211243112441124511246112471124811249112501125111252112531125411255112561125711258112591126011261112621126311264112651126611267112681126911270112711127211273112741127511276112771127811279112801128111282112831128411285112861128711288112891129011291112921129311294112951129611297112981129911300113011130211303113041130511306113071130811309113101131111312113131131411315113161131711318113191132011321113221132311324113251132611327113281132911330113311133211333113341133511336113371133811339113401134111342113431134411345113461134711348113491135011351113521135311354113551135611357113581135911360113611136211363113641136511366113671136811369113701137111372113731137411375113761137711378113791138011381113821138311384113851138611387113881138911390113911139211393113941139511396113971139811399114001140111402114031140411405114061140711408114091141011411114121141311414114151141611417114181141911420114211142211423114241142511426114271142811429114301143111432114331143411435114361143711438114391144011441114421144311444114451144611447114481144911450114511145211453114541145511456114571145811459114601146111462114631146411465114661146711468114691147011471114721147311474114751147611477114781147911480114811148211483114841148511486114871148811489114901149111492114931149411495114961149711498114991150011501115021150311504115051150611507115081150911510115111151211513115141151511516115171151811519115201152111522115231152411525115261152711528115291153011531115321153311534115351153611537115381153911540115411154211543115441154511546115471154811549115501155111552115531155411555115561155711558115591156011561115621156311564115651156611567115681156911570115711157211573115741157511576115771157811579115801158111582115831158411585115861158711588115891159011591115921159311594115951159611597115981159911600116011160211603116041160511606116071160811609116101161111612116131161411615116161161711618116191162011621116221162311624116251162611627116281162911630116311163211633116341163511636116371163811639
// Copyright Catch2 Authors// Distributed under the Boost Software License, Version 1.0.// (See accompanying file LICENSE.txt or copy at// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
// Catch v3.6.0// Generated: 2024-05-05 20:53:27.562886// ----------------------------------------------------------// This file is an amalgamation of multiple different files.// You probably shouldn't edit it directly.// ----------------------------------------------------------
#include "catch_amalgamated.hpp"
#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
#if defined(CATCH_PLATFORM_WINDOWS)
// We might end up with the define made globally through the compiler,// and we don't want to trigger warnings for this#if !defined(NOMINMAX)# define NOMINMAX#endif#if !defined(WIN32_LEAN_AND_MEAN)# define WIN32_LEAN_AND_MEAN#endif
#include <windows.h>
#endif // defined(CATCH_PLATFORM_WINDOWS)
#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
namespace Catch { namespace Benchmark { namespace Detail { ChronometerConcept::~ChronometerConcept() = default; } // namespace Detail } // namespace Benchmark} // namespace Catch
// Adapted from donated nonius code.
#include <vector>
namespace Catch { namespace Benchmark { namespace Detail { SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) { if (!cfg.benchmarkNoAnalysis()) { std::vector<double> samples; samples.reserve(static_cast<size_t>(last - first)); for (auto current = first; current != last; ++current) { samples.push_back( current->count() ); }
auto analysis = Catch::Benchmark::Detail::analyse_samples( cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.data(), samples.data() + samples.size() ); auto outliers = Catch::Benchmark::Detail::classify_outliers( samples.data(), samples.data() + samples.size() );
auto wrap_estimate = [](Estimate<double> e) { return Estimate<FDuration> { FDuration(e.point), FDuration(e.lower_bound), FDuration(e.upper_bound), e.confidence_interval, }; }; std::vector<FDuration> samples2; samples2.reserve(samples.size()); for (auto s : samples) { samples2.push_back( FDuration( s ) ); }
return { CATCH_MOVE(samples2), wrap_estimate(analysis.mean), wrap_estimate(analysis.standard_deviation), outliers, analysis.outlier_variance, }; } else { std::vector<FDuration> samples; samples.reserve(static_cast<size_t>(last - first));
FDuration mean = FDuration(0); int i = 0; for (auto it = first; it < last; ++it, ++i) { samples.push_back(*it); mean += *it; } mean /= i;
return SampleAnalysis{ CATCH_MOVE(samples), Estimate<FDuration>{ mean, mean, mean, 0.0 }, Estimate<FDuration>{ FDuration( 0 ), FDuration( 0 ), FDuration( 0 ), 0.0 }, OutlierClassification{}, 0.0 }; } } } // namespace Detail } // namespace Benchmark} // namespace Catch
namespace Catch { namespace Benchmark { namespace Detail { BenchmarkFunction::callable::~callable() = default; } // namespace Detail } // namespace Benchmark} // namespace Catch
#include <exception>
namespace Catch { namespace Benchmark { namespace Detail { struct optimized_away_error : std::exception { const char* what() const noexcept override; };
const char* optimized_away_error::what() const noexcept { return "could not measure benchmark, maybe it was optimized away"; }
void throw_optimized_away_error() { Catch::throw_exception(optimized_away_error{}); }
} // namespace Detail } // namespace Benchmark} // namespace Catch
// Adapted from donated nonius code.
#include <algorithm>#include <cassert>#include <cmath>#include <cstddef>#include <numeric>#include <random>
#if defined(CATCH_CONFIG_USE_ASYNC)#include <future>#endif
namespace Catch { namespace Benchmark { namespace Detail { namespace {
template <typename URng, typename Estimator> static sample resample( URng& rng, unsigned int resamples, double const* first, double const* last, Estimator& estimator ) { auto n = static_cast<size_t>( last - first ); Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
sample out; out.reserve( resamples ); std::vector<double> resampled; resampled.reserve( n ); for ( size_t i = 0; i < resamples; ++i ) { resampled.clear(); for ( size_t s = 0; s < n; ++s ) { resampled.push_back( first[dist( rng )] ); } const auto estimate = estimator( resampled.data(), resampled.data() + resampled.size() ); out.push_back( estimate ); } std::sort( out.begin(), out.end() ); return out; }
static double outlier_variance( Estimate<double> mean, Estimate<double> stddev, int n ) { double sb = stddev.point; double mn = mean.point / n; double mg_min = mn / 2.; double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) ); double sg2 = sg * sg; double sb2 = sb * sb;
auto c_max = [n, mn, sb2, sg2]( double x ) -> double { double k = mn - x; double d = k * k; double nd = n * d; double k0 = -n * nd; double k1 = sb2 - n * sg2 + nd; double det = k1 * k1 - 4 * sg2 * k0; return static_cast<int>( -2. * k0 / ( k1 + std::sqrt( det ) ) ); };
auto var_out = [n, sb2, sg2]( double c ) { double nc = n - c; return ( nc / n ) * ( sb2 - nc * sg2 ); };
return (std::min)( var_out( 1 ), var_out( (std::min)( c_max( 0. ), c_max( mg_min ) ) ) ) / sb2; }
static double erf_inv( double x ) { // Code accompanying the article "Approximating the erfinv // function" in GPU Computing Gems, Volume 2 double w, p;
w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
if ( w < 6.250000 ) { w = w - 3.125000; p = -3.6444120640178196996e-21; p = -1.685059138182016589e-19 + p * w; p = 1.2858480715256400167e-18 + p * w; p = 1.115787767802518096e-17 + p * w; p = -1.333171662854620906e-16 + p * w; p = 2.0972767875968561637e-17 + p * w; p = 6.6376381343583238325e-15 + p * w; p = -4.0545662729752068639e-14 + p * w; p = -8.1519341976054721522e-14 + p * w; p = 2.6335093153082322977e-12 + p * w; p = -1.2975133253453532498e-11 + p * w; p = -5.4154120542946279317e-11 + p * w; p = 1.051212273321532285e-09 + p * w; p = -4.1126339803469836976e-09 + p * w; p = -2.9070369957882005086e-08 + p * w; p = 4.2347877827932403518e-07 + p * w; p = -1.3654692000834678645e-06 + p * w; p = -1.3882523362786468719e-05 + p * w; p = 0.0001867342080340571352 + p * w; p = -0.00074070253416626697512 + p * w; p = -0.0060336708714301490533 + p * w; p = 0.24015818242558961693 + p * w; p = 1.6536545626831027356 + p * w; } else if ( w < 16.000000 ) { w = sqrt( w ) - 3.250000; p = 2.2137376921775787049e-09; p = 9.0756561938885390979e-08 + p * w; p = -2.7517406297064545428e-07 + p * w; p = 1.8239629214389227755e-08 + p * w; p = 1.5027403968909827627e-06 + p * w; p = -4.013867526981545969e-06 + p * w; p = 2.9234449089955446044e-06 + p * w; p = 1.2475304481671778723e-05 + p * w; p = -4.7318229009055733981e-05 + p * w; p = 6.8284851459573175448e-05 + p * w; p = 2.4031110387097893999e-05 + p * w; p = -0.0003550375203628474796 + p * w; p = 0.00095328937973738049703 + p * w; p = -0.0016882755560235047313 + p * w; p = 0.0024914420961078508066 + p * w; p = -0.0037512085075692412107 + p * w; p = 0.005370914553590063617 + p * w; p = 1.0052589676941592334 + p * w; p = 3.0838856104922207635 + p * w; } else { w = sqrt( w ) - 5.000000; p = -2.7109920616438573243e-11; p = -2.5556418169965252055e-10 + p * w; p = 1.5076572693500548083e-09 + p * w; p = -3.7894654401267369937e-09 + p * w; p = 7.6157012080783393804e-09 + p * w; p = -1.4960026627149240478e-08 + p * w; p = 2.9147953450901080826e-08 + p * w; p = -6.7711997758452339498e-08 + p * w; p = 2.2900482228026654717e-07 + p * w; p = -9.9298272942317002539e-07 + p * w; p = 4.5260625972231537039e-06 + p * w; p = -1.9681778105531670567e-05 + p * w; p = 7.5995277030017761139e-05 + p * w; p = -0.00021503011930044477347 + p * w; p = -0.00013871931833623122026 + p * w; p = 1.0103004648645343977 + p * w; p = 4.8499064014085844221 + p * w; } return p * x; }
static double standard_deviation( double const* first, double const* last ) { auto m = Catch::Benchmark::Detail::mean( first, last ); double variance = std::accumulate( first, last, 0., [m]( double a, double b ) { double diff = b - m; return a + diff * diff; } ) / ( last - first ); return std::sqrt( variance ); }
static sample jackknife( double ( *estimator )( double const*, double const* ), double* first, double* last ) { const auto second = first + 1; sample results; results.reserve( static_cast<size_t>( last - first ) );
for ( auto it = first; it != last; ++it ) { std::iter_swap( it, first ); results.push_back( estimator( second, last ) ); }
return results; }
} // namespace } // namespace Detail } // namespace Benchmark} // namespace Catch
namespace Catch { namespace Benchmark { namespace Detail {
double weighted_average_quantile( int k, int q, double* first, double* last ) { auto count = last - first; double idx = (count - 1) * k / static_cast<double>(q); int j = static_cast<int>(idx); double g = idx - j; std::nth_element(first, first + j, last); auto xj = first[j]; if ( Catch::Detail::directCompare( g, 0 ) ) { return xj; }
auto xj1 = *std::min_element(first + (j + 1), last); return xj + g * (xj1 - xj); }
OutlierClassification classify_outliers( double const* first, double const* last ) { std::vector<double> copy( first, last );
auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() ); auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() ); auto iqr = q3 - q1; auto los = q1 - ( iqr * 3. ); auto lom = q1 - ( iqr * 1.5 ); auto him = q3 + ( iqr * 1.5 ); auto his = q3 + ( iqr * 3. );
OutlierClassification o; for ( ; first != last; ++first ) { const double t = *first; if ( t < los ) { ++o.low_severe; } else if ( t < lom ) { ++o.low_mild; } else if ( t > his ) { ++o.high_severe; } else if ( t > him ) { ++o.high_mild; } ++o.samples_seen; } return o; }
double mean( double const* first, double const* last ) { auto count = last - first; double sum = 0.; while (first != last) { sum += *first; ++first; } return sum / static_cast<double>(count); }
double normal_cdf( double x ) { return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0; }
double erfc_inv(double x) { return erf_inv(1.0 - x); }
double normal_quantile(double p) { static const double ROOT_TWO = std::sqrt(2.0);
double result = 0.0; assert(p >= 0 && p <= 1); if (p < 0 || p > 1) { return result; }
result = -erfc_inv(2.0 * p); // result *= normal distribution standard deviation (1.0) * sqrt(2) result *= /*sd * */ ROOT_TWO; // result += normal disttribution mean (0) return result; }
Estimate<double> bootstrap( double confidence_level, double* first, double* last, sample const& resample, double ( *estimator )( double const*, double const* ) ) { auto n_samples = last - first;
double point = estimator( first, last ); // Degenerate case with a single sample if ( n_samples == 1 ) return { point, point, point, confidence_level };
sample jack = jackknife( estimator, first, last ); double jack_mean = mean( jack.data(), jack.data() + jack.size() ); double sum_squares = 0, sum_cubes = 0; for ( double x : jack ) { auto difference = jack_mean - x; auto square = difference * difference; auto cube = square * difference; sum_squares += square; sum_cubes += cube; }
double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) ); long n = static_cast<long>( resample.size() ); double prob_n = std::count_if( resample.begin(), resample.end(), [point]( double x ) { return x < point; } ) / static_cast<double>( n ); // degenerate case with uniform samples if ( Catch::Detail::directCompare( prob_n, 0. ) ) { return { point, point, point, confidence_level }; }
double bias = normal_quantile( prob_n ); double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
auto cumn = [n]( double x ) -> long { return std::lround( normal_cdf( x ) * static_cast<double>( n ) ); }; auto a = [bias, accel]( double b ) { return bias + b / ( 1. - accel * b ); }; double b1 = bias + z1; double b2 = bias - z1; double a1 = a( b1 ); double a2 = a( b2 ); auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) ); auto hi = static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
return { point, resample[lo], resample[hi], confidence_level }; }
bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, double* first, double* last) { auto mean = &Detail::mean; auto stddev = &standard_deviation;
#if defined(CATCH_CONFIG_USE_ASYNC) auto Estimate = [=](double(*f)(double const*, double const*)) { std::random_device rd; auto seed = rd(); return std::async(std::launch::async, [=] { SimplePcg32 rng( seed ); auto resampled = resample(rng, n_resamples, first, last, f); return bootstrap(confidence_level, first, last, resampled, f); }); };
auto mean_future = Estimate(mean); auto stddev_future = Estimate(stddev);
auto mean_estimate = mean_future.get(); auto stddev_estimate = stddev_future.get();#else auto Estimate = [=](double(*f)(double const* , double const*)) { std::random_device rd; auto seed = rd(); SimplePcg32 rng( seed ); auto resampled = resample(rng, n_resamples, first, last, f); return bootstrap(confidence_level, first, last, resampled, f); };
auto mean_estimate = Estimate(mean); auto stddev_estimate = Estimate(stddev);#endif // CATCH_USE_ASYNC
auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++ double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
return { mean_estimate, stddev_estimate, outlier_variance }; } } // namespace Detail } // namespace Benchmark} // namespace Catch
#include <cmath>#include <limits>
namespace {
// Performs equivalent check of std::fabs(lhs - rhs) <= margin// But without the subtraction to allow for INFINITY in comparisonbool marginComparison(double lhs, double rhs, double margin) { return (lhs + margin >= rhs) && (rhs + margin >= lhs);}
}
namespace Catch {
Approx::Approx ( double value ) : m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ), m_margin( 0.0 ), m_scale( 0.0 ), m_value( value ) {}
Approx Approx::custom() { return Approx( 0 ); }
Approx Approx::operator-() const { auto temp(*this); temp.m_value = -temp.m_value; return temp; }
std::string Approx::toString() const { ReusableStringStream rss; rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )"; return rss.str(); }
bool Approx::equalityComparisonImpl(const double other) const { // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value // Thanks to Richard Harris for his help refining the scaled margin value return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value))); }
void Approx::setMargin(double newMargin) { CATCH_ENFORCE(newMargin >= 0, "Invalid Approx::margin: " << newMargin << '.' << " Approx::Margin has to be non-negative."); m_margin = newMargin; }
void Approx::setEpsilon(double newEpsilon) { CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0, "Invalid Approx::epsilon: " << newEpsilon << '.' << " Approx::epsilon has to be in [0, 1]"); m_epsilon = newEpsilon; }
namespace literals { Approx operator ""_a(long double val) { return Approx(val); } Approx operator ""_a(unsigned long long val) { return Approx(val); }} // end namespace literals
std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) { return value.toString();}
} // end namespace Catch
namespace Catch {
AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression): lazyExpression(_lazyExpression), resultType(_resultType) {}
std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) { if( lazyExpression ) { ReusableStringStream rss; rss << lazyExpression; reconstructedExpression = rss.str(); } } return reconstructedExpression; }
AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data ) : m_info( info ), m_resultData( CATCH_MOVE(data) ) {}
// Result was a success bool AssertionResult::succeeded() const { return Catch::isOk( m_resultData.resultType ); }
// Result was a success, or failure is suppressed bool AssertionResult::isOk() const { return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); }
ResultWas::OfType AssertionResult::getResultType() const { return m_resultData.resultType; }
bool AssertionResult::hasExpression() const { return !m_info.capturedExpression.empty(); }
bool AssertionResult::hasMessage() const { return !m_resultData.message.empty(); }
std::string AssertionResult::getExpression() const { // Possibly overallocating by 3 characters should be basically free std::string expr; expr.reserve(m_info.capturedExpression.size() + 3); if (isFalseTest(m_info.resultDisposition)) { expr += "!("; } expr += m_info.capturedExpression; if (isFalseTest(m_info.resultDisposition)) { expr += ')'; } return expr; }
std::string AssertionResult::getExpressionInMacro() const { if ( m_info.macroName.empty() ) { return static_cast<std::string>( m_info.capturedExpression ); } std::string expr; expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 ); expr += m_info.macroName; expr += "( "; expr += m_info.capturedExpression; expr += " )"; return expr; }
bool AssertionResult::hasExpandedExpression() const { return hasExpression() && getExpandedExpression() != getExpression(); }
std::string AssertionResult::getExpandedExpression() const { std::string expr = m_resultData.reconstructExpression(); return expr.empty() ? getExpression() : expr; }
StringRef AssertionResult::getMessage() const { return m_resultData.message; } SourceLineInfo AssertionResult::getSourceInfo() const { return m_info.lineInfo; }
StringRef AssertionResult::getTestMacroName() const { return m_info.macroName; }
} // end namespace Catch
#include <fstream>
namespace Catch {
namespace { static bool enableBazelEnvSupport() {#if defined( CATCH_CONFIG_BAZEL_SUPPORT ) return true;#else return Detail::getEnv( "BAZEL_TEST" ) != nullptr;#endif }
struct bazelShardingOptions { unsigned int shardIndex, shardCount; std::string shardFilePath; };
static Optional<bazelShardingOptions> readBazelShardingOptions() { const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" ); const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" ); const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
const bool has_all = bazelShardIndex && bazelShardTotal && bazelShardInfoFile; if ( !has_all ) { // We provide nice warning message if the input is // misconfigured. auto warn = []( const char* env_var ) { Catch::cerr() << "Warning: Bazel shard configuration is missing '" << env_var << "'. Shard configuration is skipped.\n"; }; if ( !bazelShardIndex ) { warn( "TEST_SHARD_INDEX" ); } if ( !bazelShardTotal ) { warn( "TEST_TOTAL_SHARDS" ); } if ( !bazelShardInfoFile ) { warn( "TEST_SHARD_STATUS_FILE" ); } return {}; }
auto shardIndex = parseUInt( bazelShardIndex ); if ( !shardIndex ) { Catch::cerr() << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex << "') as unsigned int.\n"; return {}; } auto shardTotal = parseUInt( bazelShardTotal ); if ( !shardTotal ) { Catch::cerr() << "Warning: could not parse 'TEST_TOTAL_SHARD' ('" << bazelShardTotal << "') as unsigned int.\n"; return {}; }
return bazelShardingOptions{ *shardIndex, *shardTotal, bazelShardInfoFile };
} } // end namespace
bool operator==( ProcessedReporterSpec const& lhs, ProcessedReporterSpec const& rhs ) { return lhs.name == rhs.name && lhs.outputFilename == rhs.outputFilename && lhs.colourMode == rhs.colourMode && lhs.customOptions == rhs.customOptions; }
Config::Config( ConfigData const& data ): m_data( data ) { // We need to trim filter specs to avoid trouble with superfluous // whitespace (esp. important for bdd macros, as those are manually // aligned with whitespace).
for (auto& elem : m_data.testsOrTags) { elem = trim(elem); } for (auto& elem : m_data.sectionsToRun) { elem = trim(elem); }
// Insert the default reporter if user hasn't asked for a specific one if ( m_data.reporterSpecifications.empty() ) {#if defined( CATCH_CONFIG_DEFAULT_REPORTER ) const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;#else const auto default_spec = "console";#endif auto parsed = parseReporterSpec(default_spec); CATCH_ENFORCE( parsed, "Cannot parse the provided default reporter spec: '" << default_spec << '\'' ); m_data.reporterSpecifications.push_back( std::move( *parsed ) ); }
if ( enableBazelEnvSupport() ) { readBazelEnvVars(); }
// Bazel support can modify the test specs, so parsing has to happen // after reading Bazel env vars. TestSpecParser parser( ITagAliasRegistry::get() ); if ( !m_data.testsOrTags.empty() ) { m_hasTestFilters = true; for ( auto const& testOrTags : m_data.testsOrTags ) { parser.parse( testOrTags ); } } m_testSpec = parser.testSpec();
// We now fixup the reporter specs to handle default output spec, // default colour spec, etc bool defaultOutputUsed = false; for ( auto const& reporterSpec : m_data.reporterSpecifications ) { // We do the default-output check separately, while always // using the default output below to make the code simpler // and avoid superfluous copies. if ( reporterSpec.outputFile().none() ) { CATCH_ENFORCE( !defaultOutputUsed, "Internal error: cannot use default output for " "multiple reporters" ); defaultOutputUsed = true; }
m_processedReporterSpecs.push_back( ProcessedReporterSpec{ reporterSpec.name(), reporterSpec.outputFile() ? *reporterSpec.outputFile() : data.defaultOutputFilename, reporterSpec.colourMode().valueOr( data.defaultColourMode ), reporterSpec.customOptions() } ); } }
Config::~Config() = default;
bool Config::listTests() const { return m_data.listTests; } bool Config::listTags() const { return m_data.listTags; } bool Config::listReporters() const { return m_data.listReporters; } bool Config::listListeners() const { return m_data.listListeners; }
std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; } std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
std::vector<ReporterSpec> const& Config::getReporterSpecs() const { return m_data.reporterSpecifications; }
std::vector<ProcessedReporterSpec> const& Config::getProcessedReporterSpecs() const { return m_processedReporterSpecs; }
TestSpec const& Config::testSpec() const { return m_testSpec; } bool Config::hasTestFilters() const { return m_hasTestFilters; }
bool Config::showHelp() const { return m_data.showHelp; }
// IConfig interface bool Config::allowThrows() const { return !m_data.noThrow; } StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; } bool Config::warnAboutMissingAssertions() const { return !!( m_data.warnings & WarnAbout::NoAssertions ); } bool Config::warnAboutUnmatchedTestSpecs() const { return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec ); } bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; } ShowDurations Config::showDurations() const { return m_data.showDurations; } double Config::minDuration() const { return m_data.minDuration; } TestRunOrder Config::runOrder() const { return m_data.runOrder; } uint32_t Config::rngSeed() const { return m_data.rngSeed; } unsigned int Config::shardCount() const { return m_data.shardCount; } unsigned int Config::shardIndex() const { return m_data.shardIndex; } ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; } bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; } int Config::abortAfter() const { return m_data.abortAfter; } bool Config::showInvisibles() const { return m_data.showInvisibles; } Verbosity Config::verbosity() const { return m_data.verbosity; }
bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; } bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; } unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; } double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; } unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; } std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
void Config::readBazelEnvVars() { // Register a JUnit reporter for Bazel. Bazel sets an environment // variable with the path to XML output. If this file is written to // during test, Bazel will not generate a default XML output. // This allows the XML output file to contain higher level of detail // than what is possible otherwise. const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
if ( bazelOutputFile ) { m_data.reporterSpecifications.push_back( { "junit", std::string( bazelOutputFile ), {}, {} } ); }
const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" ); if ( bazelTestSpec ) { // Presumably the test spec from environment should overwrite // the one we got from CLI (if we got any) m_data.testsOrTags.clear(); m_data.testsOrTags.push_back( bazelTestSpec ); }
const auto bazelShardOptions = readBazelShardingOptions(); if ( bazelShardOptions ) { std::ofstream f( bazelShardOptions->shardFilePath, std::ios_base::out | std::ios_base::trunc ); if ( f.is_open() ) { f << ""; m_data.shardIndex = bazelShardOptions->shardIndex; m_data.shardCount = bazelShardOptions->shardCount; } } }
} // end namespace Catch
namespace Catch { std::uint32_t getSeed() { return getCurrentContext().getConfig()->rngSeed(); }}
#include <cassert>#include <stack>
namespace Catch {
////////////////////////////////////////////////////////////////////////////
ScopedMessage::ScopedMessage( MessageBuilder&& builder ): m_info( CATCH_MOVE(builder.m_info) ) { m_info.message = builder.m_stream.str(); getResultCapture().pushScopedMessage( m_info ); }
ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept: m_info( CATCH_MOVE( old.m_info ) ) { old.m_moved = true; }
ScopedMessage::~ScopedMessage() { if ( !uncaught_exceptions() && !m_moved ){ getResultCapture().popScopedMessage(m_info); } }
Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ): m_resultCapture( getResultCapture() ) { auto trimmed = [&] (size_t start, size_t end) { while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) { ++start; } while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) { --end; } return names.substr(start, end - start + 1); }; auto skipq = [&] (size_t start, char quote) { for (auto i = start + 1; i < names.size() ; ++i) { if (names[i] == quote) return i; if (names[i] == '\\') ++i; } CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote"); };
size_t start = 0; std::stack<char> openings; for (size_t pos = 0; pos < names.size(); ++pos) { char c = names[pos]; switch (c) { case '[': case '{': case '(': // It is basically impossible to disambiguate between // comparison and start of template args in this context// case '<': openings.push(c); break; case ']': case '}': case ')':// case '>': openings.pop(); break; case '"': case '\'': pos = skipq(pos, c); break; case ',': if (start != pos && openings.empty()) { m_messages.emplace_back(macroName, lineInfo, resultType); m_messages.back().message = static_cast<std::string>(trimmed(start, pos)); m_messages.back().message += " := "; start = pos; } default:; // noop } } assert(openings.empty() && "Mismatched openings"); m_messages.emplace_back(macroName, lineInfo, resultType); m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1)); m_messages.back().message += " := "; } Capturer::~Capturer() { if ( !uncaught_exceptions() ){ assert( m_captured == m_messages.size() ); for( size_t i = 0; i < m_captured; ++i ) m_resultCapture.popScopedMessage( m_messages[i] ); } }
void Capturer::captureValue( size_t index, std::string const& value ) { assert( index < m_messages.size() ); m_messages[index].message += value; m_resultCapture.pushScopedMessage( m_messages[index] ); m_captured++; }
} // end namespace Catch
#include <exception>
namespace Catch {
namespace {
class RegistryHub : public IRegistryHub, public IMutableRegistryHub, private Detail::NonCopyable {
public: // IRegistryHub RegistryHub() = default; ReporterRegistry const& getReporterRegistry() const override { return m_reporterRegistry; } ITestCaseRegistry const& getTestCaseRegistry() const override { return m_testCaseRegistry; } IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override { return m_exceptionTranslatorRegistry; } ITagAliasRegistry const& getTagAliasRegistry() const override { return m_tagAliasRegistry; } StartupExceptionRegistry const& getStartupExceptionRegistry() const override { return m_exceptionRegistry; }
public: // IMutableRegistryHub void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override { m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) ); } void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override { m_reporterRegistry.registerListener( CATCH_MOVE(factory) ); } void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override { m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) ); } void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override { m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) ); } void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override { m_tagAliasRegistry.add( alias, tag, lineInfo ); } void registerStartupException() noexcept override {#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) m_exceptionRegistry.add(std::current_exception());#else CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");#endif } IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override { return m_enumValuesRegistry; }
private: TestRegistry m_testCaseRegistry; ReporterRegistry m_reporterRegistry; ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; TagAliasRegistry m_tagAliasRegistry; StartupExceptionRegistry m_exceptionRegistry; Detail::EnumValuesRegistry m_enumValuesRegistry; }; }
using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
IRegistryHub const& getRegistryHub() { return RegistryHubSingleton::get(); } IMutableRegistryHub& getMutableRegistryHub() { return RegistryHubSingleton::getMutable(); } void cleanUp() { cleanupSingletons(); cleanUpContext(); } std::string translateActiveException() { return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); }
} // end namespace Catch
#include <algorithm>#include <cassert>#include <exception>#include <iomanip>#include <set>
namespace Catch {
namespace { const int MaxExitCode = 255;
IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) { auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config)); CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
return reporter; }
IEventListenerPtr prepareReporters(Config const* config) { if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty() && config->getProcessedReporterSpecs().size() == 1) { auto const& spec = config->getProcessedReporterSpecs()[0]; return createReporter( spec.name, ReporterConfig( config, makeStream( spec.outputFilename ), spec.colourMode, spec.customOptions ) ); }
auto multi = Detail::make_unique<MultiReporter>(config);
auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners(); for (auto const& listener : listeners) { multi->addListener(listener->create(config)); }
for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) { multi->addReporter( createReporter( reporterSpec.name, ReporterConfig( config, makeStream( reporterSpec.outputFilename ), reporterSpec.colourMode, reporterSpec.customOptions ) ) ); }
return multi; }
class TestGroup { public: explicit TestGroup(IEventListenerPtr&& reporter, Config const* config): m_reporter(reporter.get()), m_config{config}, m_context{config, CATCH_MOVE(reporter)} {
assert( m_config->testSpec().getInvalidSpecs().empty() && "Invalid test specs should be handled before running tests" );
auto const& allTestCases = getAllTestCasesSorted(*m_config); auto const& testSpec = m_config->testSpec(); if ( !testSpec.hasFilters() ) { for ( auto const& test : allTestCases ) { if ( !test.getTestCaseInfo().isHidden() ) { m_tests.emplace( &test ); } } } else { m_matches = testSpec.matchesByFilter( allTestCases, *m_config ); for ( auto const& match : m_matches ) { m_tests.insert( match.tests.begin(), match.tests.end() ); } }
m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex()); }
Totals execute() { Totals totals; for (auto const& testCase : m_tests) { if (!m_context.aborting()) totals += m_context.runTest(*testCase); else m_reporter->skipTest(testCase->getTestCaseInfo()); }
for (auto const& match : m_matches) { if (match.tests.empty()) { m_unmatchedTestSpecs = true; m_reporter->noMatchingTestCases( match.name ); } }
return totals; }
bool hadUnmatchedTestSpecs() const { return m_unmatchedTestSpecs; }
private: IEventListener* m_reporter; Config const* m_config; RunContext m_context; std::set<TestCaseHandle const*> m_tests; TestSpec::Matches m_matches; bool m_unmatchedTestSpecs = false; };
void applyFilenamesAsTags() { for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) { testInfo->addFilenameTag(); } }
} // anon namespace
Session::Session() { static bool alreadyInstantiated = false; if( alreadyInstantiated ) { CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); } CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); } }
// There cannot be exceptions at startup in no-exception mode.#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions(); if ( !exceptions.empty() ) { config(); getCurrentMutableContext().setConfig(m_config.get());
m_startupExceptions = true; auto errStream = makeStream( "%stderr" ); auto colourImpl = makeColourImpl( ColourMode::PlatformDefault, errStream.get() ); auto guard = colourImpl->guardColour( Colour::Red ); errStream->stream() << "Errors occurred during startup!" << '\n'; // iterate over all exceptions and notify user for ( const auto& ex_ptr : exceptions ) { try { std::rethrow_exception(ex_ptr); } catch ( std::exception const& ex ) { errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n'; } } }#endif
alreadyInstantiated = true; m_cli = makeCommandLineParser( m_configData ); } Session::~Session() { Catch::cleanUp(); }
void Session::showHelp() const { Catch::cout() << "\nCatch2 v" << libraryVersion() << '\n' << m_cli << '\n' << "For more detailed usage please see the project docs\n\n" << std::flush; } void Session::libIdentify() { Catch::cout() << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n" << std::left << std::setw(16) << "category: " << "testframework\n" << std::left << std::setw(16) << "framework: " << "Catch2\n" << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush; }
int Session::applyCommandLine( int argc, char const * const * argv ) { if( m_startupExceptions ) return 1;
auto result = m_cli.parse( Clara::Args( argc, argv ) );
if( !result ) { config(); getCurrentMutableContext().setConfig(m_config.get()); auto errStream = makeStream( "%stderr" ); auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
errStream->stream() << colour->guardColour( Colour::Red ) << "\nError(s) in input:\n" << TextFlow::Column( result.errorMessage() ).indent( 2 ) << "\n\n"; errStream->stream() << "Run with -? for usage\n\n" << std::flush; return MaxExitCode; }
if( m_configData.showHelp ) showHelp(); if( m_configData.libIdentify ) libIdentify();
m_config.reset(); return 0; }
#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE) int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
char **utf8Argv = new char *[ argc ];
for ( int i = 0; i < argc; ++i ) { int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
utf8Argv[ i ] = new char[ bufSize ];
WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr ); }
int returnCode = applyCommandLine( argc, utf8Argv );
for ( int i = 0; i < argc; ++i ) delete [] utf8Argv[ i ];
delete [] utf8Argv;
return returnCode; }#endif
void Session::useConfigData( ConfigData const& configData ) { m_configData = configData; m_config.reset(); }
int Session::run() { if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) { Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush; static_cast<void>(std::getchar()); } int exitCode = runInternal(); if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) { Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush; static_cast<void>(std::getchar()); } return exitCode; }
Clara::Parser const& Session::cli() const { return m_cli; } void Session::cli( Clara::Parser const& newParser ) { m_cli = newParser; } ConfigData& Session::configData() { return m_configData; } Config& Session::config() { if( !m_config ) m_config = Detail::make_unique<Config>( m_configData ); return *m_config; }
int Session::runInternal() { if( m_startupExceptions ) return 1;
if (m_configData.showHelp || m_configData.libIdentify) { return 0; }
if ( m_configData.shardIndex >= m_configData.shardCount ) { Catch::cerr() << "The shard count (" << m_configData.shardCount << ") must be greater than the shard index (" << m_configData.shardIndex << ")\n" << std::flush; return 1; }
CATCH_TRY { config(); // Force config to be constructed
seedRng( *m_config );
if (m_configData.filenamesAsTags) { applyFilenamesAsTags(); }
// Set up global config instance before we start calling into other functions getCurrentMutableContext().setConfig(m_config.get());
// Create reporter(s) so we can route listings through them auto reporter = prepareReporters(m_config.get());
auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs(); if ( !invalidSpecs.empty() ) { for ( auto const& spec : invalidSpecs ) { reporter->reportInvalidTestSpec( spec ); } return 1; }
// Handle list request if (list(*reporter, *m_config)) { return 0; }
TestGroup tests { CATCH_MOVE(reporter), m_config.get() }; auto const totals = tests.execute();
if ( tests.hadUnmatchedTestSpecs() && m_config->warnAboutUnmatchedTestSpecs() ) { return 3; }
if ( totals.testCases.total() == 0 && !m_config->zeroTestsCountAsSuccess() ) { return 2; }
if ( totals.testCases.total() > 0 && totals.testCases.total() == totals.testCases.skipped && !m_config->zeroTestsCountAsSuccess() ) { return 4; }
// Note that on unices only the lower 8 bits are usually used, clamping // the return value to 255 prevents false negative when some multiple // of 256 tests has failed return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed)); }#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) catch( std::exception& ex ) { Catch::cerr() << ex.what() << '\n' << std::flush; return MaxExitCode; }#endif }
} // end namespace Catch
namespace Catch {
RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) { CATCH_TRY { getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo); } CATCH_CATCH_ALL { // Do not throw when constructing global objects, instead register the exception to be processed later getMutableRegistryHub().registerStartupException(); } }
}
#include <cassert>#include <cctype>#include <algorithm>
namespace Catch {
namespace { using TCP_underlying_type = uint8_t; static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type), "The size of the TestCaseProperties is different from the assumed size");
TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) { return static_cast<TestCaseProperties>( static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs) ); }
TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) { lhs = static_cast<TestCaseProperties>( static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs) ); return lhs; }
TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) { return static_cast<TestCaseProperties>( static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs) ); }
bool applies(TestCaseProperties tcp) { static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0, "TestCaseProperties::None must be equal to 0"); return tcp != TestCaseProperties::None; }
TestCaseProperties parseSpecialTag( StringRef tag ) { if( !tag.empty() && tag[0] == '.' ) return TestCaseProperties::IsHidden; else if( tag == "!throws"_sr ) return TestCaseProperties::Throws; else if( tag == "!shouldfail"_sr ) return TestCaseProperties::ShouldFail; else if( tag == "!mayfail"_sr ) return TestCaseProperties::MayFail; else if( tag == "!nonportable"_sr ) return TestCaseProperties::NonPortable; else if( tag == "!benchmark"_sr ) return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden; else return TestCaseProperties::None; } bool isReservedTag( StringRef tag ) { return parseSpecialTag( tag ) == TestCaseProperties::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) ); } void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) { CATCH_ENFORCE( !isReservedTag(tag), "Tag name: [" << tag << "] is not allowed.\n" << "Tag names starting with non alphanumeric characters are reserved\n" << _lineInfo ); }
std::string makeDefaultName() { static size_t counter = 0; return "Anonymous test case " + std::to_string(++counter); }
StringRef extractFilenamePart(StringRef filename) { size_t lastDot = filename.size(); while (lastDot > 0 && filename[lastDot - 1] != '.') { --lastDot; } // In theory we could have filename without any extension in it if ( lastDot == 0 ) { return StringRef(); }
--lastDot; size_t nameStart = lastDot; while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') { --nameStart; }
return filename.substr(nameStart, lastDot - nameStart); }
// Returns the upper bound on size of extra tags ([#file]+[.]) size_t sizeOfExtraTags(StringRef filepath) { // [.] is 3, [#] is another 3 const size_t extras = 3 + 3; return extractFilenamePart(filepath).size() + extras; } } // end unnamed namespace
bool operator<( Tag const& lhs, Tag const& rhs ) { Detail::CaseInsensitiveLess cmp; return cmp( lhs.original, rhs.original ); } bool operator==( Tag const& lhs, Tag const& rhs ) { Detail::CaseInsensitiveEqualTo cmp; return cmp( lhs.original, rhs.original ); }
Detail::unique_ptr<TestCaseInfo> makeTestCaseInfo(StringRef _className, NameAndTags const& nameAndTags, SourceLineInfo const& _lineInfo ) { return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo); }
TestCaseInfo::TestCaseInfo(StringRef _className, NameAndTags const& _nameAndTags, SourceLineInfo const& _lineInfo): name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ), className( _className ), lineInfo( _lineInfo ) { StringRef originalTags = _nameAndTags.tags; // We need to reserve enough space to store all of the tags // (including optional hidden tag and filename tag) auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file); backingTags.reserve(requiredSize);
// We cannot copy the tags directly, as we need to normalize // some tags, so that [.foo] is copied as [.][foo]. size_t tagStart = 0; size_t tagEnd = 0; bool inTag = false; for (size_t idx = 0; idx < originalTags.size(); ++idx) { auto c = originalTags[idx]; if (c == '[') { CATCH_ENFORCE( !inTag, "Found '[' inside a tag while registering test case '" << _nameAndTags.name << "' at " << _lineInfo );
inTag = true; tagStart = idx; } if (c == ']') { CATCH_ENFORCE( inTag, "Found unmatched ']' while registering test case '" << _nameAndTags.name << "' at " << _lineInfo );
inTag = false; tagEnd = idx; assert(tagStart < tagEnd);
// We need to check the tag for special meanings, copy // it over to backing storage and actually reference the // backing storage in the saved tags StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1); CATCH_ENFORCE( !tagStr.empty(), "Found an empty tag while registering test case '" << _nameAndTags.name << "' at " << _lineInfo );
enforceNotReservedTag(tagStr, lineInfo); properties |= parseSpecialTag(tagStr); // When copying a tag to the backing storage, we need to // check if it is a merged hide tag, such as [.foo], and // if it is, we need to handle it as if it was [foo]. if (tagStr.size() > 1 && tagStr[0] == '.') { tagStr = tagStr.substr(1, tagStr.size() - 1); } // We skip over dealing with the [.] tag, as we will add // it later unconditionally and then sort and unique all // the tags. internalAppendTag(tagStr); } } CATCH_ENFORCE( !inTag, "Found an unclosed tag while registering test case '" << _nameAndTags.name << "' at " << _lineInfo );
// Add [.] if relevant if (isHidden()) { internalAppendTag("."_sr); }
// Sort and prepare tags std::sort(begin(tags), end(tags)); tags.erase(std::unique(begin(tags), end(tags)), end(tags)); }
bool TestCaseInfo::isHidden() const { return applies( properties & TestCaseProperties::IsHidden ); } bool TestCaseInfo::throws() const { return applies( properties & TestCaseProperties::Throws ); } bool TestCaseInfo::okToFail() const { return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) ); } bool TestCaseInfo::expectedToFail() const { return applies( properties & (TestCaseProperties::ShouldFail) ); }
void TestCaseInfo::addFilenameTag() { std::string combined("#"); combined += extractFilenamePart(lineInfo.file); internalAppendTag(combined); }
std::string TestCaseInfo::tagsAsString() const { std::string ret; // '[' and ']' per tag std::size_t full_size = 2 * tags.size(); for (const auto& tag : tags) { full_size += tag.original.size(); } ret.reserve(full_size); for (const auto& tag : tags) { ret.push_back('['); ret += tag.original; ret.push_back(']'); }
return ret; }
void TestCaseInfo::internalAppendTag(StringRef tagStr) { backingTags += '['; const auto backingStart = backingTags.size(); backingTags += tagStr; const auto backingEnd = backingTags.size(); backingTags += ']'; tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart)); }
bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) { // We want to avoid redoing the string comparisons multiple times, // so we store the result of a three-way comparison before using // it in the actual comparison logic. const auto cmpName = lhs.name.compare( rhs.name ); if ( cmpName != 0 ) { return cmpName < 0; } const auto cmpClassName = lhs.className.compare( rhs.className ); if ( cmpClassName != 0 ) { return cmpClassName < 0; } return lhs.tags < rhs.tags; }
TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const { return *m_info; }
} // end namespace Catch
#include <algorithm>#include <string>#include <vector>#include <ostream>
namespace Catch {
TestSpec::Pattern::Pattern( std::string const& name ) : m_name( name ) {}
TestSpec::Pattern::~Pattern() = default;
std::string const& TestSpec::Pattern::name() const { return m_name; }
TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString ) : Pattern( filterString ) , m_wildcardPattern( toLower( name ), CaseSensitive::No ) {}
bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const { return m_wildcardPattern.matches( testCase.name ); }
void TestSpec::NamePattern::serializeTo( std::ostream& out ) const { out << '"' << name() << '"'; }
TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString ) : Pattern( filterString ) , m_tag( tag ) {}
bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const { return std::find( begin( testCase.tags ), end( testCase.tags ), Tag( m_tag ) ) != end( testCase.tags ); }
void TestSpec::TagPattern::serializeTo( std::ostream& out ) const { out << name(); }
bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const { bool should_use = !testCase.isHidden(); for (auto const& pattern : m_required) { should_use = true; if (!pattern->matches(testCase)) { return false; } } for (auto const& pattern : m_forbidden) { if (pattern->matches(testCase)) { return false; } } return should_use; }
void TestSpec::Filter::serializeTo( std::ostream& out ) const { bool first = true; for ( auto const& pattern : m_required ) { if ( !first ) { out << ' '; } out << *pattern; first = false; } for ( auto const& pattern : m_forbidden ) { if ( !first ) { out << ' '; } out << *pattern; first = false; } }
std::string TestSpec::extractFilterName( Filter const& filter ) { Catch::ReusableStringStream sstr; sstr << filter; return sstr.str(); }
bool TestSpec::hasFilters() const { return !m_filters.empty(); }
bool TestSpec::matches( TestCaseInfo const& testCase ) const { return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } ); }
TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const { Matches matches; matches.reserve( m_filters.size() ); for ( auto const& filter : m_filters ) { std::vector<TestCaseHandle const*> currentMatches; for ( auto const& test : testCases ) if ( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) ) currentMatches.emplace_back( &test ); matches.push_back( FilterMatch{ extractFilterName( filter ), currentMatches } ); } return matches; }
const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const { return m_invalidSpecs; }
void TestSpec::serializeTo( std::ostream& out ) const { bool first = true; for ( auto const& filter : m_filters ) { if ( !first ) { out << ','; } out << filter; first = false; } }
}
#include <chrono>
namespace Catch {
namespace { static auto getCurrentNanosecondsSinceEpoch() -> uint64_t { return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); } } // end unnamed namespace
void Timer::start() { m_nanoseconds = getCurrentNanosecondsSinceEpoch(); } auto Timer::getElapsedNanoseconds() const -> uint64_t { return getCurrentNanosecondsSinceEpoch() - m_nanoseconds; } auto Timer::getElapsedMicroseconds() const -> uint64_t { return getElapsedNanoseconds()/1000; } auto Timer::getElapsedMilliseconds() const -> unsigned int { return static_cast<unsigned int>(getElapsedMicroseconds()/1000); } auto Timer::getElapsedSeconds() const -> double { return getElapsedMicroseconds()/1000000.0; }
} // namespace Catch
#include <cmath>#include <iomanip>
namespace Catch {
namespace Detail {
namespace { const int hexThreshold = 255;
struct Endianness { enum Arch { Big, Little };
static Arch which() { int one = 1; // If the lowest byte we read is non-zero, we can assume // that little endian format is used. auto value = *reinterpret_cast<char*>(&one); return value ? Little : Big; } };
template<typename T> std::string fpToString(T value, int precision) { if (Catch::isnan(value)) { return "nan"; }
ReusableStringStream rss; rss << std::setprecision(precision) << std::fixed << value; std::string d = rss.str(); std::size_t i = d.find_last_not_of('0'); if (i != std::string::npos && i != d.size() - 1) { if (d[i] == '.') i++; d = d.substr(0, i + 1); } return d; } } // end unnamed namespace
std::string convertIntoString(StringRef string, bool escapeInvisibles) { std::string ret; // This is enough for the "don't escape invisibles" case, and a good // lower bound on the "escape invisibles" case. ret.reserve(string.size() + 2);
if (!escapeInvisibles) { ret += '"'; ret += string; ret += '"'; return ret; }
ret += '"'; for (char c : string) { switch (c) { case '\r': ret.append("\\r"); break; case '\n': ret.append("\\n"); break; case '\t': ret.append("\\t"); break; case '\f': ret.append("\\f"); break; default: ret.push_back(c); break; } } ret += '"';
return ret; }
std::string convertIntoString(StringRef string) { return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles()); }
std::string rawMemoryToString( const void *object, std::size_t size ) { // Reverse order for little endian architectures int i = 0, end = static_cast<int>( size ), inc = 1; if( Endianness::which() == Endianness::Little ) { i = end-1; end = inc = -1; }
unsigned char const *bytes = static_cast<unsigned char const *>(object); ReusableStringStream rss; rss << "0x" << std::setfill('0') << std::hex; for( ; i != end; i += inc ) rss << std::setw(2) << static_cast<unsigned>(bytes[i]); return rss.str(); }} // end Detail namespace
//// ======================================================= //////// Out-of-line defs for full specialization of StringMaker////// ======================================================= ////
std::string StringMaker<std::string>::convert(const std::string& str) { return Detail::convertIntoString( str );}
#ifdef CATCH_CONFIG_CPP17_STRING_VIEWstd::string StringMaker<std::string_view>::convert(std::string_view str) { return Detail::convertIntoString( StringRef( str.data(), str.size() ) );}#endif
std::string StringMaker<char const*>::convert(char const* str) { if (str) { return Detail::convertIntoString( str ); } else { return{ "{null string}" }; }}std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter) if (str) { return Detail::convertIntoString( str ); } else { return{ "{null string}" }; }}
#ifdef CATCH_CONFIG_WCHARstd::string StringMaker<std::wstring>::convert(const std::wstring& wstr) { std::string s; s.reserve(wstr.size()); for (auto c : wstr) { s += (c <= 0xff) ? static_cast<char>(c) : '?'; } return ::Catch::Detail::stringify(s);}
# ifdef CATCH_CONFIG_CPP17_STRING_VIEWstd::string StringMaker<std::wstring_view>::convert(std::wstring_view str) { return StringMaker<std::wstring>::convert(std::wstring(str));}# endif
std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) { if (str) { return ::Catch::Detail::stringify(std::wstring{ str }); } else { return{ "{null string}" }; }}std::string StringMaker<wchar_t *>::convert(wchar_t * str) { if (str) { return ::Catch::Detail::stringify(std::wstring{ str }); } else { return{ "{null string}" }; }}#endif
#if defined(CATCH_CONFIG_CPP17_BYTE)#include <cstddef>std::string StringMaker<std::byte>::convert(std::byte value) { return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));}#endif // defined(CATCH_CONFIG_CPP17_BYTE)
std::string StringMaker<int>::convert(int value) { return ::Catch::Detail::stringify(static_cast<long long>(value));}std::string StringMaker<long>::convert(long value) { return ::Catch::Detail::stringify(static_cast<long long>(value));}std::string StringMaker<long long>::convert(long long value) { ReusableStringStream rss; rss << value; if (value > Detail::hexThreshold) { rss << " (0x" << std::hex << value << ')'; } return rss.str();}
std::string StringMaker<unsigned int>::convert(unsigned int value) { return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));}std::string StringMaker<unsigned long>::convert(unsigned long value) { return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));}std::string StringMaker<unsigned long long>::convert(unsigned long long value) { ReusableStringStream rss; rss << value; if (value > Detail::hexThreshold) { rss << " (0x" << std::hex << value << ')'; } return rss.str();}
std::string StringMaker<signed char>::convert(signed char value) { if (value == '\r') { return "'\\r'"; } else if (value == '\f') { return "'\\f'"; } else if (value == '\n') { return "'\\n'"; } else if (value == '\t') { return "'\\t'"; } else if ('\0' <= value && value < ' ') { return ::Catch::Detail::stringify(static_cast<unsigned int>(value)); } else { char chstr[] = "' '"; chstr[1] = value; return chstr; }}std::string StringMaker<char>::convert(char c) { return ::Catch::Detail::stringify(static_cast<signed char>(c));}std::string StringMaker<unsigned char>::convert(unsigned char value) { return ::Catch::Detail::stringify(static_cast<char>(value));}
int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
std::string StringMaker<float>::convert(float value) { return Detail::fpToString(value, precision) + 'f';}
int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
std::string StringMaker<double>::convert(double value) { return Detail::fpToString(value, precision);}
} // end namespace Catch
namespace Catch {
Counts Counts::operator - ( Counts const& other ) const { Counts diff; diff.passed = passed - other.passed; diff.failed = failed - other.failed; diff.failedButOk = failedButOk - other.failedButOk; diff.skipped = skipped - other.skipped; return diff; }
Counts& Counts::operator += ( Counts const& other ) { passed += other.passed; failed += other.failed; failedButOk += other.failedButOk; skipped += other.skipped; return *this; }
std::uint64_t Counts::total() const { return passed + failed + failedButOk + skipped; } bool Counts::allPassed() const { return failed == 0 && failedButOk == 0 && skipped == 0; } bool Counts::allOk() const { return failed == 0; }
Totals Totals::operator - ( Totals const& other ) const { Totals diff; diff.assertions = assertions - other.assertions; diff.testCases = testCases - other.testCases; return diff; }
Totals& Totals::operator += ( Totals const& other ) { assertions += other.assertions; testCases += other.testCases; return *this; }
Totals Totals::delta( Totals const& prevTotals ) const { Totals diff = *this - prevTotals; if( diff.assertions.failed > 0 ) ++diff.testCases.failed; else if( diff.assertions.failedButOk > 0 ) ++diff.testCases.failedButOk; else if ( diff.assertions.skipped > 0 ) ++ diff.testCases.skipped; else ++diff.testCases.passed; return diff; }
}
namespace Catch { namespace Detail { void registerTranslatorImpl( Detail::unique_ptr<IExceptionTranslator>&& translator ) { getMutableRegistryHub().registerTranslator( CATCH_MOVE( translator ) ); } } // namespace Detail} // namespace Catch
#include <ostream>
namespace Catch {
Version::Version ( unsigned int _majorVersion, unsigned int _minorVersion, unsigned int _patchNumber, char const * const _branchName, unsigned int _buildNumber ) : majorVersion( _majorVersion ), minorVersion( _minorVersion ), patchNumber( _patchNumber ), branchName( _branchName ), buildNumber( _buildNumber ) {}
std::ostream& operator << ( std::ostream& os, Version const& version ) { os << version.majorVersion << '.' << version.minorVersion << '.' << version.patchNumber; // branchName is never null -> 0th char is \0 if it is empty if (version.branchName[0]) { os << '-' << version.branchName << '.' << version.buildNumber; } return os; }
Version const& libraryVersion() { static Version version( 3, 6, 0, "", 0 ); return version; }
}
namespace Catch {
const char* GeneratorException::what() const noexcept { return m_msg; }
} // end namespace Catch
namespace Catch {
IGeneratorTracker::~IGeneratorTracker() = default;
namespace Generators {
namespace Detail {
[[noreturn]] void throw_generator_exception(char const* msg) { Catch::throw_exception(GeneratorException{ msg }); }} // end namespace Detail
GeneratorUntypedBase::~GeneratorUntypedBase() = default;
IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) { return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo ); }
IGeneratorTracker* createGeneratorTracker( StringRef generatorName, SourceLineInfo lineInfo, GeneratorBasePtr&& generator ) { return getResultCapture().createGeneratorTracker( generatorName, lineInfo, CATCH_MOVE( generator ) ); }
} // namespace Generators} // namespace Catch
#include <random>
namespace Catch { namespace Generators { namespace Detail { std::uint32_t getSeed() { return sharedRng()(); } } // namespace Detail
struct RandomFloatingGenerator<long double>::PImpl { PImpl( long double a, long double b, uint32_t seed ): rng( seed ), dist( a, b ) {}
Catch::SimplePcg32 rng; std::uniform_real_distribution<long double> dist; };
RandomFloatingGenerator<long double>::RandomFloatingGenerator( long double a, long double b, std::uint32_t seed) : m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) { static_cast<void>( next() ); }
RandomFloatingGenerator<long double>::~RandomFloatingGenerator() = default; bool RandomFloatingGenerator<long double>::next() { m_current_number = m_pimpl->dist( m_pimpl->rng ); return true; } } // namespace Generators} // namespace Catch
namespace Catch { IResultCapture::~IResultCapture() = default;}
namespace Catch { IConfig::~IConfig() = default;}
namespace Catch { IExceptionTranslator::~IExceptionTranslator() = default; IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;}
#include <string>
namespace Catch { namespace Generators {
bool GeneratorUntypedBase::countedNext() { auto ret = next(); if ( ret ) { m_stringReprCache.clear(); ++m_currentElementIndex; } return ret; }
StringRef GeneratorUntypedBase::currentElementAsString() const { if ( m_stringReprCache.empty() ) { m_stringReprCache = stringifyImpl(); } return m_stringReprCache; }
} // namespace Generators} // namespace Catch
namespace Catch { IRegistryHub::~IRegistryHub() = default; IMutableRegistryHub::~IMutableRegistryHub() = default;}
#include <cassert>
namespace Catch {
ReporterConfig::ReporterConfig( IConfig const* _fullConfig, Detail::unique_ptr<IStream> _stream, ColourMode colourMode, std::map<std::string, std::string> customOptions ): m_stream( CATCH_MOVE(_stream) ), m_fullConfig( _fullConfig ), m_colourMode( colourMode ), m_customOptions( CATCH_MOVE( customOptions ) ) {}
Detail::unique_ptr<IStream> ReporterConfig::takeStream() && { assert( m_stream ); return CATCH_MOVE( m_stream ); } IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; } ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
std::map<std::string, std::string> const& ReporterConfig::customOptions() const { return m_customOptions; }
ReporterConfig::~ReporterConfig() = default;
AssertionStats::AssertionStats( AssertionResult const& _assertionResult, std::vector<MessageInfo> const& _infoMessages, Totals const& _totals ) : assertionResult( _assertionResult ), infoMessages( _infoMessages ), totals( _totals ) { if( assertionResult.hasMessage() ) { // Copy message into messages list. // !TBD This should have been done earlier, somewhere MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
infoMessages.push_back( CATCH_MOVE(builder.m_info) ); } }
SectionStats::SectionStats( SectionInfo&& _sectionInfo, Counts const& _assertions, double _durationInSeconds, bool _missingAssertions ) : sectionInfo( CATCH_MOVE(_sectionInfo) ), assertions( _assertions ), durationInSeconds( _durationInSeconds ), missingAssertions( _missingAssertions ) {}
TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo, Totals const& _totals, std::string&& _stdOut, std::string&& _stdErr, bool _aborting ) : testInfo( &_testInfo ), totals( _totals ), stdOut( CATCH_MOVE(_stdOut) ), stdErr( CATCH_MOVE(_stdErr) ), aborting( _aborting ) {}
TestRunStats::TestRunStats( TestRunInfo const& _runInfo, Totals const& _totals, bool _aborting ) : runInfo( _runInfo ), totals( _totals ), aborting( _aborting ) {}
IEventListener::~IEventListener() = default;
} // end namespace Catch
namespace Catch { IReporterFactory::~IReporterFactory() = default; EventListenerFactory::~EventListenerFactory() = default;}
namespace Catch { ITestCaseRegistry::~ITestCaseRegistry() = default;}
namespace Catch {
AssertionHandler::AssertionHandler ( StringRef macroName, SourceLineInfo const& lineInfo, StringRef capturedExpression, ResultDisposition::Flags resultDisposition ) : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition }, m_resultCapture( getResultCapture() ) { m_resultCapture.notifyAssertionStarted( m_assertionInfo ); }
void AssertionHandler::handleExpr( ITransientExpression const& expr ) { m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction ); } void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) { m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction ); }
auto AssertionHandler::allowThrows() const -> bool { return getCurrentContext().getConfig()->allowThrows(); }
void AssertionHandler::complete() { m_completed = true; if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the // call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test and change execution, jump over the throw, next) CATCH_BREAK_INTO_DEBUGGER(); } if (m_reaction.shouldThrow) { throw_test_failure_exception(); } if ( m_reaction.shouldSkip ) { throw_test_skip_exception(); } }
void AssertionHandler::handleUnexpectedInflightException() { m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction ); }
void AssertionHandler::handleExceptionThrownAsExpected() { m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); } void AssertionHandler::handleExceptionNotThrownAsExpected() { m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); }
void AssertionHandler::handleUnexpectedExceptionNotThrown() { m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction ); }
void AssertionHandler::handleThrowingCallSkipped() { m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction); }
// This is the overload that takes a string and infers the Equals matcher from it // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) { handleExceptionMatchExpr( handler, Matchers::Equals( str ) ); }
} // namespace Catch
#include <algorithm>
namespace Catch { namespace Detail {
bool CaseInsensitiveLess::operator()( StringRef lhs, StringRef rhs ) const { return std::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), []( char l, char r ) { return toLower( l ) < toLower( r ); } ); }
bool CaseInsensitiveEqualTo::operator()( StringRef lhs, StringRef rhs ) const { return std::equal( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), []( char l, char r ) { return toLower( l ) == toLower( r ); } ); }
} // namespace Detail} // namespace Catch
#include <algorithm>#include <ostream>
namespace { bool isOptPrefix( char c ) { return c == '-'#ifdef CATCH_PLATFORM_WINDOWS || c == '/'#endif ; }
Catch::StringRef normaliseOpt( Catch::StringRef optName ) { if ( optName[0] == '-'#if defined(CATCH_PLATFORM_WINDOWS) || optName[0] == '/'#endif ) { return optName.substr( 1, optName.size() ); }
return optName; }
static size_t find_first_separator(Catch::StringRef sr) { auto is_separator = []( char c ) { return c == ' ' || c == ':' || c == '='; }; size_t pos = 0; while (pos < sr.size()) { if (is_separator(sr[pos])) { return pos; } ++pos; }
return Catch::StringRef::npos; }
} // namespace
namespace Catch { namespace Clara { namespace Detail {
void TokenStream::loadBuffer() { m_tokenBuffer.clear();
// Skip any empty strings while ( it != itEnd && it->empty() ) { ++it; }
if ( it != itEnd ) { StringRef next = *it; if ( isOptPrefix( next[0] ) ) { auto delimiterPos = find_first_separator(next); if ( delimiterPos != StringRef::npos ) { m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } ); m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1, next.size() ) } ); } else { if ( next[1] != '-' && next.size() > 2 ) { // Combined short args, e.g. "-ab" for "-a -b" for ( size_t i = 1; i < next.size(); ++i ) { m_tokenBuffer.push_back( { TokenType::Option, next.substr( i, 1 ) } ); } } else { m_tokenBuffer.push_back( { TokenType::Option, next } ); } } } else { m_tokenBuffer.push_back( { TokenType::Argument, next } ); } } }
TokenStream::TokenStream( Args const& args ): TokenStream( args.m_args.begin(), args.m_args.end() ) {}
TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ): it( it_ ), itEnd( itEnd_ ) { loadBuffer(); }
TokenStream& TokenStream::operator++() { if ( m_tokenBuffer.size() >= 2 ) { m_tokenBuffer.erase( m_tokenBuffer.begin() ); } else { if ( it != itEnd ) ++it; loadBuffer(); } return *this; }
ParserResult convertInto( std::string const& source, std::string& target ) { target = source; return ParserResult::ok( ParseResultType::Matched ); }
ParserResult convertInto( std::string const& source, bool& target ) { std::string srcLC = toLower( source );
if ( srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on" ) { target = true; } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off" ) { target = false; } else { return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + '\'' ); } return ParserResult::ok( ParseResultType::Matched ); }
size_t ParserBase::cardinality() const { return 1; }
InternalParseResult ParserBase::parse( Args const& args ) const { return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) ); }
ParseState::ParseState( ParseResultType type, TokenStream remainingTokens ): m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
ParserResult BoundFlagRef::setFlag( bool flag ) { m_ref = flag; return ParserResult::ok( ParseResultType::Matched ); }
ResultBase::~ResultBase() = default;
bool BoundRef::isContainer() const { return false; }
bool BoundRef::isFlag() const { return false; }
bool BoundFlagRefBase::isFlag() const { return true; }
} // namespace Detail
Detail::InternalParseResult Arg::parse(std::string const&, Detail::TokenStream tokens) const { auto validationResult = validate(); if (!validationResult) return Detail::InternalParseResult(validationResult);
auto token = *tokens; if (token.type != Detail::TokenType::Argument) return Detail::InternalParseResult::ok(Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens)));
assert(!m_ref->isFlag()); auto valueRef = static_cast<Detail::BoundValueRefBase*>(m_ref.get());
auto result = valueRef->setValue(static_cast<std::string>(token.token)); if ( !result ) return Detail::InternalParseResult( result ); else return Detail::InternalParseResult::ok( Detail::ParseState( ParseResultType::Matched, CATCH_MOVE( ++tokens ) ) ); }
Opt::Opt(bool& ref) : ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
Detail::HelpColumns Opt::getHelpColumns() const { ReusableStringStream oss; bool first = true; for (auto const& opt : m_optNames) { if (first) first = false; else oss << ", "; oss << opt; } if (!m_hint.empty()) oss << " <" << m_hint << '>'; return { oss.str(), m_description }; }
bool Opt::isMatch(StringRef optToken) const { auto normalisedToken = normaliseOpt(optToken); for (auto const& name : m_optNames) { if (normaliseOpt(name) == normalisedToken) return true; } return false; }
Detail::InternalParseResult Opt::parse(std::string const&, Detail::TokenStream tokens) const { auto validationResult = validate(); if (!validationResult) return Detail::InternalParseResult(validationResult);
if (tokens && tokens->type == Detail::TokenType::Option) { auto const& token = *tokens; if (isMatch(token.token)) { if (m_ref->isFlag()) { auto flagRef = static_cast<Detail::BoundFlagRefBase*>( m_ref.get()); auto result = flagRef->setFlag(true); if (!result) return Detail::InternalParseResult(result); if (result.value() == ParseResultType::ShortCircuitAll) return Detail::InternalParseResult::ok(Detail::ParseState( result.value(), CATCH_MOVE(tokens))); } else { auto valueRef = static_cast<Detail::BoundValueRefBase*>( m_ref.get()); ++tokens; if (!tokens) return Detail::InternalParseResult::runtimeError( "Expected argument following " + token.token); auto const& argToken = *tokens; if (argToken.type != Detail::TokenType::Argument) return Detail::InternalParseResult::runtimeError( "Expected argument following " + token.token); const auto result = valueRef->setValue(static_cast<std::string>(argToken.token)); if (!result) return Detail::InternalParseResult(result); if (result.value() == ParseResultType::ShortCircuitAll) return Detail::InternalParseResult::ok(Detail::ParseState( result.value(), CATCH_MOVE(tokens))); } return Detail::InternalParseResult::ok(Detail::ParseState( ParseResultType::Matched, CATCH_MOVE(++tokens))); } } return Detail::InternalParseResult::ok( Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens))); }
Detail::Result Opt::validate() const { if (m_optNames.empty()) return Detail::Result::logicError("No options supplied to Opt"); for (auto const& name : m_optNames) { if (name.empty()) return Detail::Result::logicError( "Option name cannot be empty");#ifdef CATCH_PLATFORM_WINDOWS if (name[0] != '-' && name[0] != '/') return Detail::Result::logicError( "Option name must begin with '-' or '/'");#else if (name[0] != '-') return Detail::Result::logicError( "Option name must begin with '-'");#endif } return ParserRefImpl::validate(); }
ExeName::ExeName() : m_name(std::make_shared<std::string>("<executable>")) {}
ExeName::ExeName(std::string& ref) : ExeName() { m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref); }
Detail::InternalParseResult ExeName::parse(std::string const&, Detail::TokenStream tokens) const { return Detail::InternalParseResult::ok( Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens))); }
ParserResult ExeName::set(std::string const& newName) { auto lastSlash = newName.find_last_of("\\/"); auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
*m_name = filename; if (m_ref) return m_ref->setValue(filename); else return ParserResult::ok(ParseResultType::Matched); }
Parser& Parser::operator|=( Parser const& other ) { m_options.insert( m_options.end(), other.m_options.begin(), other.m_options.end() ); m_args.insert( m_args.end(), other.m_args.begin(), other.m_args.end() ); return *this; }
std::vector<Detail::HelpColumns> Parser::getHelpColumns() const { std::vector<Detail::HelpColumns> cols; cols.reserve( m_options.size() ); for ( auto const& o : m_options ) { cols.push_back(o.getHelpColumns()); } return cols; }
void Parser::writeToStream( std::ostream& os ) const { if ( !m_exeName.name().empty() ) { os << "usage:\n" << " " << m_exeName.name() << ' '; bool required = true, first = true; for ( auto const& arg : m_args ) { if ( first ) first = false; else os << ' '; if ( arg.isOptional() && required ) { os << '['; required = false; } os << '<' << arg.hint() << '>'; if ( arg.cardinality() == 0 ) os << " ... "; } if ( !required ) os << ']'; if ( !m_options.empty() ) os << " options"; os << "\n\nwhere options are:\n"; }
auto rows = getHelpColumns(); size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH; size_t optWidth = 0; for ( auto const& cols : rows ) optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
optWidth = ( std::min )( optWidth, consoleWidth / 2 );
for ( auto& cols : rows ) { auto row = TextFlow::Column( CATCH_MOVE(cols.left) ) .width( optWidth ) .indent( 2 ) + TextFlow::Spacer( 4 ) + TextFlow::Column( static_cast<std::string>(cols.descriptions) ) .width( consoleWidth - 7 - optWidth ); os << row << '\n'; } }
Detail::Result Parser::validate() const { for ( auto const& opt : m_options ) { auto result = opt.validate(); if ( !result ) return result; } for ( auto const& arg : m_args ) { auto result = arg.validate(); if ( !result ) return result; } return Detail::Result::ok(); }
Detail::InternalParseResult Parser::parse( std::string const& exeName, Detail::TokenStream tokens ) const {
struct ParserInfo { ParserBase const* parser = nullptr; size_t count = 0; }; std::vector<ParserInfo> parseInfos; parseInfos.reserve( m_options.size() + m_args.size() ); for ( auto const& opt : m_options ) { parseInfos.push_back( { &opt, 0 } ); } for ( auto const& arg : m_args ) { parseInfos.push_back( { &arg, 0 } ); }
m_exeName.set( exeName );
auto result = Detail::InternalParseResult::ok( Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) ); while ( result.value().remainingTokens() ) { bool tokenParsed = false;
for ( auto& parseInfo : parseInfos ) { if ( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) { result = parseInfo.parser->parse( exeName, CATCH_MOVE(result).value().remainingTokens() ); if ( !result ) return result; if ( result.value().type() != ParseResultType::NoMatch ) { tokenParsed = true; ++parseInfo.count; break; } } }
if ( result.value().type() == ParseResultType::ShortCircuitAll ) return result; if ( !tokenParsed ) return Detail::InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token ); } // !TBD Check missing required options return result; }
Args::Args(int argc, char const* const* argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
Args::Args(std::initializer_list<StringRef> args) : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}
Help::Help( bool& showHelpFlag ): Opt( [&]( bool flag ) { showHelpFlag = flag; return ParserResult::ok( ParseResultType::ShortCircuitAll ); } ) { static_cast<Opt&> ( *this )( "display usage information" )["-?"]["-h"]["--help"] .optional(); }
} // namespace Clara} // namespace Catch
#include <fstream>#include <string>
namespace Catch {
Clara::Parser makeCommandLineParser( ConfigData& config ) {
using namespace Clara;
auto const setWarning = [&]( std::string const& warning ) { if ( warning == "NoAssertions" ) { config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions); return ParserResult::ok( ParseResultType::Matched ); } else if ( warning == "UnmatchedTestSpec" ) { config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec); return ParserResult::ok( ParseResultType::Matched ); }
return ParserResult ::runtimeError( "Unrecognised warning option: '" + warning + '\'' ); }; auto const loadTestNamesFromFile = [&]( std::string const& filename ) { std::ifstream f( filename.c_str() ); if( !f.is_open() ) return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
std::string line; while( std::getline( f, line ) ) { line = trim(line); if( !line.empty() && !startsWith( line, '#' ) ) { if( !startsWith( line, '"' ) ) line = '"' + CATCH_MOVE(line) + '"'; config.testsOrTags.push_back( line ); config.testsOrTags.emplace_back( "," ); } } //Remove comma in the end if(!config.testsOrTags.empty()) config.testsOrTags.erase( config.testsOrTags.end()-1 );
return ParserResult::ok( ParseResultType::Matched ); }; auto const setTestOrder = [&]( std::string const& order ) { if( startsWith( "declared", order ) ) config.runOrder = TestRunOrder::Declared; else if( startsWith( "lexical", order ) ) config.runOrder = TestRunOrder::LexicographicallySorted; else if( startsWith( "random", order ) ) config.runOrder = TestRunOrder::Randomized; else return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' ); return ParserResult::ok( ParseResultType::Matched ); }; auto const setRngSeed = [&]( std::string const& seed ) { if( seed == "time" ) { config.rngSeed = generateRandomSeed(GenerateFrom::Time); return ParserResult::ok(ParseResultType::Matched); } else if (seed == "random-device") { config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice); return ParserResult::ok(ParseResultType::Matched); }
// TODO: ideally we should be parsing uint32_t directly // fix this later when we add new parse overload auto parsedSeed = parseUInt( seed, 0 ); if ( !parsedSeed ) { return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" ); } config.rngSeed = *parsedSeed; return ParserResult::ok( ParseResultType::Matched ); }; auto const setDefaultColourMode = [&]( std::string const& colourMode ) { Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode )); if ( !maybeMode ) { return ParserResult::runtimeError( "colour mode must be one of: default, ansi, win32, " "or none. '" + colourMode + "' is not recognised" ); } auto mode = *maybeMode; if ( !isColourImplAvailable( mode ) ) { return ParserResult::runtimeError( "colour mode '" + colourMode + "' is not supported in this binary" ); } config.defaultColourMode = mode; return ParserResult::ok( ParseResultType::Matched ); }; auto const setWaitForKeypress = [&]( std::string const& keypress ) { auto keypressLc = toLower( keypress ); if (keypressLc == "never") config.waitForKeypress = WaitForKeypress::Never; else if( keypressLc == "start" ) config.waitForKeypress = WaitForKeypress::BeforeStart; else if( keypressLc == "exit" ) config.waitForKeypress = WaitForKeypress::BeforeExit; else if( keypressLc == "both" ) config.waitForKeypress = WaitForKeypress::BeforeStartAndExit; else return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" ); return ParserResult::ok( ParseResultType::Matched ); }; auto const setVerbosity = [&]( std::string const& verbosity ) { auto lcVerbosity = toLower( verbosity ); if( lcVerbosity == "quiet" ) config.verbosity = Verbosity::Quiet; else if( lcVerbosity == "normal" ) config.verbosity = Verbosity::Normal; else if( lcVerbosity == "high" ) config.verbosity = Verbosity::High; else return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' ); return ParserResult::ok( ParseResultType::Matched ); }; auto const setReporter = [&]( std::string const& userReporterSpec ) { if ( userReporterSpec.empty() ) { return ParserResult::runtimeError( "Received empty reporter spec." ); }
Optional<ReporterSpec> parsed = parseReporterSpec( userReporterSpec ); if ( !parsed ) { return ParserResult::runtimeError( "Could not parse reporter spec '" + userReporterSpec + "'" ); }
auto const& reporterSpec = *parsed;
auto const& factories = getRegistryHub().getReporterRegistry().getFactories(); auto result = factories.find( reporterSpec.name() );
if ( result == factories.end() ) { return ParserResult::runtimeError( "Unrecognized reporter, '" + reporterSpec.name() + "'. Check available with --list-reporters" ); }
const bool hadOutputFile = reporterSpec.outputFile().some(); config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) ); // It would be enough to check this only once at the very end, but // there is not a place where we could call this check, so do it // every time it could fail. For valid inputs, this is still called // at most once. if (!hadOutputFile) { int n_reporters_without_file = 0; for (auto const& spec : config.reporterSpecifications) { if (spec.outputFile().none()) { n_reporters_without_file++; } } if (n_reporters_without_file > 1) { return ParserResult::runtimeError( "Only one reporter may have unspecified output file." ); } }
return ParserResult::ok( ParseResultType::Matched ); }; auto const setShardCount = [&]( std::string const& shardCount ) { auto parsedCount = parseUInt( shardCount ); if ( !parsedCount ) { return ParserResult::runtimeError( "Could not parse '" + shardCount + "' as shard count" ); } if ( *parsedCount == 0 ) { return ParserResult::runtimeError( "Shard count must be positive" ); } config.shardCount = *parsedCount; return ParserResult::ok( ParseResultType::Matched ); };
auto const setShardIndex = [&](std::string const& shardIndex) { auto parsedIndex = parseUInt( shardIndex ); if ( !parsedIndex ) { return ParserResult::runtimeError( "Could not parse '" + shardIndex + "' as shard index" ); } config.shardIndex = *parsedIndex; return ParserResult::ok( ParseResultType::Matched ); };
auto cli = ExeName( config.processName ) | Help( config.showHelp ) | Opt( config.showSuccessfulTests ) ["-s"]["--success"] ( "include successful tests in output" ) | Opt( config.shouldDebugBreak ) ["-b"]["--break"] ( "break into debugger on failure" ) | Opt( config.noThrow ) ["-e"]["--nothrow"] ( "skip exception tests" ) | Opt( config.showInvisibles ) ["-i"]["--invisibles"] ( "show invisibles (tabs, newlines)" ) | Opt( config.defaultOutputFilename, "filename" ) ["-o"]["--out"] ( "default output filename" ) | Opt( accept_many, setReporter, "name[::key=value]*" ) ["-r"]["--reporter"] ( "reporter to use (defaults to console)" ) | Opt( config.name, "name" ) ["-n"]["--name"] ( "suite name" ) | Opt( [&]( bool ){ config.abortAfter = 1; } ) ["-a"]["--abort"] ( "abort at first failure" ) | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" ) ["-x"]["--abortx"] ( "abort after x failures" ) | Opt( accept_many, setWarning, "warning name" ) ["-w"]["--warn"] ( "enable warnings" ) | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" ) ["-d"]["--durations"] ( "show test durations" ) | Opt( config.minDuration, "seconds" ) ["-D"]["--min-duration"] ( "show test durations for tests taking at least the given number of seconds" ) | Opt( loadTestNamesFromFile, "filename" ) ["-f"]["--input-file"] ( "load test names to run from a file" ) | Opt( config.filenamesAsTags ) ["-#"]["--filenames-as-tags"] ( "adds a tag for the filename" ) | Opt( config.sectionsToRun, "section name" ) ["-c"]["--section"] ( "specify section to run" ) | Opt( setVerbosity, "quiet|normal|high" ) ["-v"]["--verbosity"] ( "set output verbosity" ) | Opt( config.listTests ) ["--list-tests"] ( "list all/matching test cases" ) | Opt( config.listTags ) ["--list-tags"] ( "list all/matching tags" ) | Opt( config.listReporters ) ["--list-reporters"] ( "list all available reporters" ) | Opt( config.listListeners ) ["--list-listeners"] ( "list all listeners" ) | Opt( setTestOrder, "decl|lex|rand" ) ["--order"] ( "test case order (defaults to decl)" ) | Opt( setRngSeed, "'time'|'random-device'|number" ) ["--rng-seed"] ( "set a specific seed for random numbers" ) | Opt( setDefaultColourMode, "ansi|win32|none|default" ) ["--colour-mode"] ( "what color mode should be used as default" ) | Opt( config.libIdentify ) ["--libidentify"] ( "report name and version according to libidentify standard" ) | Opt( setWaitForKeypress, "never|start|exit|both" ) ["--wait-for-keypress"] ( "waits for a keypress before exiting" ) | Opt( config.skipBenchmarks) ["--skip-benchmarks"] ( "disable running benchmarks") | Opt( config.benchmarkSamples, "samples" ) ["--benchmark-samples"] ( "number of samples to collect (default: 100)" ) | Opt( config.benchmarkResamples, "resamples" ) ["--benchmark-resamples"] ( "number of resamples for the bootstrap (default: 100000)" ) | Opt( config.benchmarkConfidenceInterval, "confidence interval" ) ["--benchmark-confidence-interval"] ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" ) | Opt( config.benchmarkNoAnalysis ) ["--benchmark-no-analysis"] ( "perform only measurements; do not perform any analysis" ) | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" ) ["--benchmark-warmup-time"] ( "amount of time in milliseconds spent on warming up each test (default: 100)" ) | Opt( setShardCount, "shard count" ) ["--shard-count"] ( "split the tests to execute into this many groups" ) | Opt( setShardIndex, "shard index" ) ["--shard-index"] ( "index of the group of tests to execute (see --shard-count)" ) | Opt( config.allowZeroTests ) ["--allow-running-no-tests"] ( "Treat 'No tests run' as a success" ) | Arg( config.testsOrTags, "test name|pattern|tags" ) ( "which test or tests to use" );
return cli; }
} // end namespace Catch
#if defined(__clang__)# pragma clang diagnostic push# pragma clang diagnostic ignored "-Wexit-time-destructors"#endif
#include <cassert>#include <ostream>#include <utility>
namespace Catch {
ColourImpl::~ColourImpl() = default;
ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) { return ColourGuard(colourCode, this ); }
void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) { assert( &stream == &m_colourImpl->m_stream->stream() && "Engaging colour guard for different stream than used by the " "parent colour implementation" ); static_cast<void>( stream );
m_engaged = true; m_colourImpl->use( m_code ); }
ColourImpl::ColourGuard::ColourGuard( Colour::Code code, ColourImpl const* colour ): m_colourImpl( colour ), m_code( code ) { } ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept: m_colourImpl( rhs.m_colourImpl ), m_code( rhs.m_code ), m_engaged( rhs.m_engaged ) { rhs.m_engaged = false; } ColourImpl::ColourGuard& ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept { using std::swap; swap( m_colourImpl, rhs.m_colourImpl ); swap( m_code, rhs.m_code ); swap( m_engaged, rhs.m_engaged );
return *this; } ColourImpl::ColourGuard::~ColourGuard() { if ( m_engaged ) { m_colourImpl->use( Colour::None ); } }
ColourImpl::ColourGuard& ColourImpl::ColourGuard::engage( std::ostream& stream ) & { engageImpl( stream ); return *this; }
ColourImpl::ColourGuard&& ColourImpl::ColourGuard::engage( std::ostream& stream ) && { engageImpl( stream ); return CATCH_MOVE(*this); }
namespace { //! A do-nothing implementation of colour, used as fallback for unknown //! platforms, and when the user asks to deactivate all colours. class NoColourImpl final : public ColourImpl { public: NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
private: void use( Colour::Code ) const override {} }; } // namespace
} // namespace Catch
#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
namespace Catch {namespace {
class Win32ColourImpl final : public ColourImpl { public: Win32ColourImpl(IStream* stream): ColourImpl(stream) { CONSOLE_SCREEN_BUFFER_INFO csbiInfo; GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &csbiInfo ); originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY ); originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY ); }
static bool useImplementationForStream(IStream const& stream) { // Win32 text colour APIs can only be used on console streams // We cannot check that the output hasn't been redirected, // so we just check that the original stream is console stream. return stream.isConsole(); }
private: void use( Colour::Code _colourCode ) const override { switch( _colourCode ) { case Colour::None: return setTextAttribute( originalForegroundAttributes ); case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::Red: return setTextAttribute( FOREGROUND_RED ); case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); case Colour::Grey: return setTextAttribute( 0 );
case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
default: CATCH_ERROR( "Unknown colour requested" ); } }
void setTextAttribute( WORD _textAttribute ) const { SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), _textAttribute | originalBackgroundAttributes ); } WORD originalForegroundAttributes; WORD originalBackgroundAttributes; };
} // end anon namespace} // end namespace Catch
#endif // Windows/ ANSI/ None
#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )# define CATCH_INTERNAL_HAS_ISATTY# include <unistd.h>#endif
namespace Catch {namespace {
class ANSIColourImpl final : public ColourImpl { public: ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
static bool useImplementationForStream(IStream const& stream) { // This is kinda messy due to trying to support a bunch of // different platforms at once. // The basic idea is that if we are asked to do autodetection (as // opposed to being told to use posixy colours outright), then we // only want to use the colours if we are writing to console. // However, console might be redirected, so we make an attempt at // checking for that on platforms where we know how to do that. bool useColour = stream.isConsole();#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \ !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) ) ErrnoGuard _; // for isatty useColour = useColour && isatty( STDOUT_FILENO );# endif# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE ) useColour = useColour && !isDebuggerActive();# endif
return useColour; }
private: void use( Colour::Code _colourCode ) const override { auto setColour = [&out = m_stream->stream()]( char const* escapeCode ) { // The escape sequence must be flushed to console, otherwise // if stdin and stderr are intermixed, we'd get accidentally // coloured output. out << '\033' << escapeCode << std::flush; }; switch( _colourCode ) { case Colour::None: case Colour::White: return setColour( "[0m" ); case Colour::Red: return setColour( "[0;31m" ); case Colour::Green: return setColour( "[0;32m" ); case Colour::Blue: return setColour( "[0;34m" ); case Colour::Cyan: return setColour( "[0;36m" ); case Colour::Yellow: return setColour( "[0;33m" ); case Colour::Grey: return setColour( "[1;30m" );
case Colour::LightGrey: return setColour( "[0;37m" ); case Colour::BrightRed: return setColour( "[1;31m" ); case Colour::BrightGreen: return setColour( "[1;32m" ); case Colour::BrightWhite: return setColour( "[1;37m" ); case Colour::BrightYellow: return setColour( "[1;33m" );
case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" ); default: CATCH_INTERNAL_ERROR( "Unknown colour requested" ); } } };
} // end anon namespace} // end namespace Catch
namespace Catch {
Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection, IStream* stream ) {#if defined( CATCH_CONFIG_COLOUR_WIN32 ) if ( colourSelection == ColourMode::Win32 ) { return Detail::make_unique<Win32ColourImpl>( stream ); }#endif if ( colourSelection == ColourMode::ANSI ) { return Detail::make_unique<ANSIColourImpl>( stream ); } if ( colourSelection == ColourMode::None ) { return Detail::make_unique<NoColourImpl>( stream ); }
if ( colourSelection == ColourMode::PlatformDefault) {#if defined( CATCH_CONFIG_COLOUR_WIN32 ) if ( Win32ColourImpl::useImplementationForStream( *stream ) ) { return Detail::make_unique<Win32ColourImpl>( stream ); }#endif if ( ANSIColourImpl::useImplementationForStream( *stream ) ) { return Detail::make_unique<ANSIColourImpl>( stream ); } return Detail::make_unique<NoColourImpl>( stream ); }
CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) ); }
bool isColourImplAvailable( ColourMode colourSelection ) { switch ( colourSelection ) {#if defined( CATCH_CONFIG_COLOUR_WIN32 ) case ColourMode::Win32:#endif case ColourMode::ANSI: case ColourMode::None: case ColourMode::PlatformDefault: return true; default: return false; } }
} // end namespace Catch
#if defined(__clang__)# pragma clang diagnostic pop#endif
namespace Catch {
Context* Context::currentContext = nullptr;
void cleanUpContext() { delete Context::currentContext; Context::currentContext = nullptr; } void Context::createContext() { currentContext = new Context(); }
Context& getCurrentMutableContext() { if ( !Context::currentContext ) { Context::createContext(); } // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn) return *Context::currentContext; }
void Context::setResultCapture( IResultCapture* resultCapture ) { m_resultCapture = resultCapture; }
void Context::setConfig( IConfig const* config ) { m_config = config; }
SimplePcg32& sharedRng() { static SimplePcg32 s_rng; return s_rng; }
}
#include <ostream>
#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)#include <android/log.h>
namespace Catch { void writeToDebugConsole( std::string const& text ) { __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() ); } }
#elif defined(CATCH_PLATFORM_WINDOWS)
namespace Catch { void writeToDebugConsole( std::string const& text ) { ::OutputDebugStringA( text.c_str() ); } }
#else
namespace Catch { void writeToDebugConsole( std::string const& text ) { // !TBD: Need a version for Mac/ XCode and other IDEs Catch::cout() << text; } }
#endif // Platform
#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
# include <cassert># include <sys/types.h># include <unistd.h># include <cstddef># include <ostream>
#ifdef __apple_build_version__ // These headers will only compile with AppleClang (XCode) // For other compilers (Clang, GCC, ... ) we need to exclude them# include <sys/sysctl.h>#endif
namespace Catch { #ifdef __apple_build_version__ // The following function is taken directly from the following technical note: // https://developer.apple.com/library/archive/qa/qa1361/_index.html
// Returns true if the current process is being debugged (either // running under the debugger or has a debugger attached post facto). bool isDebuggerActive(){ int mib[4]; struct kinfo_proc info; std::size_t size;
// Initialize the flags so that, if sysctl fails for some bizarre // reason, we get a predictable result.
info.kp_proc.p_flag = 0;
// Initialize mib, which tells sysctl the info we want, in this case // we're looking for information about a specific process ID.
mib[0] = CTL_KERN; mib[1] = KERN_PROC; mib[2] = KERN_PROC_PID; mib[3] = getpid();
// Call sysctl.
size = sizeof(info); if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) { Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush; return false; }
// We're being debugged if the P_TRACED flag is set.
return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); } #else bool isDebuggerActive() { // We need to find another way to determine this for non-appleclang compilers on macOS return false; } #endif } // namespace Catch
#elif defined(CATCH_PLATFORM_LINUX) #include <fstream> #include <string>
namespace Catch{ // The standard POSIX way of detecting a debugger is to attempt to // ptrace() the process, but this needs to be done from a child and not // this process itself to still allow attaching to this process later // if wanted, so is rather heavy. Under Linux we have the PID of the // "debugger" (which doesn't need to be gdb, of course, it could also // be strace, for example) in /proc/$PID/status, so just get it from // there instead. bool isDebuggerActive(){ // Libstdc++ has a bug, where std::ifstream sets errno to 0 // This way our users can properly assert over errno values ErrnoGuard guard; std::ifstream in("/proc/self/status"); for( std::string line; std::getline(in, line); ) { static const int PREFIX_LEN = 11; if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) { // We're traced if the PID is not 0 and no other PID starts // with 0 digit, so it's enough to check for just a single // character. return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0'; } }
return false; } } // namespace Catch#elif defined(_MSC_VER) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } }#elif defined(__MINGW32__) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } }#else namespace Catch { bool isDebuggerActive() { return false; } }#endif // Platform
namespace Catch {
void ITransientExpression::streamReconstructedExpression( std::ostream& os ) const { // We can't make this function pure virtual to keep ITransientExpression // constexpr, so we write error message instead os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression"; }
void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) { if( lhs.size() + rhs.size() < 40 && lhs.find('\n') == std::string::npos && rhs.find('\n') == std::string::npos ) os << lhs << ' ' << op << ' ' << rhs; else os << lhs << '\n' << op << '\n' << rhs; }}
#include <stdexcept>
namespace Catch {#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER) [[noreturn]] void throw_exception(std::exception const& e) { Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n" << "The message was: " << e.what() << '\n'; std::terminate(); }#endif
[[noreturn]] void throw_logic_error(std::string const& msg) { throw_exception(std::logic_error(msg)); }
[[noreturn]] void throw_domain_error(std::string const& msg) { throw_exception(std::domain_error(msg)); }
[[noreturn]] void throw_runtime_error(std::string const& msg) { throw_exception(std::runtime_error(msg)); }
} // namespace Catch;
#include <cassert>
namespace Catch {
IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
namespace Detail {
namespace { // Extracts the actual name part of an enum instance // In other words, it returns the Blue part of Bikeshed::Colour::Blue StringRef extractInstanceName(StringRef enumInstance) { // Find last occurrence of ":" size_t name_start = enumInstance.size(); while (name_start > 0 && enumInstance[name_start - 1] != ':') { --name_start; } return enumInstance.substr(name_start, enumInstance.size() - name_start); } }
std::vector<StringRef> parseEnums( StringRef enums ) { auto enumValues = splitStringRef( enums, ',' ); std::vector<StringRef> parsed; parsed.reserve( enumValues.size() ); for( auto const& enumValue : enumValues ) { parsed.push_back(trim(extractInstanceName(enumValue))); } return parsed; }
EnumInfo::~EnumInfo() = default;
StringRef EnumInfo::lookup( int value ) const { for( auto const& valueToName : m_values ) { if( valueToName.first == value ) return valueToName.second; } return "{** unexpected enum value **}"_sr; }
Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) { auto enumInfo = Catch::Detail::make_unique<EnumInfo>(); enumInfo->m_name = enumName; enumInfo->m_values.reserve( values.size() );
const auto valueNames = Catch::Detail::parseEnums( allValueNames ); assert( valueNames.size() == values.size() ); std::size_t i = 0; for( auto value : values ) enumInfo->m_values.emplace_back(value, valueNames[i++]);
return enumInfo; }
EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) { m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values)); return *m_enumInfos.back(); }
} // Detail} // Catch
#include <cerrno>
namespace Catch { ErrnoGuard::ErrnoGuard():m_oldErrno(errno){} ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }}
#include <exception>
namespace Catch {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) namespace { static std::string tryTranslators( std::vector< Detail::unique_ptr<IExceptionTranslator const>> const& translators ) { if ( translators.empty() ) { std::rethrow_exception( std::current_exception() ); } else { return translators[0]->translate( translators.begin() + 1, translators.end() ); } }
}#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) { m_translators.push_back( CATCH_MOVE( translator ) ); }
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) std::string ExceptionTranslatorRegistry::translateActiveException() const { // Compiling a mixed mode project with MSVC means that CLR // exceptions will be caught in (...) as well. However, these do // do not fill-in std::current_exception and thus lead to crash // when attempting rethrow. // /EHa switch also causes structured exceptions to be caught // here, but they fill-in current_exception properly, so // at worst the output should be a little weird, instead of // causing a crash. if ( std::current_exception() == nullptr ) { return "Non C++ exception. Possibly a CLR exception."; }
// First we try user-registered translators. If none of them can // handle the exception, it will be rethrown handled by our defaults. try { return tryTranslators(m_translators); } // To avoid having to handle TFE explicitly everywhere, we just // rethrow it so that it goes back up the caller. catch( TestFailureException& ) { std::rethrow_exception(std::current_exception()); } catch( TestSkipException& ) { std::rethrow_exception(std::current_exception()); } catch( std::exception const& ex ) { return ex.what(); } catch( std::string const& msg ) { return msg; } catch( const char* msg ) { return msg; } catch(...) { return "Unknown exception"; } }
#else // ^^ Exceptions are enabled // Exceptions are disabled vv std::string ExceptionTranslatorRegistry::translateActiveException() const { CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!"); }#endif
}
/** \file * This file provides platform specific implementations of FatalConditionHandler * * This means that there is a lot of conditional compilation, and platform * specific code. Currently, Catch2 supports a dummy handler (if no * handler is desired), and 2 platform specific handlers: * * Windows' SEH * * POSIX signals * * Consequently, various pieces of code below are compiled if either of * the platform specific handlers is enabled, or if none of them are * enabled. It is assumed that both cannot be enabled at the same time, * and doing so should cause a compilation error. * * If another platform specific handler is added, the compile guards * below will need to be updated taking these assumptions into account. */
#include <algorithm>
#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
namespace Catch {
// If neither SEH nor signal handling is required, the handler impls // do not have to do anything, and can be empty. void FatalConditionHandler::engage_platform() {} void FatalConditionHandler::disengage_platform() noexcept {} FatalConditionHandler::FatalConditionHandler() = default; FatalConditionHandler::~FatalConditionHandler() = default;
} // end namespace Catch
#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
namespace { //! Signals fatal error message to the run context void reportFatal( char const * const message ) { Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message ); }
//! Minimal size Catch2 needs for its own fatal error handling. //! Picked empirically, so it might not be sufficient on all //! platforms, and for all configurations. constexpr std::size_t minStackSizeForErrors = 32 * 1024;} // end unnamed namespace
#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH )
namespace Catch {
struct SignalDefs { DWORD id; const char* name; };
// There is no 1-1 mapping between signals and windows exceptions. // Windows can easily distinguish between SO and SigSegV, // but SigInt, SigTerm, etc are handled differently. static SignalDefs signalDefs[] = { { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" }, { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" }, { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" }, { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" }, };
static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) { for (auto const& def : signalDefs) { if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) { reportFatal(def.name); } } // If its not an exception we care about, pass it along. // This stops us from eating debugger breaks etc. return EXCEPTION_CONTINUE_SEARCH; }
// Since we do not support multiple instantiations, we put these // into global variables and rely on cleaning them up in outlined // constructors/destructors static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
// For MSVC, we reserve part of the stack memory for handling // memory overflow structured exception. FatalConditionHandler::FatalConditionHandler() { ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors); if (!SetThreadStackGuarantee(&guaranteeSize)) { // We do not want to fully error out, because needing // the stack reserve should be rare enough anyway. Catch::cerr() << "Failed to reserve piece of stack." << " Stack overflows will not be reported successfully."; } }
// We do not attempt to unset the stack guarantee, because // Windows does not support lowering the stack size guarantee. FatalConditionHandler::~FatalConditionHandler() = default;
void FatalConditionHandler::engage_platform() { // Register as a the top level exception filter. previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter); }
void FatalConditionHandler::disengage_platform() noexcept { if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) { Catch::cerr() << "Unexpected SEH unhandled exception filter on disengage." << " The filter was restored, but might be rolled back unexpectedly."; } previousTopLevelExceptionFilter = nullptr; }
} // end namespace Catch
#endif // CATCH_CONFIG_WINDOWS_SEH
#if defined( CATCH_CONFIG_POSIX_SIGNALS )
#include <signal.h>
namespace Catch {
struct SignalDefs { int id; const char* name; };
static SignalDefs signalDefs[] = { { SIGINT, "SIGINT - Terminal interrupt signal" }, { SIGILL, "SIGILL - Illegal instruction signal" }, { SIGFPE, "SIGFPE - Floating point error signal" }, { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, { SIGTERM, "SIGTERM - Termination request signal" }, { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } };
// Older GCCs trigger -Wmissing-field-initializers for T foo = {}// which is zero initialization, but not explicit. We want to avoid// that.#if defined(__GNUC__)# pragma GCC diagnostic push# pragma GCC diagnostic ignored "-Wmissing-field-initializers"#endif
static char* altStackMem = nullptr; static std::size_t altStackSize = 0; static stack_t oldSigStack{}; static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
static void restorePreviousSignalHandlers() noexcept { // We set signal handlers back to the previous ones. Hopefully // nobody overwrote them in the meantime, and doesn't expect // their signal handlers to live past ours given that they // installed them after ours.. for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { sigaction(signalDefs[i].id, &oldSigActions[i], nullptr); } // Return the old stack sigaltstack(&oldSigStack, nullptr); }
static void handleSignal( int sig ) { char const * name = "<unknown signal>"; for (auto const& def : signalDefs) { if (sig == def.id) { name = def.name; break; } } // We need to restore previous signal handlers and let them do // their thing, so that the users can have the debugger break // when a signal is raised, and so on. restorePreviousSignalHandlers(); reportFatal( name ); raise( sig ); }
FatalConditionHandler::FatalConditionHandler() { assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists"); if (altStackSize == 0) { altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors); } altStackMem = new char[altStackSize](); }
FatalConditionHandler::~FatalConditionHandler() { delete[] altStackMem; // We signal that another instance can be constructed by zeroing // out the pointer. altStackMem = nullptr; }
void FatalConditionHandler::engage_platform() { stack_t sigStack; sigStack.ss_sp = altStackMem; sigStack.ss_size = altStackSize; sigStack.ss_flags = 0; sigaltstack(&sigStack, &oldSigStack); struct sigaction sa = { };
sa.sa_handler = handleSignal; sa.sa_flags = SA_ONSTACK; for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) { sigaction(signalDefs[i].id, &sa, &oldSigActions[i]); } }
#if defined(__GNUC__)# pragma GCC diagnostic pop#endif
void FatalConditionHandler::disengage_platform() noexcept { restorePreviousSignalHandlers(); }
} // end namespace Catch
#endif // CATCH_CONFIG_POSIX_SIGNALS
#include <cstring>
namespace Catch { namespace Detail {
uint32_t convertToBits(float f) { static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated"); uint32_t i; std::memcpy(&i, &f, sizeof(f)); return i; }
uint64_t convertToBits(double d) { static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated"); uint64_t i; std::memcpy(&i, &d, sizeof(d)); return i; }
#if defined( __GNUC__ ) || defined( __clang__ )# pragma GCC diagnostic push# pragma GCC diagnostic ignored "-Wfloat-equal"#endif bool directCompare( float lhs, float rhs ) { return lhs == rhs; } bool directCompare( double lhs, double rhs ) { return lhs == rhs; }#if defined( __GNUC__ ) || defined( __clang__ )# pragma GCC diagnostic pop#endif
} // end namespace Detail} // end namespace Catch
#include <cstdlib>
namespace Catch { namespace Detail {
#if !defined (CATCH_CONFIG_GETENV) char const* getEnv( char const* ) { return nullptr; }#else
char const* getEnv( char const* varName ) {# if defined( _MSC_VER )# pragma warning( push )# pragma warning( disable : 4996 ) // use getenv_s instead of getenv# endif
return std::getenv( varName );
# if defined( _MSC_VER )# pragma warning( pop )# endif }#endif} // namespace Detail} // namespace Catch
#include <cstdio>#include <fstream>#include <sstream>#include <vector>
namespace Catch {
Catch::IStream::~IStream() = default;
namespace Detail { namespace { template<typename WriterF, std::size_t bufferSize=256> class StreamBufImpl final : public std::streambuf { char data[bufferSize]; WriterF m_writer;
public: StreamBufImpl() { setp( data, data + sizeof(data) ); }
~StreamBufImpl() noexcept override { StreamBufImpl::sync(); }
private: int overflow( int c ) override { sync();
if( c != EOF ) { if( pbase() == epptr() ) m_writer( std::string( 1, static_cast<char>( c ) ) ); else sputc( static_cast<char>( c ) ); } return 0; }
int sync() override { if( pbase() != pptr() ) { m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) ); setp( pbase(), epptr() ); } return 0; } };
///////////////////////////////////////////////////////////////////////////
struct OutputDebugWriter {
void operator()( std::string const& str ) { if ( !str.empty() ) { writeToDebugConsole( str ); } } };
///////////////////////////////////////////////////////////////////////////
class FileStream final : public IStream { std::ofstream m_ofs; public: FileStream( std::string const& filename ) { m_ofs.open( filename.c_str() ); CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' ); m_ofs << std::unitbuf; } public: // IStream std::ostream& stream() override { return m_ofs; } };
///////////////////////////////////////////////////////////////////////////
class CoutStream final : public IStream { std::ostream m_os; public: // Store the streambuf from cout up-front because // cout may get redirected when running tests CoutStream() : m_os( Catch::cout().rdbuf() ) {}
public: // IStream std::ostream& stream() override { return m_os; } bool isConsole() const override { return true; } };
class CerrStream : public IStream { std::ostream m_os;
public: // Store the streambuf from cerr up-front because // cout may get redirected when running tests CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
public: // IStream std::ostream& stream() override { return m_os; } bool isConsole() const override { return true; } };
///////////////////////////////////////////////////////////////////////////
class DebugOutStream final : public IStream { Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf; std::ostream m_os; public: DebugOutStream() : m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ), m_os( m_streamBuf.get() ) {}
public: // IStream std::ostream& stream() override { return m_os; } };
} // unnamed namespace} // namespace Detail
///////////////////////////////////////////////////////////////////////////
auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> { if ( filename.empty() || filename == "-" ) { return Detail::make_unique<Detail::CoutStream>(); } if( filename[0] == '%' ) { if ( filename == "%debug" ) { return Detail::make_unique<Detail::DebugOutStream>(); } else if ( filename == "%stderr" ) { return Detail::make_unique<Detail::CerrStream>(); } else if ( filename == "%stdout" ) { return Detail::make_unique<Detail::CoutStream>(); } else { CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' ); } } return Detail::make_unique<Detail::FileStream>( filename ); }
}
namespace Catch { void JsonUtils::indent( std::ostream& os, std::uint64_t level ) { for ( std::uint64_t i = 0; i < level; ++i ) { os << " "; } } void JsonUtils::appendCommaNewline( std::ostream& os, bool& should_comma, std::uint64_t level ) { if ( should_comma ) { os << ','; } should_comma = true; os << '\n'; indent( os, level ); }
JsonObjectWriter::JsonObjectWriter( std::ostream& os ): JsonObjectWriter{ os, 0 } {}
JsonObjectWriter::JsonObjectWriter( std::ostream& os, std::uint64_t indent_level ): m_os{ os }, m_indent_level{ indent_level } { m_os << '{'; } JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept: m_os{ source.m_os }, m_indent_level{ source.m_indent_level }, m_should_comma{ source.m_should_comma }, m_active{ source.m_active } { source.m_active = false; }
JsonObjectWriter::~JsonObjectWriter() { if ( !m_active ) { return; }
m_os << '\n'; JsonUtils::indent( m_os, m_indent_level ); m_os << '}'; }
JsonValueWriter JsonObjectWriter::write( StringRef key ) { JsonUtils::appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 );
m_os << '"' << key << "\": "; return JsonValueWriter{ m_os, m_indent_level + 1 }; }
JsonArrayWriter::JsonArrayWriter( std::ostream& os ): JsonArrayWriter{ os, 0 } {} JsonArrayWriter::JsonArrayWriter( std::ostream& os, std::uint64_t indent_level ): m_os{ os }, m_indent_level{ indent_level } { m_os << '['; } JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept: m_os{ source.m_os }, m_indent_level{ source.m_indent_level }, m_should_comma{ source.m_should_comma }, m_active{ source.m_active } { source.m_active = false; } JsonArrayWriter::~JsonArrayWriter() { if ( !m_active ) { return; }
m_os << '\n'; JsonUtils::indent( m_os, m_indent_level ); m_os << ']'; }
JsonObjectWriter JsonArrayWriter::writeObject() { JsonUtils::appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 ); return JsonObjectWriter{ m_os, m_indent_level + 1 }; }
JsonArrayWriter JsonArrayWriter::writeArray() { JsonUtils::appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 ); return JsonArrayWriter{ m_os, m_indent_level + 1 }; }
JsonArrayWriter& JsonArrayWriter::write( bool value ) { return writeImpl( value ); }
JsonValueWriter::JsonValueWriter( std::ostream& os ): JsonValueWriter{ os, 0 } {}
JsonValueWriter::JsonValueWriter( std::ostream& os, std::uint64_t indent_level ): m_os{ os }, m_indent_level{ indent_level } {}
JsonObjectWriter JsonValueWriter::writeObject() && { return JsonObjectWriter{ m_os, m_indent_level }; }
JsonArrayWriter JsonValueWriter::writeArray() && { return JsonArrayWriter{ m_os, m_indent_level }; }
void JsonValueWriter::write( Catch::StringRef value ) && { writeImpl( value, true ); }
void JsonValueWriter::write( bool value ) && { writeImpl( value ? "true"_sr : "false"_sr, false ); }
void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) { if ( quote ) { m_os << '"'; } for (char c : value) { // Escape list taken from https://www.json.org/json-en.html, // string definition. // Note that while forward slash _can_ be escaped, it does // not have to be, if JSON is not further embedded somewhere // where forward slash is meaningful. if ( c == '"' ) { m_os << "\\\""; } else if ( c == '\\' ) { m_os << "\\\\"; } else if ( c == '\b' ) { m_os << "\\b"; } else if ( c == '\f' ) { m_os << "\\f"; } else if ( c == '\n' ) { m_os << "\\n"; } else if ( c == '\r' ) { m_os << "\\r"; } else if ( c == '\t' ) { m_os << "\\t"; } else { m_os << c; } } if ( quote ) { m_os << '"'; } }
} // namespace Catch
namespace Catch {
auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& { if (lazyExpr.m_isNegated) os << '!';
if (lazyExpr) { if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression()) os << '(' << *lazyExpr.m_transientExpression << ')'; else os << *lazyExpr.m_transientExpression; } else { os << "{** error - unchecked empty expression requested **}"; } return os; }
} // namespace Catch
#ifdef CATCH_CONFIG_WINDOWS_CRTDBG#include <crtdbg.h>
namespace Catch {
LeakDetector::LeakDetector() { int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); flag |= _CRTDBG_LEAK_CHECK_DF; flag |= _CRTDBG_ALLOC_MEM_DF; _CrtSetDbgFlag(flag); _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); // Change this to leaking allocation's number to break there _CrtSetBreakAlloc(-1); }}
#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
Catch::LeakDetector::LeakDetector() = default;
#endif // CATCH_CONFIG_WINDOWS_CRTDBG
Catch::LeakDetector::~LeakDetector() { Catch::cleanUp();}
namespace Catch { namespace {
void listTests(IEventListener& reporter, IConfig const& config) { auto const& testSpec = config.testSpec(); auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config); reporter.listTests(matchedTestCases); }
void listTags(IEventListener& reporter, IConfig const& config) { auto const& testSpec = config.testSpec(); std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts; for (auto const& testCase : matchedTestCases) { for (auto const& tagName : testCase.getTestCaseInfo().tags) { auto it = tagCounts.find(tagName.original); if (it == tagCounts.end()) it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first; it->second.add(tagName.original); } }
std::vector<TagInfo> infos; infos.reserve(tagCounts.size()); for (auto& tagc : tagCounts) { infos.push_back(CATCH_MOVE(tagc.second)); }
reporter.listTags(infos); }
void listReporters(IEventListener& reporter) { std::vector<ReporterDescription> descriptions;
auto const& factories = getRegistryHub().getReporterRegistry().getFactories(); descriptions.reserve(factories.size()); for (auto const& fac : factories) { descriptions.push_back({ fac.first, fac.second->getDescription() }); }
reporter.listReporters(descriptions); }
void listListeners(IEventListener& reporter) { std::vector<ListenerDescription> descriptions;
auto const& factories = getRegistryHub().getReporterRegistry().getListeners(); descriptions.reserve( factories.size() ); for ( auto const& fac : factories ) { descriptions.push_back( { fac->getName(), fac->getDescription() } ); }
reporter.listListeners( descriptions ); }
} // end anonymous namespace
void TagInfo::add( StringRef spelling ) { ++count; spellings.insert( spelling ); }
std::string TagInfo::all() const { // 2 per tag for brackets '[' and ']' size_t size = spellings.size() * 2; for (auto const& spelling : spellings) { size += spelling.size(); }
std::string out; out.reserve(size); for (auto const& spelling : spellings) { out += '['; out += spelling; out += ']'; } return out; }
bool list( IEventListener& reporter, Config const& config ) { bool listed = false; if (config.listTests()) { listed = true; listTests(reporter, config); } if (config.listTags()) { listed = true; listTags(reporter, config); } if (config.listReporters()) { listed = true; listReporters(reporter); } if ( config.listListeners() ) { listed = true; listListeners( reporter ); } return listed; }
} // end namespace Catch
namespace Catch { CATCH_INTERNAL_START_WARNINGS_SUPPRESSION CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS static LeakDetector leakDetector; CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION}
// Allow users of amalgamated .cpp file to remove our main and provide their own.#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)// Standard C/C++ Win32 Unicode wmain entry pointextern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {#else// Standard C/C++ main entry pointint main (int argc, char * argv[]) {#endif
// We want to force the linker not to discard the global variable // and its constructor, as it (optionally) registers leak detector (void)&Catch::leakDetector;
return Catch::Session().run( argc, argv );}
#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
namespace Catch {
MessageInfo::MessageInfo( StringRef _macroName, SourceLineInfo const& _lineInfo, ResultWas::OfType _type ) : macroName( _macroName ), lineInfo( _lineInfo ), type( _type ), sequence( ++globalCount ) {}
// This may need protecting if threading support is added unsigned int MessageInfo::globalCount = 0;
} // end namespace Catch
#include <cstdio>#include <cstring>#include <sstream>
#if defined(CATCH_CONFIG_NEW_CAPTURE) #if defined(_MSC_VER) #include <io.h> //_dup and _dup2 #define dup _dup #define dup2 _dup2 #define fileno _fileno #else #include <unistd.h> // dup and dup2 #endif#endif
namespace Catch {
RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream ) : m_originalStream( originalStream ), m_redirectionStream( redirectionStream ), m_prevBuf( m_originalStream.rdbuf() ) { m_originalStream.rdbuf( m_redirectionStream.rdbuf() ); }
RedirectedStream::~RedirectedStream() { m_originalStream.rdbuf( m_prevBuf ); }
RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {} auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
RedirectedStdErr::RedirectedStdErr() : m_cerr( Catch::cerr(), m_rss.get() ), m_clog( Catch::clog(), m_rss.get() ) {} auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr) : m_redirectedCout(redirectedCout), m_redirectedCerr(redirectedCerr) {}
RedirectedStreams::~RedirectedStreams() { m_redirectedCout += m_redirectedStdOut.str(); m_redirectedCerr += m_redirectedStdErr.str(); }
#if defined(CATCH_CONFIG_NEW_CAPTURE)
#if defined(_MSC_VER) TempFile::TempFile() { if (tmpnam_s(m_buffer)) { CATCH_RUNTIME_ERROR("Could not get a temp filename"); } if (fopen_s(&m_file, m_buffer, "w+")) { char buffer[100]; if (strerror_s(buffer, errno)) { CATCH_RUNTIME_ERROR("Could not translate errno to a string"); } CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer); } }#else TempFile::TempFile() { m_file = std::tmpfile(); if (!m_file) { CATCH_RUNTIME_ERROR("Could not create a temp file."); } }
#endif
TempFile::~TempFile() { // TBD: What to do about errors here? std::fclose(m_file); // We manually create the file on Windows only, on Linux // it will be autodeleted#if defined(_MSC_VER) std::remove(m_buffer);#endif }
FILE* TempFile::getFile() { return m_file; }
std::string TempFile::getContents() { std::stringstream sstr; char buffer[100] = {}; std::rewind(m_file); while (std::fgets(buffer, sizeof(buffer), m_file)) { sstr << buffer; } return sstr.str(); }
OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) : m_originalStdout(dup(1)), m_originalStderr(dup(2)), m_stdoutDest(stdout_dest), m_stderrDest(stderr_dest) { dup2(fileno(m_stdoutFile.getFile()), 1); dup2(fileno(m_stderrFile.getFile()), 2); }
OutputRedirect::~OutputRedirect() { Catch::cout() << std::flush; fflush(stdout); // Since we support overriding these streams, we flush cerr // even though std::cerr is unbuffered Catch::cerr() << std::flush; Catch::clog() << std::flush; fflush(stderr);
dup2(m_originalStdout, 1); dup2(m_originalStderr, 2);
m_stdoutDest += m_stdoutFile.getContents(); m_stderrDest += m_stderrFile.getContents(); }
#endif // CATCH_CONFIG_NEW_CAPTURE
} // namespace Catch
#if defined(CATCH_CONFIG_NEW_CAPTURE) #if defined(_MSC_VER) #undef dup #undef dup2 #undef fileno #endif#endif
#include <limits>#include <stdexcept>
namespace Catch {
Optional<unsigned int> parseUInt(std::string const& input, int base) { auto trimmed = trim( input ); // std::stoull is annoying and accepts numbers starting with '-', // it just negates them into unsigned int if ( trimmed.empty() || trimmed[0] == '-' ) { return {}; }
CATCH_TRY { size_t pos = 0; const auto ret = std::stoull( trimmed, &pos, base );
// We did not consume the whole input, so there is an issue // This can be bunch of different stuff, like multiple numbers // in the input, or invalid digits/characters and so on. Either // way, we do not want to return the partially parsed result. if ( pos != trimmed.size() ) { return {}; } // Too large if ( ret > std::numeric_limits<unsigned int>::max() ) { return {}; } return static_cast<unsigned int>(ret); } CATCH_CATCH_ANON( std::invalid_argument const& ) { // no conversion could be performed } CATCH_CATCH_ANON( std::out_of_range const& ) { // the input does not fit into an unsigned long long } return {}; }
} // namespace Catch
#include <cmath>
namespace Catch {
#if !defined(CATCH_CONFIG_POLYFILL_ISNAN) bool isnan(float f) { return std::isnan(f); } bool isnan(double d) { return std::isnan(d); }#else // For now we only use this for embarcadero bool isnan(float f) { return std::_isnan(f); } bool isnan(double d) { return std::_isnan(d); }#endif
#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER ) float nextafter( float x, float y ) { return std::nextafter( x, y ); } double nextafter( double x, double y ) { return std::nextafter( x, y ); }#else float nextafter( float x, float y ) { return ::nextafterf( x, y ); } double nextafter( double x, double y ) { return ::nextafter( x, y ); }#endif
} // end namespace Catch
namespace Catch {
namespace {
#if defined(_MSC_VER)#pragma warning(push)#pragma warning(disable:4146) // we negate uint32 during the rotate#endif // Safe rotr implementation thanks to John Regehr uint32_t rotate_right(uint32_t val, uint32_t count) { const uint32_t mask = 31; count &= mask; return (val >> count) | (val << (-count & mask)); }
#if defined(_MSC_VER)#pragma warning(pop)#endif
}
SimplePcg32::SimplePcg32(result_type seed_) { seed(seed_); }
void SimplePcg32::seed(result_type seed_) { m_state = 0; (*this)(); m_state += seed_; (*this)(); }
void SimplePcg32::discard(uint64_t skip) { // We could implement this to run in O(log n) steps, but this // should suffice for our use case. for (uint64_t s = 0; s < skip; ++s) { static_cast<void>((*this)()); } }
SimplePcg32::result_type SimplePcg32::operator()() { // prepare the output value const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u); const auto output = rotate_right(xorshifted, m_state >> 59u);
// advance state m_state = m_state * 6364136223846793005ULL + s_inc;
return output; }
bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) { return lhs.m_state == rhs.m_state; }
bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) { return lhs.m_state != rhs.m_state; }}
#include <ctime>#include <random>
namespace Catch {
std::uint32_t generateRandomSeed( GenerateFrom from ) { switch ( from ) { case GenerateFrom::Time: return static_cast<std::uint32_t>( std::time( nullptr ) );
case GenerateFrom::Default: case GenerateFrom::RandomDevice: { std::random_device rd; return Detail::fillBitsFrom<std::uint32_t>( rd ); }
default: CATCH_ERROR("Unknown generation method"); } }
} // end namespace Catch
namespace Catch { struct ReporterRegistry::ReporterRegistryImpl { std::vector<Detail::unique_ptr<EventListenerFactory>> listeners; std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess> factories; };
ReporterRegistry::ReporterRegistry(): m_impl( Detail::make_unique<ReporterRegistryImpl>() ) { // Because it is impossible to move out of initializer list, // we have to add the elements manually m_impl->factories["Automake"] = Detail::make_unique<ReporterFactory<AutomakeReporter>>(); m_impl->factories["compact"] = Detail::make_unique<ReporterFactory<CompactReporter>>(); m_impl->factories["console"] = Detail::make_unique<ReporterFactory<ConsoleReporter>>(); m_impl->factories["JUnit"] = Detail::make_unique<ReporterFactory<JunitReporter>>(); m_impl->factories["SonarQube"] = Detail::make_unique<ReporterFactory<SonarQubeReporter>>(); m_impl->factories["TAP"] = Detail::make_unique<ReporterFactory<TAPReporter>>(); m_impl->factories["TeamCity"] = Detail::make_unique<ReporterFactory<TeamCityReporter>>(); m_impl->factories["XML"] = Detail::make_unique<ReporterFactory<XmlReporter>>(); m_impl->factories["JSON"] = Detail::make_unique<ReporterFactory<JsonReporter>>(); }
ReporterRegistry::~ReporterRegistry() = default;
IEventListenerPtr ReporterRegistry::create( std::string const& name, ReporterConfig&& config ) const { auto it = m_impl->factories.find( name ); if ( it == m_impl->factories.end() ) return nullptr; return it->second->create( CATCH_MOVE( config ) ); }
void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr factory ) { CATCH_ENFORCE( name.find( "::" ) == name.npos, "'::' is not allowed in reporter name: '" + name + '\'' ); auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) ); CATCH_ENFORCE( ret.second, "reporter using '" + name + "' as name was already registered" ); } void ReporterRegistry::registerListener( Detail::unique_ptr<EventListenerFactory> factory ) { m_impl->listeners.push_back( CATCH_MOVE( factory ) ); }
std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess> const& ReporterRegistry::getFactories() const { return m_impl->factories; }
std::vector<Detail::unique_ptr<EventListenerFactory>> const& ReporterRegistry::getListeners() const { return m_impl->listeners; }} // namespace Catch
#include <algorithm>
namespace Catch {
namespace { struct kvPair { StringRef key, value; };
kvPair splitKVPair(StringRef kvString) { auto splitPos = static_cast<size_t>( std::find( kvString.begin(), kvString.end(), '=' ) - kvString.begin() );
return { kvString.substr( 0, splitPos ), kvString.substr( splitPos + 1, kvString.size() ) }; } }
namespace Detail { std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) { static constexpr auto separator = "::"; static constexpr size_t separatorSize = 2;
size_t separatorPos = 0; auto findNextSeparator = [&reporterSpec]( size_t startPos ) { static_assert( separatorSize == 2, "The code below currently assumes 2 char separator" );
auto currentPos = startPos; do { while ( currentPos < reporterSpec.size() && reporterSpec[currentPos] != separator[0] ) { ++currentPos; } if ( currentPos + 1 < reporterSpec.size() && reporterSpec[currentPos + 1] == separator[1] ) { return currentPos; } ++currentPos; } while ( currentPos < reporterSpec.size() );
return static_cast<size_t>( -1 ); };
std::vector<std::string> parts;
while ( separatorPos < reporterSpec.size() ) { const auto nextSeparator = findNextSeparator( separatorPos ); parts.push_back( static_cast<std::string>( reporterSpec.substr( separatorPos, nextSeparator - separatorPos ) ) );
if ( nextSeparator == static_cast<size_t>( -1 ) ) { break; } separatorPos = nextSeparator + separatorSize; }
// Handle a separator at the end. // This is not a valid spec, but we want to do validation in a // centralized place if ( separatorPos == reporterSpec.size() ) { parts.emplace_back(); }
return parts; }
Optional<ColourMode> stringToColourMode( StringRef colourMode ) { if ( colourMode == "default" ) { return ColourMode::PlatformDefault; } else if ( colourMode == "ansi" ) { return ColourMode::ANSI; } else if ( colourMode == "win32" ) { return ColourMode::Win32; } else if ( colourMode == "none" ) { return ColourMode::None; } else { return {}; } } } // namespace Detail
bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) { return lhs.m_name == rhs.m_name && lhs.m_outputFileName == rhs.m_outputFileName && lhs.m_colourMode == rhs.m_colourMode && lhs.m_customOptions == rhs.m_customOptions; }
Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) { auto parts = Detail::splitReporterSpec( reporterSpec );
assert( parts.size() > 0 && "Split should never return empty vector" );
std::map<std::string, std::string> kvPairs; Optional<std::string> outputFileName; Optional<ColourMode> colourMode;
// First part is always reporter name, so we skip it for ( size_t i = 1; i < parts.size(); ++i ) { auto kv = splitKVPair( parts[i] ); auto key = kv.key, value = kv.value;
if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone) return {}; } else if ( key[0] == 'X' ) { // This is a reporter-specific option, we don't check these // apart from basic sanity checks if ( key.size() == 1 ) { return {}; }
auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) ); if ( !ret.second ) { // Duplicated key. We might want to handle this differently, // e.g. by overwriting the existing value? return {}; } } else if ( key == "out" ) { // Duplicated key if ( outputFileName ) { return {}; } outputFileName = static_cast<std::string>( value ); } else if ( key == "colour-mode" ) { // Duplicated key if ( colourMode ) { return {}; } colourMode = Detail::stringToColourMode( value ); // Parsing failed if ( !colourMode ) { return {}; } } else { // Unrecognized option return {}; } }
return ReporterSpec{ CATCH_MOVE( parts[0] ), CATCH_MOVE( outputFileName ), CATCH_MOVE( colourMode ), CATCH_MOVE( kvPairs ) }; }
ReporterSpec::ReporterSpec( std::string name, Optional<std::string> outputFileName, Optional<ColourMode> colourMode, std::map<std::string, std::string> customOptions ): m_name( CATCH_MOVE( name ) ), m_outputFileName( CATCH_MOVE( outputFileName ) ), m_colourMode( CATCH_MOVE( colourMode ) ), m_customOptions( CATCH_MOVE( customOptions ) ) {}
} // namespace Catch
namespace Catch {
bool isOk( ResultWas::OfType resultType ) { return ( resultType & ResultWas::FailureBit ) == 0; } bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) ); }
bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
} // end namespace Catch
#include <cstdio>#include <sstream>#include <vector>
namespace Catch {
// This class encapsulates the idea of a pool of ostringstreams that can be reused. struct StringStreams { std::vector<Detail::unique_ptr<std::ostringstream>> m_streams; std::vector<std::size_t> m_unused; std::ostringstream m_referenceStream; // Used for copy state/ flags from
auto add() -> std::size_t { if( m_unused.empty() ) { m_streams.push_back( Detail::make_unique<std::ostringstream>() ); return m_streams.size()-1; } else { auto index = m_unused.back(); m_unused.pop_back(); return index; } }
void release( std::size_t index ) { m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state m_unused.push_back(index); } };
ReusableStringStream::ReusableStringStream() : m_index( Singleton<StringStreams>::getMutable().add() ), m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() ) {}
ReusableStringStream::~ReusableStringStream() { static_cast<std::ostringstream*>( m_oss )->str(""); m_oss->clear(); Singleton<StringStreams>::getMutable().release( m_index ); }
std::string ReusableStringStream::str() const { return static_cast<std::ostringstream*>( m_oss )->str(); }
void ReusableStringStream::str( std::string const& str ) { static_cast<std::ostringstream*>( m_oss )->str( str ); }
}
#include <cassert>#include <algorithm>
namespace Catch {
namespace Generators { namespace { struct GeneratorTracker final : TestCaseTracking::TrackerBase, IGeneratorTracker { GeneratorBasePtr m_generator;
GeneratorTracker( TestCaseTracking::NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ): TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
static GeneratorTracker* acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocationRef const& nameAndLocation ) { GeneratorTracker* tracker;
ITracker& currentTracker = ctx.currentTracker(); // Under specific circumstances, the generator we want // to acquire is also the current tracker. If this is // the case, we have to avoid looking through current // tracker's children, and instead return the current // tracker. // A case where this check is important is e.g. // for (int i = 0; i < 5; ++i) { // int n = GENERATE(1, 2); // } // // without it, the code above creates 5 nested generators. if ( currentTracker.nameAndLocation() == nameAndLocation ) { auto thisTracker = currentTracker.parent()->findChild( nameAndLocation ); assert( thisTracker ); assert( thisTracker->isGeneratorTracker() ); tracker = static_cast<GeneratorTracker*>( thisTracker ); } else if ( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) { assert( childTracker ); assert( childTracker->isGeneratorTracker() ); tracker = static_cast<GeneratorTracker*>( childTracker ); } else { return nullptr; }
if ( !tracker->isComplete() ) { tracker->open(); }
return tracker; }
// TrackerBase interface bool isGeneratorTracker() const override { return true; } auto hasGenerator() const -> bool override { return !!m_generator; } void close() override { TrackerBase::close(); // If a generator has a child (it is followed by a section) // and none of its children have started, then we must wait // until later to start consuming its values. // This catches cases where `GENERATE` is placed between two // `SECTION`s. // **The check for m_children.empty cannot be removed**. // doing so would break `GENERATE` _not_ followed by // `SECTION`s. const bool should_wait_for_child = [&]() { // No children -> nobody to wait for if ( m_children.empty() ) { return false; } // If at least one child started executing, don't wait if ( std::find_if( m_children.begin(), m_children.end(), []( TestCaseTracking::ITrackerPtr const& tracker ) { return tracker->hasStarted(); } ) != m_children.end() ) { return false; }
// No children have started. We need to check if they // _can_ start, and thus we should wait for them, or // they cannot start (due to filters), and we shouldn't // wait for them ITracker* parent = m_parent; // This is safe: there is always at least one section // tracker in a test case tracking tree while ( !parent->isSectionTracker() ) { parent = parent->parent(); } assert( parent && "Missing root (test case) level section" );
auto const& parentSection = static_cast<SectionTracker const&>( *parent ); auto const& filters = parentSection.getFilters(); // No filters -> no restrictions on running sections if ( filters.empty() ) { return true; }
for ( auto const& child : m_children ) { if ( child->isSectionTracker() && std::find( filters.begin(), filters.end(), static_cast<SectionTracker const&>( *child ) .trimmedName() ) != filters.end() ) { return true; } } return false; }();
// This check is a bit tricky, because m_generator->next() // has a side-effect, where it consumes generator's current // value, but we do not want to invoke the side-effect if // this generator is still waiting for any child to start. assert( m_generator && "Tracker without generator" ); if ( should_wait_for_child || ( m_runState == CompletedSuccessfully && m_generator->countedNext() ) ) { m_children.clear(); m_runState = Executing; } }
// IGeneratorTracker interface auto getGenerator() const -> GeneratorBasePtr const& override { return m_generator; } void setGenerator( GeneratorBasePtr&& generator ) override { m_generator = CATCH_MOVE( generator ); } }; } // namespace }
RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter) : m_runInfo(_config->name()), m_config(_config), m_reporter(CATCH_MOVE(reporter)), m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal }, m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions ) { getCurrentMutableContext().setResultCapture( this ); m_reporter->testRunStarting(m_runInfo); }
RunContext::~RunContext() { m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting())); }
Totals RunContext::runTest(TestCaseHandle const& testCase) { const Totals prevTotals = m_totals;
auto const& testInfo = testCase.getTestCaseInfo(); m_reporter->testCaseStarting(testInfo); m_activeTestCase = &testCase;
ITracker& rootTracker = m_trackerContext.startRun(); assert(rootTracker.isSectionTracker()); static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
// We intentionally only seed the internal RNG once per test case, // before it is first invoked. The reason for that is a complex // interplay of generator/section implementation details and the // Random*Generator types. // // The issue boils down to us needing to seed the Random*Generators // with different seed each, so that they return different sequences // of random numbers. We do this by giving them a number from the // shared RNG instance as their seed. // // However, this runs into an issue if the reseeding happens each // time the test case is entered (as opposed to first time only), // because multiple generators could get the same seed, e.g. in // ```cpp // TEST_CASE() { // auto i = GENERATE(take(10, random(0, 100)); // SECTION("A") { // auto j = GENERATE(take(10, random(0, 100)); // } // SECTION("B") { // auto k = GENERATE(take(10, random(0, 100)); // } // } // ``` // `i` and `j` would properly return values from different sequences, // but `i` and `k` would return the same sequence, because their seed // would be the same. // (The reason their seeds would be the same is that the generator // for k would be initialized when the test case is entered the second // time, after the shared RNG instance was reset to the same value // it had when the generator for i was initialized.) seedRng( *m_config );
uint64_t testRuns = 0; std::string redirectedCout; std::string redirectedCerr; do { m_trackerContext.startCycle(); m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
m_reporter->testCasePartialStarting(testInfo, testRuns);
const auto beforeRunTotals = m_totals; std::string oneRunCout, oneRunCerr; runCurrentTest(oneRunCout, oneRunCerr); redirectedCout += oneRunCout; redirectedCerr += oneRunCerr;
const auto singleRunTotals = m_totals.delta(beforeRunTotals); auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
m_reporter->testCasePartialEnded(statsForOneRun, testRuns); ++testRuns; } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
Totals deltaTotals = m_totals.delta(prevTotals); if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) { deltaTotals.assertions.failed++; deltaTotals.testCases.passed--; deltaTotals.testCases.failed++; } m_totals.testCases += deltaTotals.testCases; m_reporter->testCaseEnded(TestCaseStats(testInfo, deltaTotals, CATCH_MOVE(redirectedCout), CATCH_MOVE(redirectedCerr), aborting()));
m_activeTestCase = nullptr; m_testCaseTracker = nullptr;
return deltaTotals; }
void RunContext::assertionEnded(AssertionResult&& result) { if (result.getResultType() == ResultWas::Ok) { m_totals.assertions.passed++; m_lastAssertionPassed = true; } else if (result.getResultType() == ResultWas::ExplicitSkip) { m_totals.assertions.skipped++; m_lastAssertionPassed = true; } else if (!result.succeeded()) { m_lastAssertionPassed = false; if (result.isOk()) { } else if( m_activeTestCase->getTestCaseInfo().okToFail() ) m_totals.assertions.failedButOk++; else m_totals.assertions.failed++; } else { m_lastAssertionPassed = true; }
m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
if ( result.getResultType() != ResultWas::Warning ) { m_messageScopes.clear(); }
// Reset working state. assertion info will be reset after // populateReaction is run if it is needed m_lastResult = CATCH_MOVE( result ); } void RunContext::resetAssertionInfo() { m_lastAssertionInfo.macroName = StringRef(); m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr; m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal; }
void RunContext::notifyAssertionStarted( AssertionInfo const& info ) { m_reporter->assertionStarting( info ); }
bool RunContext::sectionStarted( StringRef sectionName, SourceLineInfo const& sectionLineInfo, Counts& assertions ) { ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocationRef( sectionName, sectionLineInfo ) );
if (!sectionTracker.isOpen()) return false; m_activeSections.push_back(§ionTracker);
SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) ); m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting(sectionInfo);
assertions = m_totals.assertions;
return true; } IGeneratorTracker* RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) { using namespace Generators; GeneratorTracker* tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocationRef( generatorName, lineInfo ) ); m_lastAssertionInfo.lineInfo = lineInfo; return tracker; }
IGeneratorTracker* RunContext::createGeneratorTracker( StringRef generatorName, SourceLineInfo lineInfo, Generators::GeneratorBasePtr&& generator ) {
auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo ); auto& currentTracker = m_trackerContext.currentTracker(); assert( currentTracker.nameAndLocation() != nameAndLoc && "Trying to create tracker for a genreator that already has one" );
auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>( CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker ); auto ret = newTracker.get(); currentTracker.addChild( CATCH_MOVE( newTracker ) );
ret->setGenerator( CATCH_MOVE( generator ) ); ret->open(); return ret; }
bool RunContext::testForMissingAssertions(Counts& assertions) { if (assertions.total() != 0) return false; if (!m_config->warnAboutMissingAssertions()) return false; if (m_trackerContext.currentTracker().hasChildren()) return false; m_totals.assertions.failed++; assertions.failed++; return true; }
void RunContext::sectionEnded(SectionEndInfo&& endInfo) { Counts assertions = m_totals.assertions - endInfo.prevAssertions; bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) { m_activeSections.back()->close(); m_activeSections.pop_back(); }
m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions)); m_messages.clear(); m_messageScopes.clear(); }
void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) { if ( m_unfinishedSections.empty() ) { m_activeSections.back()->fail(); } else { m_activeSections.back()->close(); } m_activeSections.pop_back();
m_unfinishedSections.push_back(CATCH_MOVE(endInfo)); }
void RunContext::benchmarkPreparing( StringRef name ) { m_reporter->benchmarkPreparing(name); } void RunContext::benchmarkStarting( BenchmarkInfo const& info ) { m_reporter->benchmarkStarting( info ); } void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) { m_reporter->benchmarkEnded( stats ); } void RunContext::benchmarkFailed( StringRef error ) { m_reporter->benchmarkFailed( error ); }
void RunContext::pushScopedMessage(MessageInfo const & message) { m_messages.push_back(message); }
void RunContext::popScopedMessage(MessageInfo const & message) { m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end()); }
void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) { m_messageScopes.emplace_back( CATCH_MOVE(builder) ); }
std::string RunContext::getCurrentTestName() const { return m_activeTestCase ? m_activeTestCase->getTestCaseInfo().name : std::string(); }
const AssertionResult * RunContext::getLastResult() const { return &(*m_lastResult); }
void RunContext::exceptionEarlyReported() { m_shouldReportUnexpected = false; }
void RunContext::handleFatalErrorCondition( StringRef message ) { // First notify reporter that bad things happened m_reporter->fatalErrorEncountered(message);
// Don't rebuild the result -- the stringification itself can cause more fatal errors // Instead, fake a result data. AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } ); tempResult.message = static_cast<std::string>(message); AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
assertionEnded(CATCH_MOVE(result) ); resetAssertionInfo();
// Best effort cleanup for sections that have not been destructed yet // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly while (!m_activeSections.empty()) { auto nl = m_activeSections.back()->nameAndLocation(); SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 }; sectionEndedEarly(CATCH_MOVE(endInfo)); } handleUnfinishedSections();
// Recreate section for test case (as we will lose the one that was in scope) auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
Counts assertions; assertions.failed = 1; SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false); m_reporter->sectionEnded(testCaseSectionStats);
auto const& testInfo = m_activeTestCase->getTestCaseInfo();
Totals deltaTotals; deltaTotals.testCases.failed = 1; deltaTotals.assertions.failed = 1; m_reporter->testCaseEnded(TestCaseStats(testInfo, deltaTotals, std::string(), std::string(), false)); m_totals.testCases.failed++; m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false)); }
bool RunContext::lastAssertionPassed() { return m_lastAssertionPassed; }
void RunContext::assertionPassed() { m_lastAssertionPassed = true; ++m_totals.assertions.passed; resetAssertionInfo(); m_messageScopes.clear(); }
bool RunContext::aborting() const { return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter()); }
void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) { auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name); m_reporter->sectionStarting(testCaseSection); Counts prevAssertions = m_totals.assertions; double duration = 0; m_shouldReportUnexpected = true; m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
Timer timer; CATCH_TRY { if (m_reporter->getPreferences().shouldRedirectStdOut) {#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
timer.start(); invokeActiveTestCase();#else OutputRedirect r(redirectedCout, redirectedCerr); timer.start(); invokeActiveTestCase();#endif } else { timer.start(); invokeActiveTestCase(); } duration = timer.getElapsedSeconds(); } CATCH_CATCH_ANON (TestFailureException&) { // This just means the test was aborted due to failure } CATCH_CATCH_ANON (TestSkipException&) { // This just means the test was explicitly skipped } CATCH_CATCH_ALL { // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions // are reported without translation at the point of origin. if( m_shouldReportUnexpected ) { AssertionReaction dummyReaction; handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction ); } } Counts assertions = m_totals.assertions - prevAssertions; bool missingAssertions = testForMissingAssertions(assertions);
m_testCaseTracker->close(); handleUnfinishedSections(); m_messages.clear(); m_messageScopes.clear();
SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions); m_reporter->sectionEnded(testCaseSectionStats); }
void RunContext::invokeActiveTestCase() { // We need to engage a handler for signals/structured exceptions // before running the tests themselves, or the binary can crash // without failed test being reported. FatalConditionHandlerGuard _(&m_fatalConditionhandler); // We keep having issue where some compilers warn about an unused // variable, even though the type has non-trivial constructor and // destructor. This is annoying and ugly, but it makes them stfu. (void)_;
m_activeTestCase->invoke(); }
void RunContext::handleUnfinishedSections() { // If sections ended prematurely due to an exception we stored their // infos here so we can tear them down outside the unwind process. for (auto it = m_unfinishedSections.rbegin(), itEnd = m_unfinishedSections.rend(); it != itEnd; ++it) sectionEnded(CATCH_MOVE(*it)); m_unfinishedSections.clear(); }
void RunContext::handleExpr( AssertionInfo const& info, ITransientExpression const& expr, AssertionReaction& reaction ) { bool negated = isFalseTest( info.resultDisposition ); bool result = expr.getResult() != negated;
if( result ) { if (!m_includeSuccessfulResults) { assertionPassed(); } else { reportExpr(info, ResultWas::Ok, &expr, negated); } } else { reportExpr(info, ResultWas::ExpressionFailed, &expr, negated ); populateReaction( reaction ); } resetAssertionInfo(); } void RunContext::reportExpr( AssertionInfo const &info, ResultWas::OfType resultType, ITransientExpression const *expr, bool negated ) {
m_lastAssertionInfo = info; AssertionResultData data( resultType, LazyExpression( negated ) );
AssertionResult assertionResult{ info, CATCH_MOVE( data ) }; assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
assertionEnded( CATCH_MOVE(assertionResult) ); }
void RunContext::handleMessage( AssertionInfo const& info, ResultWas::OfType resultType, StringRef message, AssertionReaction& reaction ) { m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( false ) ); data.message = static_cast<std::string>(message); AssertionResult assertionResult{ m_lastAssertionInfo, CATCH_MOVE( data ) };
const auto isOk = assertionResult.isOk(); assertionEnded( CATCH_MOVE(assertionResult) ); if ( !isOk ) { populateReaction( reaction ); } else if ( resultType == ResultWas::ExplicitSkip ) { // TODO: Need to handle this explicitly, as ExplicitSkip is // considered "OK" reaction.shouldSkip = true; } resetAssertionInfo(); } void RunContext::handleUnexpectedExceptionNotThrown( AssertionInfo const& info, AssertionReaction& reaction ) { handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction); }
void RunContext::handleUnexpectedInflightException( AssertionInfo const& info, std::string&& message, AssertionReaction& reaction ) { m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) ); data.message = CATCH_MOVE(message); AssertionResult assertionResult{ info, CATCH_MOVE(data) }; assertionEnded( CATCH_MOVE(assertionResult) ); populateReaction( reaction ); resetAssertionInfo(); }
void RunContext::populateReaction( AssertionReaction& reaction ) { reaction.shouldDebugBreak = m_config->shouldDebugBreak(); reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal); }
void RunContext::handleIncomplete( AssertionInfo const& info ) { using namespace std::string_literals; m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) ); data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s; AssertionResult assertionResult{ info, CATCH_MOVE( data ) }; assertionEnded( CATCH_MOVE(assertionResult) ); resetAssertionInfo(); } void RunContext::handleNonExpr( AssertionInfo const &info, ResultWas::OfType resultType, AssertionReaction &reaction ) { m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( false ) ); AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
const auto isOk = assertionResult.isOk(); assertionEnded( CATCH_MOVE(assertionResult) ); if ( !isOk ) { populateReaction( reaction ); } resetAssertionInfo(); }
IResultCapture& getResultCapture() { if (auto* capture = getCurrentContext().getResultCapture()) return *capture; else CATCH_INTERNAL_ERROR("No result capture instance"); }
void seedRng(IConfig const& config) { sharedRng().seed(config.rngSeed()); }
unsigned int rngSeed() { return getCurrentContext().getConfig()->rngSeed(); }
}
namespace Catch {
Section::Section( SectionInfo&& info ): m_info( CATCH_MOVE( info ) ), m_sectionIncluded( getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) { // Non-"included" sections will not use the timing information // anyway, so don't bother with the potential syscall. if (m_sectionIncluded) { m_timer.start(); } }
Section::Section( SourceLineInfo const& _lineInfo, StringRef _name, const char* const ): m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ), m_sectionIncluded( getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) { // We delay initialization the SectionInfo member until we know // this section needs it, so we avoid allocating std::string for name. // We also delay timer start to avoid the potential syscall unless we // will actually use the result. if ( m_sectionIncluded ) { m_info.name = static_cast<std::string>( _name ); m_info.lineInfo = _lineInfo; m_timer.start(); } }
Section::~Section() { if( m_sectionIncluded ) { SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() }; if ( uncaught_exceptions() ) { getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) ); } else { getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) ); } } }
// This indicates whether the section should be executed or not Section::operator bool() const { return m_sectionIncluded; }
} // end namespace Catch
#include <vector>
namespace Catch {
namespace { static auto getSingletons() -> std::vector<ISingleton*>*& { static std::vector<ISingleton*>* g_singletons = nullptr; if( !g_singletons ) g_singletons = new std::vector<ISingleton*>(); return g_singletons; } }
ISingleton::~ISingleton() = default;
void addSingleton(ISingleton* singleton ) { getSingletons()->push_back( singleton ); } void cleanupSingletons() { auto& singletons = getSingletons(); for( auto singleton : *singletons ) delete singleton; delete singletons; singletons = nullptr; }
} // namespace Catch
#include <cstring>#include <ostream>
namespace Catch {
bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept { return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0); } bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept { // We can assume that the same file will usually have the same pointer. // Thus, if the pointers are the same, there is no point in calling the strcmp return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0)); }
std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {#ifndef __GNUG__ os << info.file << '(' << info.line << ')';#else os << info.file << ':' << info.line;#endif return os; }
} // end namespace Catch
namespace Catch {#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept { CATCH_TRY { m_exceptions.push_back(exception); } CATCH_CATCH_ALL { // If we run out of memory during start-up there's really not a lot more we can do about it std::terminate(); } }
std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept { return m_exceptions; }#endif
} // end namespace Catch
#include <iostream>
namespace Catch {
// If you #define this you must implement these functions#if !defined( CATCH_CONFIG_NOSTDOUT ) std::ostream& cout() { return std::cout; } std::ostream& cerr() { return std::cerr; } std::ostream& clog() { return std::clog; }#endif
} // namespace Catch
#include <ostream>#include <cstring>#include <cctype>#include <vector>
namespace Catch {
bool startsWith( std::string const& s, std::string const& prefix ) { return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin()); } bool startsWith( StringRef s, char prefix ) { return !s.empty() && s[0] == prefix; } bool endsWith( std::string const& s, std::string const& suffix ) { return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin()); } bool endsWith( std::string const& s, char suffix ) { return !s.empty() && s[s.size()-1] == suffix; } bool contains( std::string const& s, std::string const& infix ) { return s.find( infix ) != std::string::npos; } void toLowerInPlace( std::string& s ) { for ( char& c : s ) { c = toLower( c ); } } std::string toLower( std::string const& s ) { std::string lc = s; toLowerInPlace( lc ); return lc; } char toLower(char c) { return static_cast<char>(std::tolower(static_cast<unsigned char>(c))); }
std::string trim( std::string const& str ) { static char const* whitespaceChars = "\n\r\t "; std::string::size_type start = str.find_first_not_of( whitespaceChars ); std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string(); }
StringRef trim(StringRef ref) { const auto is_ws = [](char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }; size_t real_begin = 0; while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; } size_t real_end = ref.size(); while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
return ref.substr(real_begin, real_end - real_begin); }
bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { std::size_t i = str.find( replaceThis ); if (i == std::string::npos) { return false; } std::size_t copyBegin = 0; std::string origStr = CATCH_MOVE(str); str.clear(); // There is at least one replacement, so reserve with the best guess // we can make without actually counting the number of occurences. str.reserve(origStr.size() - replaceThis.size() + withThis.size()); do { str.append(origStr, copyBegin, i-copyBegin ); str += withThis; copyBegin = i + replaceThis.size(); if( copyBegin < origStr.size() ) i = origStr.find( replaceThis, copyBegin ); else i = std::string::npos; } while( i != std::string::npos ); if ( copyBegin < origStr.size() ) { str.append(origStr, copyBegin, origStr.size() ); } return true; }
std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) { std::vector<StringRef> subStrings; std::size_t start = 0; for(std::size_t pos = 0; pos < str.size(); ++pos ) { if( str[pos] == delimiter ) { if( pos - start > 1 ) subStrings.push_back( str.substr( start, pos-start ) ); start = pos+1; } } if( start < str.size() ) subStrings.push_back( str.substr( start, str.size()-start ) ); return subStrings; }
std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { os << pluraliser.m_count << ' ' << pluraliser.m_label; if( pluraliser.m_count != 1 ) os << 's'; return os; }
}
#include <algorithm>#include <ostream>#include <cstring>#include <cstdint>
namespace Catch { StringRef::StringRef( char const* rawChars ) noexcept : StringRef( rawChars, std::strlen(rawChars) ) {}
bool StringRef::operator<(StringRef rhs) const noexcept { if (m_size < rhs.m_size) { return strncmp(m_start, rhs.m_start, m_size) <= 0; } return strncmp(m_start, rhs.m_start, rhs.m_size) < 0; }
int StringRef::compare( StringRef rhs ) const { auto cmpResult = strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
// This means that strncmp found a difference before the strings // ended, and we can return it directly if ( cmpResult != 0 ) { return cmpResult; }
// If strings are equal up to length, then their comparison results on // their size if ( m_size < rhs.m_size ) { return -1; } else if ( m_size > rhs.m_size ) { return 1; } else { return 0; } }
auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& { return os.write(str.data(), static_cast<std::streamsize>(str.size())); }
std::string operator+(StringRef lhs, StringRef rhs) { std::string ret; ret.reserve(lhs.size() + rhs.size()); ret += lhs; ret += rhs; return ret; }
auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& { lhs.append(rhs.data(), rhs.size()); return lhs; }
} // namespace Catch
namespace Catch {
TagAliasRegistry::~TagAliasRegistry() = default;
TagAlias const* TagAliasRegistry::find( std::string const& alias ) const { auto it = m_registry.find( alias ); if( it != m_registry.end() ) return &(it->second); else return nullptr; }
std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { std::string expandedTestSpec = unexpandedTestSpec; for( auto const& registryKvp : m_registry ) { std::size_t pos = expandedTestSpec.find( registryKvp.first ); if( pos != std::string::npos ) { expandedTestSpec = expandedTestSpec.substr( 0, pos ) + registryKvp.second.tag + expandedTestSpec.substr( pos + registryKvp.first.size() ); } } return expandedTestSpec; }
void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) { CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'), "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second, "error: tag alias, '" << alias << "' already registered.\n" << "\tFirst seen at: " << find(alias)->lineInfo << "\n" << "\tRedefined at: " << lineInfo ); }
ITagAliasRegistry::~ITagAliasRegistry() = default;
ITagAliasRegistry const& ITagAliasRegistry::get() { return getRegistryHub().getTagAliasRegistry(); }
} // end namespace Catch
namespace Catch { TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const { // FNV-1a hash algorithm that is designed for uniqueness: const hash_t prime = 1099511628211u; hash_t hash = 14695981039346656037u; for ( const char c : t.name ) { hash ^= c; hash *= prime; } for ( const char c : t.className ) { hash ^= c; hash *= prime; } for ( const Tag& tag : t.tags ) { for ( const char c : tag.original ) { hash ^= c; hash *= prime; } } hash ^= m_seed; hash *= prime; const uint32_t low{ static_cast<uint32_t>( hash ) }; const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) }; return low * high; }} // namespace Catch
#include <algorithm>#include <set>
namespace Catch {
namespace { static void enforceNoDuplicateTestCases( std::vector<TestCaseHandle> const& tests ) { auto testInfoCmp = []( TestCaseInfo const* lhs, TestCaseInfo const* rhs ) { return *lhs < *rhs; }; std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests( testInfoCmp ); for ( auto const& test : tests ) { const auto infoPtr = &test.getTestCaseInfo(); const auto prev = seenTests.insert( infoPtr ); CATCH_ENFORCE( prev.second, "error: test case \"" << infoPtr->name << "\", with tags \"" << infoPtr->tagsAsString() << "\" already defined.\n" << "\tFirst seen at " << ( *prev.first )->lineInfo << "\n" << "\tRedefined at " << infoPtr->lineInfo ); } }
static bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config ) { return testSpec.matches( testCase.getTestCaseInfo() ) && isThrowSafe( testCase, config ); }
} // end unnamed namespace
std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) { switch (config.runOrder()) { case TestRunOrder::Declared: return unsortedTestCases;
case TestRunOrder::LexicographicallySorted: { std::vector<TestCaseHandle> sorted = unsortedTestCases; std::sort( sorted.begin(), sorted.end(), []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) { return lhs.getTestCaseInfo() < rhs.getTestCaseInfo(); } ); return sorted; } case TestRunOrder::Randomized: { using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
TestCaseInfoHasher h{ config.rngSeed() }; std::vector<TestWithHash> indexed_tests; indexed_tests.reserve(unsortedTestCases.size());
for (auto const& handle : unsortedTestCases) { indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle); }
std::sort( indexed_tests.begin(), indexed_tests.end(), []( TestWithHash const& lhs, TestWithHash const& rhs ) { if ( lhs.first == rhs.first ) { return lhs.second.getTestCaseInfo() < rhs.second.getTestCaseInfo(); } return lhs.first < rhs.first; } );
std::vector<TestCaseHandle> randomized; randomized.reserve(indexed_tests.size());
for (auto const& indexed : indexed_tests) { randomized.push_back(indexed.second); }
return randomized; } }
CATCH_INTERNAL_ERROR("Unknown test order value!"); }
bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) { return !testCase.getTestCaseInfo().throws() || config.allowThrows(); }
std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) { std::vector<TestCaseHandle> filtered; filtered.reserve( testCases.size() ); for (auto const& testCase : testCases) { if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) || (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) { filtered.push_back(testCase); } } return createShard(filtered, config.shardCount(), config.shardIndex()); } std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) { return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config ); }
TestRegistry::~TestRegistry() = default;
void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) { m_handles.emplace_back(testInfo.get(), testInvoker.get()); m_viewed_test_infos.push_back(testInfo.get()); m_owned_test_infos.push_back(CATCH_MOVE(testInfo)); m_invokers.push_back(CATCH_MOVE(testInvoker)); }
std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const { return m_viewed_test_infos; }
std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const { return m_handles; } std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const { if( m_sortedFunctions.empty() ) enforceNoDuplicateTestCases( m_handles );
if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) { m_sortedFunctions = sortTests( config, m_handles ); m_currentSortOrder = config.runOrder(); } return m_sortedFunctions; }
} // end namespace Catch
#include <algorithm>#include <cassert>
#if defined(__clang__)# pragma clang diagnostic push# pragma clang diagnostic ignored "-Wexit-time-destructors"#endif
namespace Catch {namespace TestCaseTracking {
NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location ) : name( CATCH_MOVE(_name) ), location( _location ) {}
ITracker::~ITracker() = default;
void ITracker::markAsNeedingAnotherRun() { m_runState = NeedsAnotherRun; }
void ITracker::addChild( ITrackerPtr&& child ) { m_children.push_back( CATCH_MOVE(child) ); }
ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) { auto it = std::find_if( m_children.begin(), m_children.end(), [&nameAndLocation]( ITrackerPtr const& tracker ) { auto const& tnameAndLoc = tracker->nameAndLocation(); if ( tnameAndLoc.location.line != nameAndLocation.location.line ) { return false; } return tnameAndLoc == nameAndLocation; } ); return ( it != m_children.end() ) ? it->get() : nullptr; }
bool ITracker::isSectionTracker() const { return false; } bool ITracker::isGeneratorTracker() const { return false; }
bool ITracker::isOpen() const { return m_runState != NotStarted && !isComplete(); }
bool ITracker::hasStarted() const { return m_runState != NotStarted; }
void ITracker::openChild() { if (m_runState != ExecutingChildren) { m_runState = ExecutingChildren; if (m_parent) { m_parent->openChild(); } } }
ITracker& TrackerContext::startRun() { using namespace std::string_literals; m_rootTracker = Catch::Detail::make_unique<SectionTracker>( NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ), *this, nullptr ); m_currentTracker = nullptr; m_runState = Executing; return *m_rootTracker; }
void TrackerContext::completeCycle() { m_runState = CompletedCycle; }
bool TrackerContext::completedCycle() const { return m_runState == CompletedCycle; } void TrackerContext::setCurrentTracker( ITracker* tracker ) { m_currentTracker = tracker; }
TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ): ITracker(CATCH_MOVE(nameAndLocation), parent), m_ctx( ctx ) {}
bool TrackerBase::isComplete() const { return m_runState == CompletedSuccessfully || m_runState == Failed; }
void TrackerBase::open() { m_runState = Executing; moveToThis(); if( m_parent ) m_parent->openChild(); }
void TrackerBase::close() {
// Close any still open children (e.g. generators) while( &m_ctx.currentTracker() != this ) m_ctx.currentTracker().close();
switch( m_runState ) { case NeedsAnotherRun: break;
case Executing: m_runState = CompletedSuccessfully; break; case ExecutingChildren: if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) ) m_runState = CompletedSuccessfully; break;
case NotStarted: case CompletedSuccessfully: case Failed: CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
default: CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState ); } moveToParent(); m_ctx.completeCycle(); } void TrackerBase::fail() { m_runState = Failed; if( m_parent ) m_parent->markAsNeedingAnotherRun(); moveToParent(); m_ctx.completeCycle(); }
void TrackerBase::moveToParent() { assert( m_parent ); m_ctx.setCurrentTracker( m_parent ); } void TrackerBase::moveToThis() { m_ctx.setCurrentTracker( this ); }
SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ) : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ), m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name))) { if( parent ) { while ( !parent->isSectionTracker() ) { parent = parent->parent(); }
SectionTracker& parentSection = static_cast<SectionTracker&>( *parent ); addNextFilters( parentSection.m_filters ); } }
bool SectionTracker::isComplete() const { bool complete = true;
if (m_filters.empty() || m_filters[0].empty() || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) { complete = TrackerBase::isComplete(); } return complete; }
bool SectionTracker::isSectionTracker() const { return true; }
SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) { SectionTracker* tracker;
ITracker& currentTracker = ctx.currentTracker(); if ( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) { assert( childTracker ); assert( childTracker->isSectionTracker() ); tracker = static_cast<SectionTracker*>( childTracker ); } else { auto newTracker = Catch::Detail::make_unique<SectionTracker>( NameAndLocation{ static_cast<std::string>(nameAndLocation.name), nameAndLocation.location }, ctx, ¤tTracker ); tracker = newTracker.get(); currentTracker.addChild( CATCH_MOVE( newTracker ) ); }
if ( !ctx.completedCycle() ) { tracker->tryOpen(); }
return *tracker; }
void SectionTracker::tryOpen() { if( !isComplete() ) open(); }
void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) { if( !filters.empty() ) { m_filters.reserve( m_filters.size() + filters.size() + 2 ); m_filters.emplace_back(StringRef{}); // Root - should never be consulted m_filters.emplace_back(StringRef{}); // Test Case - not a section filter m_filters.insert( m_filters.end(), filters.begin(), filters.end() ); } } void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) { if( filters.size() > 1 ) m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() ); }
StringRef SectionTracker::trimmedName() const { return m_trimmed_name; }
} // namespace TestCaseTracking
} // namespace Catch
#if defined(__clang__)# pragma clang diagnostic pop#endif
namespace Catch {
void throw_test_failure_exception() {#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) throw TestFailureException{};#else CATCH_ERROR( "Test failure requires aborting test!" );#endif }
void throw_test_skip_exception() {#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) throw Catch::TestSkipException();#else CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );#endif }
} // namespace Catch
#include <algorithm>#include <iterator>
namespace Catch { ITestInvoker::~ITestInvoker() = default;
namespace { static StringRef extractClassName( StringRef classOrMethodName ) { if ( !startsWith( classOrMethodName, '&' ) ) { return classOrMethodName; }
// Remove the leading '&' to avoid having to special case it later const auto methodName = classOrMethodName.substr( 1, classOrMethodName.size() );
auto reverseStart = std::make_reverse_iterator( methodName.end() ); auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
// We make a simplifying assumption that ":" is only present // in the input as part of "::" from C++ typenames (this is // relatively safe assumption because the input is generated // as stringification of type through preprocessor). auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1; auto secondLastColons = std::find( lastColons + 1, reverseEnd, ':' );
auto const startIdx = reverseEnd - secondLastColons; auto const classNameSize = secondLastColons - lastColons - 1;
return methodName.substr( static_cast<std::size_t>( startIdx ), static_cast<std::size_t>( classNameSize ) ); }
class TestInvokerAsFunction final : public ITestInvoker { using TestType = void ( * )(); TestType m_testAsFunction;
public: TestInvokerAsFunction( TestType testAsFunction ) noexcept: m_testAsFunction( testAsFunction ) {}
void invoke() const override { m_testAsFunction(); } };
} // namespace
Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) { return Detail::make_unique<TestInvokerAsFunction>( testAsFunction ); }
AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept { CATCH_TRY { getMutableRegistryHub() .registerTest( makeTestCaseInfo( extractClassName( classOrMethod ), nameAndTags, lineInfo), CATCH_MOVE(invoker) ); } CATCH_CATCH_ALL { // Do not throw when constructing global objects, instead register the exception to be processed later getMutableRegistryHub().registerStartupException(); } }}
namespace Catch {
TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
TestSpecParser& TestSpecParser::parse( std::string const& arg ) { m_mode = None; m_exclusion = false; m_arg = m_tagAliases->expandAliases( arg ); m_escapeChars.clear(); m_substring.reserve(m_arg.size()); m_patternName.reserve(m_arg.size()); m_realPatternPos = 0;
for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) //if visitChar fails if( !visitChar( m_arg[m_pos] ) ){ m_testSpec.m_invalidSpecs.push_back(arg); break; } endMode(); return *this; } TestSpec TestSpecParser::testSpec() { addFilter(); return CATCH_MOVE(m_testSpec); } bool TestSpecParser::visitChar( char c ) { if( (m_mode != EscapedName) && (c == '\\') ) { escape(); addCharToPattern(c); return true; }else if((m_mode != EscapedName) && (c == ',') ) { return separate(); }
switch( m_mode ) { case None: if( processNoneChar( c ) ) return true; break; case Name: processNameChar( c ); break; case EscapedName: endMode(); addCharToPattern(c); return true; default: case Tag: case QuotedName: if( processOtherChar( c ) ) return true; break; }
m_substring += c; if( !isControlChar( c ) ) { m_patternName += c; m_realPatternPos++; } return true; } // Two of the processing methods return true to signal the caller to return // without adding the given character to the current pattern strings bool TestSpecParser::processNoneChar( char c ) { switch( c ) { case ' ': return true; case '~': m_exclusion = true; return false; case '[': startNewMode( Tag ); return false; case '"': startNewMode( QuotedName ); return false; default: startNewMode( Name ); return false; } } void TestSpecParser::processNameChar( char c ) { if( c == '[' ) { if( m_substring == "exclude:" ) m_exclusion = true; else endMode(); startNewMode( Tag ); } } bool TestSpecParser::processOtherChar( char c ) { if( !isControlChar( c ) ) return false; m_substring += c; endMode(); return true; } void TestSpecParser::startNewMode( Mode mode ) { m_mode = mode; } void TestSpecParser::endMode() { switch( m_mode ) { case Name: case QuotedName: return addNamePattern(); case Tag: return addTagPattern(); case EscapedName: revertBackToLastMode(); return; case None: default: return startNewMode( None ); } } void TestSpecParser::escape() { saveLastMode(); m_mode = EscapedName; m_escapeChars.push_back(m_realPatternPos); } bool TestSpecParser::isControlChar( char c ) const { switch( m_mode ) { default: return false; case None: return c == '~'; case Name: return c == '['; case EscapedName: return true; case QuotedName: return c == '"'; case Tag: return c == '[' || c == ']'; } }
void TestSpecParser::addFilter() { if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) { m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) ); m_currentFilter = TestSpec::Filter(); } }
void TestSpecParser::saveLastMode() { lastMode = m_mode; }
void TestSpecParser::revertBackToLastMode() { m_mode = lastMode; }
bool TestSpecParser::separate() { if( (m_mode==QuotedName) || (m_mode==Tag) ){ //invalid argument, signal failure to previous scope. m_mode = None; m_pos = m_arg.size(); m_substring.clear(); m_patternName.clear(); m_realPatternPos = 0; return false; } endMode(); addFilter(); return true; //success }
std::string TestSpecParser::preprocessPattern() { std::string token = m_patternName; for (std::size_t i = 0; i < m_escapeChars.size(); ++i) token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1); m_escapeChars.clear(); if (startsWith(token, "exclude:")) { m_exclusion = true; token = token.substr(8); }
m_patternName.clear(); m_realPatternPos = 0;
return token; }
void TestSpecParser::addNamePattern() { auto token = preprocessPattern();
if (!token.empty()) { if (m_exclusion) { m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring)); } else { m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring)); } } m_substring.clear(); m_exclusion = false; m_mode = None; }
void TestSpecParser::addTagPattern() { auto token = preprocessPattern();
if (!token.empty()) { // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo]) // we have to create a separate hide tag and shorten the real one if (token.size() > 1 && token[0] == '.') { token.erase(token.begin()); if (m_exclusion) { m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring)); } else { m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring)); } } if (m_exclusion) { m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring)); } else { m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring)); } } m_substring.clear(); m_exclusion = false; m_mode = None; }
} // namespace Catch
#include <algorithm>#include <cstring>#include <ostream>
namespace { bool isWhitespace( char c ) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }
bool isBreakableBefore( char c ) { static const char chars[] = "[({<|"; return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr; }
bool isBreakableAfter( char c ) { static const char chars[] = "])}>.,:;*+-=&/\\"; return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr; }
} // namespace
namespace Catch { namespace TextFlow { void AnsiSkippingString::preprocessString() { for ( auto it = m_string.begin(); it != m_string.end(); ) { // try to read through an ansi sequence while ( it != m_string.end() && *it == '\033' && it + 1 != m_string.end() && *( it + 1 ) == '[' ) { auto cursor = it + 2; while ( cursor != m_string.end() && ( isdigit( *cursor ) || *cursor == ';' ) ) { ++cursor; } if ( cursor == m_string.end() || *cursor != 'm' ) { break; } // 'm' -> 0xff *cursor = AnsiSkippingString::sentinel; // if we've read an ansi sequence, set the iterator and // return to the top of the loop it = cursor + 1; } if ( it != m_string.end() ) { ++m_size; ++it; } } }
AnsiSkippingString::AnsiSkippingString( std::string const& text ): m_string( text ) { preprocessString(); }
AnsiSkippingString::AnsiSkippingString( std::string&& text ): m_string( CATCH_MOVE( text ) ) { preprocessString(); }
AnsiSkippingString::const_iterator AnsiSkippingString::begin() const { return const_iterator( m_string ); }
AnsiSkippingString::const_iterator AnsiSkippingString::end() const { return const_iterator( m_string, const_iterator::EndTag{} ); }
std::string AnsiSkippingString::substring( const_iterator begin, const_iterator end ) const { // There's one caveat here to an otherwise simple substring: when // making a begin iterator we might have skipped ansi sequences at // the start. If `begin` here is a begin iterator, skipped over // initial ansi sequences, we'll use the true beginning of the // string. Lastly: We need to transform any chars we replaced with // 0xff back to 'm' auto str = std::string( begin == this->begin() ? m_string.begin() : begin.m_it, end.m_it ); std::transform( str.begin(), str.end(), str.begin(), []( char c ) { return c == AnsiSkippingString::sentinel ? 'm' : c; } ); return str; }
void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() { // check if we've landed on an ansi sequence, and if so read through // it while ( m_it != m_string->end() && *m_it == '\033' && m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) { auto cursor = m_it + 2; while ( cursor != m_string->end() && ( isdigit( *cursor ) || *cursor == ';' ) ) { ++cursor; } if ( cursor == m_string->end() || *cursor != AnsiSkippingString::sentinel ) { break; } // if we've read an ansi sequence, set the iterator and // return to the top of the loop m_it = cursor + 1; } }
void AnsiSkippingString::const_iterator::advance() { assert( m_it != m_string->end() ); m_it++; tryParseAnsiEscapes(); }
void AnsiSkippingString::const_iterator::unadvance() { assert( m_it != m_string->begin() ); m_it--; // if *m_it is 0xff, scan back to the \033 and then m_it-- once more // (and repeat check) while ( *m_it == AnsiSkippingString::sentinel ) { while ( *m_it != '\033' ) { assert( m_it != m_string->begin() ); m_it--; } // if this happens, we must have been a begin iterator that had // skipped over ansi sequences at the start of a string assert( m_it != m_string->begin() ); assert( *m_it == '\033' ); m_it--; } }
static bool isBoundary( AnsiSkippingString const& line, AnsiSkippingString::const_iterator it ) { return it == line.end() || ( isWhitespace( *it ) && !isWhitespace( *it.oneBefore() ) ) || isBreakableBefore( *it ) || isBreakableAfter( *it.oneBefore() ); }
void Column::const_iterator::calcLength() { m_addHyphen = false; m_parsedTo = m_lineStart; AnsiSkippingString const& current_line = m_column.m_string;
if ( m_parsedTo == current_line.end() ) { m_lineEnd = m_parsedTo; return; }
assert( m_lineStart != current_line.end() ); if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
const auto maxLineLength = m_column.m_width - indentSize(); std::size_t lineLength = 0; while ( m_parsedTo != current_line.end() && lineLength < maxLineLength && *m_parsedTo != '\n' ) { ++m_parsedTo; ++lineLength; }
// If we encountered a newline before the column is filled, // then we linebreak at the newline and consider this line // finished. if ( lineLength < maxLineLength ) { m_lineEnd = m_parsedTo; } else { // Look for a natural linebreak boundary in the column // (We look from the end, so that the first found boundary is // the right one) m_lineEnd = m_parsedTo; while ( lineLength > 0 && !isBoundary( current_line, m_lineEnd ) ) { --lineLength; --m_lineEnd; } while ( lineLength > 0 && isWhitespace( *m_lineEnd.oneBefore() ) ) { --lineLength; --m_lineEnd; }
// If we found one, then that is where we linebreak, otherwise // we have to split text with a hyphen if ( lineLength == 0 ) { m_addHyphen = true; m_lineEnd = m_parsedTo.oneBefore(); } } }
size_t Column::const_iterator::indentSize() const { auto initial = m_lineStart == m_column.m_string.begin() ? m_column.m_initialIndent : std::string::npos; return initial == std::string::npos ? m_column.m_indent : initial; }
std::string Column::const_iterator::addIndentAndSuffix( AnsiSkippingString::const_iterator start, AnsiSkippingString::const_iterator end ) const { std::string ret; const auto desired_indent = indentSize(); // ret.reserve( desired_indent + (end - start) + m_addHyphen ); ret.append( desired_indent, ' ' ); // ret.append( start, end ); ret += m_column.m_string.substring( start, end ); if ( m_addHyphen ) { ret.push_back( '-' ); }
return ret; }
Column::const_iterator::const_iterator( Column const& column ): m_column( column ), m_lineStart( column.m_string.begin() ), m_lineEnd( column.m_string.begin() ), m_parsedTo( column.m_string.begin() ) { assert( m_column.m_width > m_column.m_indent ); assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent ); calcLength(); if ( m_lineStart == m_lineEnd ) { m_lineStart = m_column.m_string.end(); } }
std::string Column::const_iterator::operator*() const { assert( m_lineStart <= m_parsedTo ); return addIndentAndSuffix( m_lineStart, m_lineEnd ); }
Column::const_iterator& Column::const_iterator::operator++() { m_lineStart = m_lineEnd; AnsiSkippingString const& current_line = m_column.m_string; if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) { m_lineStart++; } else { while ( m_lineStart != current_line.end() && isWhitespace( *m_lineStart ) ) { ++m_lineStart; } }
if ( m_lineStart != current_line.end() ) { calcLength(); } return *this; }
Column::const_iterator Column::const_iterator::operator++( int ) { const_iterator prev( *this ); operator++(); return prev; }
std::ostream& operator<<( std::ostream& os, Column const& col ) { bool first = true; for ( auto line : col ) { if ( first ) { first = false; } else { os << '\n'; } os << line; } return os; }
Column Spacer( size_t spaceWidth ) { Column ret{ "" }; ret.width( spaceWidth ); return ret; }
Columns::iterator::iterator( Columns const& columns, EndTag ): m_columns( columns.m_columns ), m_activeIterators( 0 ) {
m_iterators.reserve( m_columns.size() ); for ( auto const& col : m_columns ) { m_iterators.push_back( col.end() ); } }
Columns::iterator::iterator( Columns const& columns ): m_columns( columns.m_columns ), m_activeIterators( m_columns.size() ) {
m_iterators.reserve( m_columns.size() ); for ( auto const& col : m_columns ) { m_iterators.push_back( col.begin() ); } }
std::string Columns::iterator::operator*() const { std::string row, padding;
for ( size_t i = 0; i < m_columns.size(); ++i ) { const auto width = m_columns[i].width(); if ( m_iterators[i] != m_columns[i].end() ) { std::string col = *m_iterators[i]; row += padding; row += col;
padding.clear(); if ( col.size() < width ) { padding.append( width - col.size(), ' ' ); } } else { padding.append( width, ' ' ); } } return row; }
Columns::iterator& Columns::iterator::operator++() { for ( size_t i = 0; i < m_columns.size(); ++i ) { if ( m_iterators[i] != m_columns[i].end() ) { ++m_iterators[i]; } } return *this; }
Columns::iterator Columns::iterator::operator++( int ) { iterator prev( *this ); operator++(); return prev; }
std::ostream& operator<<( std::ostream& os, Columns const& cols ) { bool first = true; for ( auto line : cols ) { if ( first ) { first = false; } else { os << '\n'; } os << line; } return os; }
Columns operator+( Column const& lhs, Column const& rhs ) { Columns cols; cols += lhs; cols += rhs; return cols; } Columns operator+( Column&& lhs, Column&& rhs ) { Columns cols; cols += CATCH_MOVE( lhs ); cols += CATCH_MOVE( rhs ); return cols; }
Columns& operator+=( Columns& lhs, Column const& rhs ) { lhs.m_columns.push_back( rhs ); return lhs; } Columns& operator+=( Columns& lhs, Column&& rhs ) { lhs.m_columns.push_back( CATCH_MOVE( rhs ) ); return lhs; } Columns operator+( Columns const& lhs, Column const& rhs ) { auto combined( lhs ); combined += rhs; return combined; } Columns operator+( Columns&& lhs, Column&& rhs ) { lhs += CATCH_MOVE( rhs ); return CATCH_MOVE( lhs ); }
} // namespace TextFlow} // namespace Catch
#include <exception>
namespace Catch { bool uncaught_exceptions() {#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) return false;#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) return std::uncaught_exceptions() > 0;#else return std::uncaught_exception();#endif }} // end namespace Catch
namespace Catch {
WildcardPattern::WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity ) : m_caseSensitivity( caseSensitivity ), m_pattern( normaliseString( pattern ) ) { if( startsWith( m_pattern, '*' ) ) { m_pattern = m_pattern.substr( 1 ); m_wildcard = WildcardAtStart; } if( endsWith( m_pattern, '*' ) ) { m_pattern = m_pattern.substr( 0, m_pattern.size()-1 ); m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd ); } }
bool WildcardPattern::matches( std::string const& str ) const { switch( m_wildcard ) { case NoWildcard: return m_pattern == normaliseString( str ); case WildcardAtStart: return endsWith( normaliseString( str ), m_pattern ); case WildcardAtEnd: return startsWith( normaliseString( str ), m_pattern ); case WildcardAtBothEnds: return contains( normaliseString( str ), m_pattern ); default: CATCH_INTERNAL_ERROR( "Unknown enum" ); } }
std::string WildcardPattern::normaliseString( std::string const& str ) const { return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str ); }}
// Note: swapping these two includes around causes MSVC to error out// while in /permissive- mode. No, I don't know why.// Tested on VS 2019, 18.{3, 4}.x
#include <cstdint>#include <iomanip>#include <type_traits>
namespace Catch {
namespace {
size_t trailingBytes(unsigned char c) { if ((c & 0xE0) == 0xC0) { return 2; } if ((c & 0xF0) == 0xE0) { return 3; } if ((c & 0xF8) == 0xF0) { return 4; } CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); }
uint32_t headerValue(unsigned char c) { if ((c & 0xE0) == 0xC0) { return c & 0x1F; } if ((c & 0xF0) == 0xE0) { return c & 0x0F; } if ((c & 0xF8) == 0xF0) { return c & 0x07; } CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); }
void hexEscapeChar(std::ostream& os, unsigned char c) { std::ios_base::fmtflags f(os.flags()); os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(c); os.flags(f); }
bool shouldNewline(XmlFormatting fmt) { return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline)); }
bool shouldIndent(XmlFormatting fmt) { return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent)); }
} // anonymous namespace
XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) { return static_cast<XmlFormatting>( static_cast<std::underlying_type_t<XmlFormatting>>(lhs) | static_cast<std::underlying_type_t<XmlFormatting>>(rhs) ); }
XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) { return static_cast<XmlFormatting>( static_cast<std::underlying_type_t<XmlFormatting>>(lhs) & static_cast<std::underlying_type_t<XmlFormatting>>(rhs) ); }
XmlEncode::XmlEncode( StringRef str, ForWhat forWhat ) : m_str( str ), m_forWhat( forWhat ) {}
void XmlEncode::encodeTo( std::ostream& os ) const { // Apostrophe escaping not necessary if we always use " to write attributes // (see: http://www.w3.org/TR/xml/#syntax)
for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) { unsigned char c = static_cast<unsigned char>(m_str[idx]); switch (c) { case '<': os << "<"; break; case '&': os << "&"; break;
case '>': // See: http://www.w3.org/TR/xml/#syntax if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']') os << ">"; else os << c; break;
case '\"': if (m_forWhat == ForAttributes) os << """; else os << c; break;
default: // Check for control characters and invalid utf-8
// Escape control characters in standard ascii // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0 if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) { hexEscapeChar(os, c); break; }
// Plain ASCII: Write it to stream if (c < 0x7F) { os << c; break; }
// UTF-8 territory // Check if the encoding is valid and if it is not, hex escape bytes. // Important: We do not check the exact decoded values for validity, only the encoding format // First check that this bytes is a valid lead byte: // This means that it is not encoded as 1111 1XXX // Or as 10XX XXXX if (c < 0xC0 || c >= 0xF8) { hexEscapeChar(os, c); break; }
auto encBytes = trailingBytes(c); // Are there enough bytes left to avoid accessing out-of-bounds memory? if (idx + encBytes - 1 >= m_str.size()) { hexEscapeChar(os, c); break; } // The header is valid, check data // The next encBytes bytes must together be a valid utf-8 // This means: bitpattern 10XX XXXX and the extracted value is sane (ish) bool valid = true; uint32_t value = headerValue(c); for (std::size_t n = 1; n < encBytes; ++n) { unsigned char nc = static_cast<unsigned char>(m_str[idx + n]); valid &= ((nc & 0xC0) == 0x80); value = (value << 6) | (nc & 0x3F); }
if ( // Wrong bit pattern of following bytes (!valid) || // Overlong encodings (value < 0x80) || (0x80 <= value && value < 0x800 && encBytes > 2) || (0x800 < value && value < 0x10000 && encBytes > 3) || // Encoded value out of range (value >= 0x110000) ) { hexEscapeChar(os, c); break; }
// If we got here, this is in fact a valid(ish) utf-8 sequence for (std::size_t n = 0; n < encBytes; ++n) { os << m_str[idx + n]; } idx += encBytes - 1; break; } } }
std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { xmlEncode.encodeTo( os ); return os; }
XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt ) : m_writer( writer ), m_fmt(fmt) {}
XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept : m_writer( other.m_writer ), m_fmt(other.m_fmt) { other.m_writer = nullptr; other.m_fmt = XmlFormatting::None; } XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept { if ( m_writer ) { m_writer->endElement(); } m_writer = other.m_writer; other.m_writer = nullptr; m_fmt = other.m_fmt; other.m_fmt = XmlFormatting::None; return *this; }
XmlWriter::ScopedElement::~ScopedElement() { if (m_writer) { m_writer->endElement(m_fmt); } }
XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) { m_writer->writeText( text, fmt ); return *this; }
XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeAttribute( StringRef name, StringRef attribute ) { m_writer->writeAttribute( name, attribute ); return *this; }
XmlWriter::XmlWriter( std::ostream& os ) : m_os( os ) { writeDeclaration(); }
XmlWriter::~XmlWriter() { while (!m_tags.empty()) { endElement(); } newlineIfNecessary(); }
XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) { ensureTagClosed(); newlineIfNecessary(); if (shouldIndent(fmt)) { m_os << m_indent; m_indent += " "; } m_os << '<' << name; m_tags.push_back( name ); m_tagIsOpen = true; applyFormatting(fmt); return *this; }
XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) { ScopedElement scoped( this, fmt ); startElement( name, fmt ); return scoped; }
XmlWriter& XmlWriter::endElement(XmlFormatting fmt) { m_indent = m_indent.substr(0, m_indent.size() - 2);
if( m_tagIsOpen ) { m_os << "/>"; m_tagIsOpen = false; } else { newlineIfNecessary(); if (shouldIndent(fmt)) { m_os << m_indent; } m_os << "</" << m_tags.back() << '>'; } m_os << std::flush; applyFormatting(fmt); m_tags.pop_back(); return *this; }
XmlWriter& XmlWriter::writeAttribute( StringRef name, StringRef attribute ) { if( !name.empty() && !attribute.empty() ) m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; return *this; }
XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) { writeAttribute(name, (attribute ? "true"_sr : "false"_sr)); return *this; }
XmlWriter& XmlWriter::writeAttribute( StringRef name, char const* attribute ) { writeAttribute( name, StringRef( attribute ) ); return *this; }
XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) { CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element"); if( !text.empty() ){ bool tagWasOpen = m_tagIsOpen; ensureTagClosed(); if (tagWasOpen && shouldIndent(fmt)) { m_os << m_indent; } m_os << XmlEncode( text, XmlEncode::ForTextNodes ); applyFormatting(fmt); } return *this; }
XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) { ensureTagClosed(); if (shouldIndent(fmt)) { m_os << m_indent; } m_os << "<!-- " << text << " -->"; applyFormatting(fmt); return *this; }
void XmlWriter::writeStylesheetRef( StringRef url ) { m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n'; }
void XmlWriter::ensureTagClosed() { if( m_tagIsOpen ) { m_os << '>' << std::flush; newlineIfNecessary(); m_tagIsOpen = false; } }
void XmlWriter::applyFormatting(XmlFormatting fmt) { m_needsNewline = shouldNewline(fmt); }
void XmlWriter::writeDeclaration() { m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n'; }
void XmlWriter::newlineIfNecessary() { if( m_needsNewline ) { m_os << '\n' << std::flush; m_needsNewline = false; } }}
namespace Catch {namespace Matchers {
std::string MatcherUntypedBase::toString() const { if (m_cachedToString.empty()) { m_cachedToString = describe(); } return m_cachedToString; }
MatcherUntypedBase::~MatcherUntypedBase() = default;
} // namespace Matchers} // namespace Catch
namespace Catch {namespace Matchers {
std::string IsEmptyMatcher::describe() const { return "is empty"; }
std::string HasSizeMatcher::describe() const { ReusableStringStream sstr; sstr << "has size == " << m_target_size; return sstr.str(); }
IsEmptyMatcher IsEmpty() { return {}; }
HasSizeMatcher SizeIs(std::size_t sz) { return HasSizeMatcher{ sz }; }
} // end namespace Matchers} // end namespace Catch
namespace Catch {namespace Matchers {
bool ExceptionMessageMatcher::match(std::exception const& ex) const { return ex.what() == m_message;}
std::string ExceptionMessageMatcher::describe() const { return "exception message matches \"" + m_message + '"';}
ExceptionMessageMatcher Message(std::string const& message) { return ExceptionMessageMatcher(message);}
} // namespace Matchers} // namespace Catch
#include <algorithm>#include <cmath>#include <cstdlib>#include <cstdint>#include <sstream>#include <iomanip>#include <limits>
namespace Catch {namespace {
template <typename FP> bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) { // Comparison with NaN should always be false. // This way we can rule it out before getting into the ugly details if (Catch::isnan(lhs) || Catch::isnan(rhs)) { return false; }
// This should also handle positive and negative zeros, infinities const auto ulpDist = ulpDistance(lhs, rhs);
return ulpDist <= maxUlpDiff; }
template <typename FP>FP step(FP start, FP direction, uint64_t steps) { for (uint64_t i = 0; i < steps; ++i) { start = Catch::nextafter(start, direction); } return start;}
// Performs equivalent check of std::fabs(lhs - rhs) <= margin// But without the subtraction to allow for INFINITY in comparisonbool marginComparison(double lhs, double rhs, double margin) { return (lhs + margin >= rhs) && (rhs + margin >= lhs);}
template <typename FloatingPoint>void write(std::ostream& out, FloatingPoint num) { out << std::scientific << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1) << num;}
} // end anonymous namespace
namespace Matchers {namespace Detail {
enum class FloatingPointKind : uint8_t { Float, Double };
} // end namespace Detail
WithinAbsMatcher::WithinAbsMatcher(double target, double margin) :m_target{ target }, m_margin{ margin } { CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.' << " Margin has to be non-negative."); }
// Performs equivalent check of std::fabs(lhs - rhs) <= margin // But without the subtraction to allow for INFINITY in comparison bool WithinAbsMatcher::match(double const& matchee) const { return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee); }
std::string WithinAbsMatcher::describe() const { return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target); }
WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType) :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } { CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double || m_ulps < (std::numeric_limits<uint32_t>::max)(), "Provided ULP is impossibly large for a float comparison."); CATCH_ENFORCE( std::numeric_limits<double>::is_iec559, "WithinUlp matcher only supports platforms with " "IEEE-754 compatible floating point representation" ); }
#if defined(__clang__)#pragma clang diagnostic push// Clang <3.5 reports on the default branch in the switch below#pragma clang diagnostic ignored "-Wunreachable-code"#endif
bool WithinUlpsMatcher::match(double const& matchee) const { switch (m_type) { case Detail::FloatingPointKind::Float: return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps); case Detail::FloatingPointKind::Double: return almostEqualUlps<double>(matchee, m_target, m_ulps); default: CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" ); } }
#if defined(__clang__)#pragma clang diagnostic pop#endif
std::string WithinUlpsMatcher::describe() const { std::stringstream ret;
ret << "is within " << m_ulps << " ULPs of ";
if (m_type == Detail::FloatingPointKind::Float) { write(ret, static_cast<float>(m_target)); ret << 'f'; } else { write(ret, m_target); }
ret << " (["; if (m_type == Detail::FloatingPointKind::Double) { write( ret, step( m_target, -std::numeric_limits<double>::infinity(), m_ulps ) ); ret << ", "; write( ret, step( m_target, std::numeric_limits<double>::infinity(), m_ulps ) ); } else { // We have to cast INFINITY to float because of MinGW, see #1782 write( ret, step( static_cast<float>( m_target ), -std::numeric_limits<float>::infinity(), m_ulps ) ); ret << ", "; write( ret, step( static_cast<float>( m_target ), std::numeric_limits<float>::infinity(), m_ulps ) ); } ret << "])";
return ret.str(); }
WithinRelMatcher::WithinRelMatcher(double target, double epsilon): m_target(target), m_epsilon(epsilon){ CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense."); CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense."); }
bool WithinRelMatcher::match(double const& matchee) const { const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target)); return marginComparison(matchee, m_target, std::isinf(relMargin)? 0 : relMargin); }
std::string WithinRelMatcher::describe() const { Catch::ReusableStringStream sstr; sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other"; return sstr.str(); }
WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) { return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);}
WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) { return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);}
WithinAbsMatcher WithinAbs(double target, double margin) { return WithinAbsMatcher(target, margin);}
WithinRelMatcher WithinRel(double target, double eps) { return WithinRelMatcher(target, eps);}
WithinRelMatcher WithinRel(double target) { return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);}
WithinRelMatcher WithinRel(float target, float eps) { return WithinRelMatcher(target, eps);}
WithinRelMatcher WithinRel(float target) { return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);}
bool IsNaNMatcher::match( double const& matchee ) const { return std::isnan( matchee );}
std::string IsNaNMatcher::describe() const { using namespace std::string_literals; return "is NaN"s;}
IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
} // namespace Matchers} // namespace Catch
std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) { if (desc.empty()) { return "matches undescribed predicate"; } else { return "matches predicate: \"" + desc + '"'; }}
namespace Catch { namespace Matchers { std::string AllTrueMatcher::describe() const { return "contains only true"; }
AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
std::string NoneTrueMatcher::describe() const { return "contains no true"; }
NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; } } // namespace Matchers} // namespace Catch
#include <regex>
namespace Catch {namespace Matchers {
CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity ) : m_caseSensitivity( caseSensitivity ), m_str( adjustString( str ) ) {} std::string CasedString::adjustString( std::string const& str ) const { return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str; } StringRef CasedString::caseSensitivitySuffix() const { return m_caseSensitivity == CaseSensitive::Yes ? StringRef() : " (case insensitive)"_sr; }
StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator ) : m_comparator( comparator ), m_operation( operation ) { }
std::string StringMatcherBase::describe() const { std::string description; description.reserve(5 + m_operation.size() + m_comparator.m_str.size() + m_comparator.caseSensitivitySuffix().size()); description += m_operation; description += ": \""; description += m_comparator.m_str; description += '"'; description += m_comparator.caseSensitivitySuffix(); return description; }
StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
bool StringEqualsMatcher::match( std::string const& source ) const { return m_comparator.adjustString( source ) == m_comparator.m_str; }
StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
bool StringContainsMatcher::match( std::string const& source ) const { return contains( m_comparator.adjustString( source ), m_comparator.m_str ); }
StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
bool StartsWithMatcher::match( std::string const& source ) const { return startsWith( m_comparator.adjustString( source ), m_comparator.m_str ); }
EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
bool EndsWithMatcher::match( std::string const& source ) const { return endsWith( m_comparator.adjustString( source ), m_comparator.m_str ); }
RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
bool RegexMatcher::match(std::string const& matchee) const { auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway if (m_caseSensitivity == CaseSensitive::No) { flags |= std::regex::icase; } auto reg = std::regex(m_regex, flags); return std::regex_match(matchee, reg); }
std::string RegexMatcher::describe() const { return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively"); }
StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) { return StringEqualsMatcher( CasedString( str, caseSensitivity) ); } StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) { return StringContainsMatcher( CasedString( str, caseSensitivity) ); } EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) { return EndsWithMatcher( CasedString( str, caseSensitivity) ); } StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) { return StartsWithMatcher( CasedString( str, caseSensitivity) ); }
RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) { return RegexMatcher(regex, caseSensitivity); }
} // namespace Matchers} // namespace Catch
namespace Catch {namespace Matchers { MatcherGenericBase::~MatcherGenericBase() = default;
namespace Detail {
std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) { std::string description; std::size_t combined_size = 4; for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) { combined_size += desc->size(); } combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
description.reserve(combined_size);
description += "( "; bool first = true; for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) { if( first ) first = false; else description += combine; description += *desc; } description += " )"; return description; }
} // namespace Detail} // namespace Matchers} // namespace Catch
namespace Catch {
// This is the general overload that takes a any string matcher // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers // the Equals matcher (so the header does not mention matchers) void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) { std::string exceptionMessage = Catch::translateActiveException(); MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher ); handler.handleExpr( expr ); }
} // namespace Catch
#include <ostream>
namespace Catch {
AutomakeReporter::~AutomakeReporter() = default;
void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) { // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR. m_stream << ":test-result: "; if ( _testCaseStats.totals.testCases.skipped > 0 ) { m_stream << "SKIP"; } else if (_testCaseStats.totals.assertions.allPassed()) { m_stream << "PASS"; } else if (_testCaseStats.totals.assertions.allOk()) { m_stream << "XFAIL"; } else { m_stream << "FAIL"; } m_stream << ' ' << _testCaseStats.testInfo->name << '\n'; StreamingReporterBase::testCaseEnded(_testCaseStats); }
void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) { m_stream << ":test-result: SKIP " << testInfo.name << '\n'; }
} // end namespace Catch
namespace Catch { ReporterBase::ReporterBase( ReporterConfig&& config ): IEventListener( config.fullConfig() ), m_wrapped_stream( CATCH_MOVE(config).takeStream() ), m_stream( m_wrapped_stream->stream() ), m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ), m_customOptions( config.customOptions() ) {}
ReporterBase::~ReporterBase() = default;
void ReporterBase::listReporters( std::vector<ReporterDescription> const& descriptions ) { defaultListReporters(m_stream, descriptions, m_config->verbosity()); }
void ReporterBase::listListeners( std::vector<ListenerDescription> const& descriptions ) { defaultListListeners( m_stream, descriptions ); }
void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) { defaultListTests(m_stream, m_colour.get(), tests, m_config->hasTestFilters(), m_config->verbosity()); }
void ReporterBase::listTags(std::vector<TagInfo> const& tags) { defaultListTags( m_stream, tags, m_config->hasTestFilters() ); }
} // namespace Catch
#include <ostream>
namespace Catch {namespace {
// Colour::LightGrey static constexpr Colour::Code compactDimColour = Colour::FileName;
#ifdef CATCH_PLATFORM_MAC static constexpr Catch::StringRef compactFailedString = "FAILED"_sr; static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;#else static constexpr Catch::StringRef compactFailedString = "failed"_sr; static constexpr Catch::StringRef compactPassedString = "passed"_sr;#endif
// Implementation of CompactReporter formattingclass AssertionPrinter {public: AssertionPrinter& operator= (AssertionPrinter const&) = delete; AssertionPrinter(AssertionPrinter const&) = delete; AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_) : stream(_stream) , result(_stats.assertionResult) , messages(_stats.infoMessages) , itMessage(_stats.infoMessages.begin()) , printInfoMessages(_printInfoMessages) , colourImpl(colourImpl_) {}
void print() { printSourceInfo();
itMessage = messages.begin();
switch (result.getResultType()) { case ResultWas::Ok: printResultType(Colour::ResultSuccess, compactPassedString); printOriginalExpression(); printReconstructedExpression(); if (!result.hasExpression()) printRemainingMessages(Colour::None); else printRemainingMessages(); break; case ResultWas::ExpressionFailed: if (result.isOk()) printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr); else printResultType(Colour::Error, compactFailedString); printOriginalExpression(); printReconstructedExpression(); printRemainingMessages(); break; case ResultWas::ThrewException: printResultType(Colour::Error, compactFailedString); printIssue("unexpected exception with message:"); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::FatalErrorCondition: printResultType(Colour::Error, compactFailedString); printIssue("fatal error condition with message:"); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::DidntThrowException: printResultType(Colour::Error, compactFailedString); printIssue("expected exception, got none"); printExpressionWas(); printRemainingMessages(); break; case ResultWas::Info: printResultType(Colour::None, "info"_sr); printMessage(); printRemainingMessages(); break; case ResultWas::Warning: printResultType(Colour::None, "warning"_sr); printMessage(); printRemainingMessages(); break; case ResultWas::ExplicitFailure: printResultType(Colour::Error, compactFailedString); printIssue("explicitly"); printRemainingMessages(Colour::None); break; case ResultWas::ExplicitSkip: printResultType(Colour::Skip, "skipped"_sr); printMessage(); printRemainingMessages(); break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: printResultType(Colour::Error, "** internal error **"); break; } }
private: void printSourceInfo() const { stream << colourImpl->guardColour( Colour::FileName ) << result.getSourceInfo() << ':'; }
void printResultType(Colour::Code colour, StringRef passOrFail) const { if (!passOrFail.empty()) { stream << colourImpl->guardColour(colour) << ' ' << passOrFail; stream << ':'; } }
void printIssue(char const* issue) const { stream << ' ' << issue; }
void printExpressionWas() { if (result.hasExpression()) { stream << ';'; { stream << colourImpl->guardColour(compactDimColour) << " expression was:"; } printOriginalExpression(); } }
void printOriginalExpression() const { if (result.hasExpression()) { stream << ' ' << result.getExpression(); } }
void printReconstructedExpression() const { if (result.hasExpandedExpression()) { stream << colourImpl->guardColour(compactDimColour) << " for: "; stream << result.getExpandedExpression(); } }
void printMessage() { if (itMessage != messages.end()) { stream << " '" << itMessage->message << '\''; ++itMessage; } }
void printRemainingMessages(Colour::Code colour = compactDimColour) { if (itMessage == messages.end()) return;
const auto itEnd = messages.cend(); const auto N = static_cast<std::size_t>(itEnd - itMessage);
stream << colourImpl->guardColour( colour ) << " with " << pluralise( N, "message"_sr ) << ':';
while (itMessage != itEnd) { // If this assertion is a warning ignore any INFO messages if (printInfoMessages || itMessage->type != ResultWas::Info) { printMessage(); if (itMessage != itEnd) { stream << colourImpl->guardColour(compactDimColour) << " and"; } continue; } ++itMessage; } }
private: std::ostream& stream; AssertionResult const& result; std::vector<MessageInfo> const& messages; std::vector<MessageInfo>::const_iterator itMessage; bool printInfoMessages; ColourImpl* colourImpl;};
} // anon namespace
std::string CompactReporter::getDescription() { return "Reports test results on a single line, suitable for IDEs"; }
void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) { m_stream << "No test cases matched '" << unmatchedSpec << "'\n"; }
void CompactReporter::testRunStarting( TestRunInfo const& ) { if ( m_config->testSpec().hasFilters() ) { m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: " << m_config->testSpec() << '\n'; } m_stream << "RNG seed: " << getSeed() << '\n'; }
void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) { AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those if( !m_config->includeSuccessfulResults() && result.isOk() ) { if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip ) return; printInfoMessages = false; }
AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() ); printer.print();
m_stream << '\n' << std::flush; }
void CompactReporter::sectionEnded(SectionStats const& _sectionStats) { double dur = _sectionStats.durationInSeconds; if ( shouldShowDuration( *m_config, dur ) ) { m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush; } }
void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) { printTestRunTotals( m_stream, *m_colour, _testRunStats.totals ); m_stream << "\n\n" << std::flush; StreamingReporterBase::testRunEnded( _testRunStats ); }
CompactReporter::~CompactReporter() = default;
} // end namespace Catch
#include <cstdio>
#if defined(_MSC_VER)#pragma warning(push)#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch // Note that 4062 (not all labels are handled and default is missing) is enabled#endif
#if defined(__clang__)# pragma clang diagnostic push// For simplicity, benchmarking-only helpers are always enabled# pragma clang diagnostic ignored "-Wunused-function"#endif
namespace Catch {
namespace {
// Formatter impl for ConsoleReporterclass ConsoleAssertionPrinter {public: ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete; ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete; ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages) : stream(_stream), stats(_stats), result(_stats.assertionResult), colour(Colour::None), messages(_stats.infoMessages), colourImpl(colourImpl_), printInfoMessages(_printInfoMessages) { switch (result.getResultType()) { case ResultWas::Ok: colour = Colour::Success; passOrFail = "PASSED"_sr; //if( result.hasMessage() ) if (messages.size() == 1) messageLabel = "with message"_sr; if (messages.size() > 1) messageLabel = "with messages"_sr; break; case ResultWas::ExpressionFailed: if (result.isOk()) { colour = Colour::Success; passOrFail = "FAILED - but was ok"_sr; } else { colour = Colour::Error; passOrFail = "FAILED"_sr; } if (messages.size() == 1) messageLabel = "with message"_sr; if (messages.size() > 1) messageLabel = "with messages"_sr; break; case ResultWas::ThrewException: colour = Colour::Error; passOrFail = "FAILED"_sr; // todo switch switch (messages.size()) { case 0: messageLabel = "due to unexpected exception with "_sr; break; case 1: messageLabel = "due to unexpected exception with message"_sr; break; default: messageLabel = "due to unexpected exception with messages"_sr; break; } break; case ResultWas::FatalErrorCondition: colour = Colour::Error; passOrFail = "FAILED"_sr; messageLabel = "due to a fatal error condition"_sr; break; case ResultWas::DidntThrowException: colour = Colour::Error; passOrFail = "FAILED"_sr; messageLabel = "because no exception was thrown where one was expected"_sr; break; case ResultWas::Info: messageLabel = "info"_sr; break; case ResultWas::Warning: messageLabel = "warning"_sr; break; case ResultWas::ExplicitFailure: passOrFail = "FAILED"_sr; colour = Colour::Error; if (messages.size() == 1) messageLabel = "explicitly with message"_sr; if (messages.size() > 1) messageLabel = "explicitly with messages"_sr; break; case ResultWas::ExplicitSkip: colour = Colour::Skip; passOrFail = "SKIPPED"_sr; if (messages.size() == 1) messageLabel = "explicitly with message"_sr; if (messages.size() > 1) messageLabel = "explicitly with messages"_sr; break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: passOrFail = "** internal error **"_sr; colour = Colour::Error; break; } }
void print() const { printSourceInfo(); if (stats.totals.assertions.total() > 0) { printResultType(); printOriginalExpression(); printReconstructedExpression(); } else { stream << '\n'; } printMessage(); }
private: void printResultType() const { if (!passOrFail.empty()) { stream << colourImpl->guardColour(colour) << passOrFail << ":\n"; } } void printOriginalExpression() const { if (result.hasExpression()) { stream << colourImpl->guardColour( Colour::OriginalExpression ) << " " << result.getExpressionInMacro() << '\n'; } } void printReconstructedExpression() const { if (result.hasExpandedExpression()) { stream << "with expansion:\n"; stream << colourImpl->guardColour( Colour::ReconstructedExpression ) << TextFlow::Column( result.getExpandedExpression() ) .indent( 2 ) << '\n'; } } void printMessage() const { if (!messageLabel.empty()) stream << messageLabel << ':' << '\n'; for (auto const& msg : messages) { // If this assertion is a warning ignore any INFO messages if (printInfoMessages || msg.type != ResultWas::Info) stream << TextFlow::Column(msg.message).indent(2) << '\n'; } } void printSourceInfo() const { stream << colourImpl->guardColour( Colour::FileName ) << result.getSourceInfo() << ": "; }
std::ostream& stream; AssertionStats const& stats; AssertionResult const& result; Colour::Code colour; StringRef passOrFail; StringRef messageLabel; std::vector<MessageInfo> const& messages; ColourImpl* colourImpl; bool printInfoMessages;};
std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) { const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0; return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);}
std::size_t&findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) { if (i > j && i > k && i > l) return i; else if (j > k && j > l) return j; else if (k > l) return k; else return l;}
struct ColumnBreak {};struct RowBreak {};struct OutputFlush {};
class Duration { enum class Unit { Auto, Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes }; static const uint64_t s_nanosecondsInAMicrosecond = 1000; static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond; static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond; static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
double m_inNanoseconds; Unit m_units;
public: explicit Duration(double inNanoseconds, Unit units = Unit::Auto) : m_inNanoseconds(inNanoseconds), m_units(units) { if (m_units == Unit::Auto) { if (m_inNanoseconds < s_nanosecondsInAMicrosecond) m_units = Unit::Nanoseconds; else if (m_inNanoseconds < s_nanosecondsInAMillisecond) m_units = Unit::Microseconds; else if (m_inNanoseconds < s_nanosecondsInASecond) m_units = Unit::Milliseconds; else if (m_inNanoseconds < s_nanosecondsInAMinute) m_units = Unit::Seconds; else m_units = Unit::Minutes; }
}
auto value() const -> double { switch (m_units) { case Unit::Microseconds: return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond); case Unit::Milliseconds: return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond); case Unit::Seconds: return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond); case Unit::Minutes: return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute); default: return m_inNanoseconds; } } StringRef unitsAsString() const { switch (m_units) { case Unit::Nanoseconds: return "ns"_sr; case Unit::Microseconds: return "us"_sr; case Unit::Milliseconds: return "ms"_sr; case Unit::Seconds: return "s"_sr; case Unit::Minutes: return "m"_sr; default: return "** internal error **"_sr; }
} friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& { return os << duration.value() << ' ' << duration.unitsAsString(); }};} // end anon namespace
enum class Justification { Left, Right };
struct ColumnInfo { std::string name; std::size_t width; Justification justification;};
class TablePrinter { std::ostream& m_os; std::vector<ColumnInfo> m_columnInfos; ReusableStringStream m_oss; int m_currentColumn = -1; bool m_isOpen = false;
public: TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos ) : m_os( os ), m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
auto columnInfos() const -> std::vector<ColumnInfo> const& { return m_columnInfos; }
void open() { if (!m_isOpen) { m_isOpen = true; *this << RowBreak();
TextFlow::Columns headerCols; for (auto const& info : m_columnInfos) { assert(info.width > 2); headerCols += TextFlow::Column(info.name).width(info.width - 2); headerCols += TextFlow::Spacer( 2 ); } m_os << headerCols << '\n';
m_os << lineOfChars('-') << '\n'; } } void close() { if (m_isOpen) { *this << RowBreak(); m_os << '\n' << std::flush; m_isOpen = false; } }
template<typename T> friend TablePrinter& operator<< (TablePrinter& tp, T const& value) { tp.m_oss << value; return tp; }
friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) { auto colStr = tp.m_oss.str(); const auto strSize = colStr.size(); tp.m_oss.str(""); tp.open(); if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) { tp.m_currentColumn = -1; tp.m_os << '\n'; } tp.m_currentColumn++;
auto colInfo = tp.m_columnInfos[tp.m_currentColumn]; auto padding = (strSize + 1 < colInfo.width) ? std::string(colInfo.width - (strSize + 1), ' ') : std::string(); if (colInfo.justification == Justification::Left) tp.m_os << colStr << padding << ' '; else tp.m_os << padding << colStr << ' '; return tp; }
friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) { if (tp.m_currentColumn > 0) { tp.m_os << '\n'; tp.m_currentColumn = -1; } return tp; }
friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) { tp.m_os << std::flush; return tp; }};
ConsoleReporter::ConsoleReporter(ReporterConfig&& config): StreamingReporterBase( CATCH_MOVE( config ) ), m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream, [&config]() -> std::vector<ColumnInfo> { if (config.fullConfig()->benchmarkNoAnalysis()) { return{ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left }, { " samples", 14, Justification::Right }, { " iterations", 14, Justification::Right }, { " mean", 14, Justification::Right } }; } else { return{ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left }, { "samples mean std dev", 14, Justification::Right }, { "iterations low mean low std dev", 14, Justification::Right }, { "est run time high mean high std dev", 14, Justification::Right } }; } }())) {}ConsoleReporter::~ConsoleReporter() = default;
std::string ConsoleReporter::getDescription() { return "Reports test results as plain lines of text";}
void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) { m_stream << "No test cases matched '" << unmatchedSpec << "'\n";}
void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) { m_stream << "Invalid Filter: " << arg << '\n';}
void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) { AssertionResult const& result = _assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them. // TODO: Make configurable whether skips should be printed if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip) return;
lazyPrint();
ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults); printer.print(); m_stream << '\n' << std::flush;}
void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) { m_tablePrinter->close(); m_headerPrinted = false; StreamingReporterBase::sectionStarting(_sectionInfo);}void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) { m_tablePrinter->close(); if (_sectionStats.missingAssertions) { lazyPrint(); auto guard = m_colour->guardColour( Colour::ResultError ).engage( m_stream ); if (m_sectionStack.size() > 1) m_stream << "\nNo assertions in section"; else m_stream << "\nNo assertions in test case"; m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush; } double dur = _sectionStats.durationInSeconds; if (shouldShowDuration(*m_config, dur)) { m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush; } if (m_headerPrinted) { m_headerPrinted = false; } StreamingReporterBase::sectionEnded(_sectionStats);}
void ConsoleReporter::benchmarkPreparing( StringRef name ) { lazyPrintWithoutClosingBenchmarkTable();
auto nameCol = TextFlow::Column( static_cast<std::string>( name ) ) .width( m_tablePrinter->columnInfos()[0].width - 2 );
bool firstLine = true; for (auto line : nameCol) { if (!firstLine) (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak(); else firstLine = false;
(*m_tablePrinter) << line << ColumnBreak(); }}
void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) { (*m_tablePrinter) << info.samples << ColumnBreak() << info.iterations << ColumnBreak(); if ( !m_config->benchmarkNoAnalysis() ) { ( *m_tablePrinter ) << Duration( info.estimatedDuration ) << ColumnBreak(); } ( *m_tablePrinter ) << OutputFlush{};}void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) { if (m_config->benchmarkNoAnalysis()) { (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak(); } else { (*m_tablePrinter) << ColumnBreak() << Duration(stats.mean.point.count()) << ColumnBreak() << Duration(stats.mean.lower_bound.count()) << ColumnBreak() << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak() << Duration(stats.standardDeviation.point.count()) << ColumnBreak() << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak() << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak(); }}
void ConsoleReporter::benchmarkFailed( StringRef error ) { auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream ); (*m_tablePrinter) << "Benchmark failed (" << error << ')' << ColumnBreak() << RowBreak();}
void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) { m_tablePrinter->close(); StreamingReporterBase::testCaseEnded(_testCaseStats); m_headerPrinted = false;}void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) { printTotalsDivider(_testRunStats.totals); printTestRunTotals( m_stream, *m_colour, _testRunStats.totals ); m_stream << '\n' << std::flush; StreamingReporterBase::testRunEnded(_testRunStats);}void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) { StreamingReporterBase::testRunStarting(_testRunInfo); if ( m_config->testSpec().hasFilters() ) { m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: " << m_config->testSpec() << '\n'; } m_stream << "Randomness seeded to: " << getSeed() << '\n';}
void ConsoleReporter::lazyPrint() {
m_tablePrinter->close(); lazyPrintWithoutClosingBenchmarkTable();}
void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
if ( !m_testRunInfoPrinted ) { lazyPrintRunInfo(); } if (!m_headerPrinted) { printTestCaseAndSectionHeader(); m_headerPrinted = true; }}void ConsoleReporter::lazyPrintRunInfo() { m_stream << '\n' << lineOfChars( '~' ) << '\n' << m_colour->guardColour( Colour::SecondaryText ) << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion() << " host application.\n" << "Run with -? for options\n\n";
m_testRunInfoPrinted = true;}void ConsoleReporter::printTestCaseAndSectionHeader() { assert(!m_sectionStack.empty()); printOpenHeader(currentTestCaseInfo->name);
if (m_sectionStack.size() > 1) { auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
auto it = m_sectionStack.begin() + 1, // Skip first section (test case) itEnd = m_sectionStack.end(); for (; it != itEnd; ++it) printHeaderString(it->name, 2); }
SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
m_stream << lineOfChars( '-' ) << '\n' << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n' << lineOfChars( '.' ) << "\n\n" << std::flush;}
void ConsoleReporter::printClosedHeader(std::string const& _name) { printOpenHeader(_name); m_stream << lineOfChars('.') << '\n';}void ConsoleReporter::printOpenHeader(std::string const& _name) { m_stream << lineOfChars('-') << '\n'; { auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream ); printHeaderString(_name); }}
void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) { // We want to get a bit fancy with line breaking here, so that subsequent // lines start after ":" if one is present, e.g. // ``` // blablabla: Fancy // linebreaking // ``` // but we also want to avoid problems with overly long indentation causing // the text to take up too many lines, e.g. // ``` // blablabla: F // a // n // c // y // . // . // . // ``` // So we limit the prefix indentation check to first quarter of the possible // width std::size_t idx = _string.find( ": " ); if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) { idx += 2; } else { idx = 0; } m_stream << TextFlow::Column( _string ) .indent( indent + idx ) .initialIndent( indent ) << '\n';}
void ConsoleReporter::printTotalsDivider(Totals const& totals) { if (totals.testCases.total() > 0) { std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total()); std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total()); std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total()); std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total()); while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1) findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++; while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1) findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
m_stream << m_colour->guardColour( Colour::Error ) << std::string( failedRatio, '=' ) << m_colour->guardColour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); if ( totals.testCases.allPassed() ) { m_stream << m_colour->guardColour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); } else { m_stream << m_colour->guardColour( Colour::Success ) << std::string( passedRatio, '=' ); } m_stream << m_colour->guardColour( Colour::Skip ) << std::string( skippedRatio, '=' ); } else { m_stream << m_colour->guardColour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' ); } m_stream << '\n';}
} // end namespace Catch
#if defined(_MSC_VER)#pragma warning(pop)#endif
#if defined(__clang__)# pragma clang diagnostic pop#endif
#include <algorithm>#include <cassert>
namespace Catch { namespace { struct BySectionInfo { BySectionInfo( SectionInfo const& other ): m_other( other ) {} BySectionInfo( BySectionInfo const& other ) = default; bool operator()( Detail::unique_ptr<CumulativeReporterBase::SectionNode> const& node ) const { return ( ( node->stats.sectionInfo.name == m_other.name ) && ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) ); } void operator=( BySectionInfo const& ) = delete;
private: SectionInfo const& m_other; };
} // namespace
namespace Detail { AssertionOrBenchmarkResult::AssertionOrBenchmarkResult( AssertionStats const& assertion ): m_assertion( assertion ) {}
AssertionOrBenchmarkResult::AssertionOrBenchmarkResult( BenchmarkStats<> const& benchmark ): m_benchmark( benchmark ) {}
bool AssertionOrBenchmarkResult::isAssertion() const { return m_assertion.some(); } bool AssertionOrBenchmarkResult::isBenchmark() const { return m_benchmark.some(); }
AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const { assert(m_assertion.some());
return *m_assertion; } BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const { assert(m_benchmark.some());
return *m_benchmark; }
}
CumulativeReporterBase::~CumulativeReporterBase() = default;
void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) { m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats); }
void CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) { // We need a copy, because SectionStats expect to take ownership SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false ); SectionNode* node; if ( m_sectionStack.empty() ) { if ( !m_rootSection ) { m_rootSection = Detail::make_unique<SectionNode>( incompleteStats ); } node = m_rootSection.get(); } else { SectionNode& parentNode = *m_sectionStack.back(); auto it = std::find_if( parentNode.childSections.begin(), parentNode.childSections.end(), BySectionInfo( sectionInfo ) ); if ( it == parentNode.childSections.end() ) { auto newNode = Detail::make_unique<SectionNode>( incompleteStats ); node = newNode.get(); parentNode.childSections.push_back( CATCH_MOVE( newNode ) ); } else { node = it->get(); } }
m_deepestSection = node; m_sectionStack.push_back( node ); }
void CumulativeReporterBase::assertionEnded( AssertionStats const& assertionStats ) { assert( !m_sectionStack.empty() ); // AssertionResult holds a pointer to a temporary DecomposedExpression, // which getExpandedExpression() calls to build the expression string. // Our section stack copy of the assertionResult will likely outlive the // temporary, so it must be expanded or discarded now to avoid calling // a destroyed object later. if ( m_shouldStoreFailedAssertions && !assertionStats.assertionResult.isOk() ) { static_cast<void>( assertionStats.assertionResult.getExpandedExpression() ); } if ( m_shouldStoreSuccesfulAssertions && assertionStats.assertionResult.isOk() ) { static_cast<void>( assertionStats.assertionResult.getExpandedExpression() ); } SectionNode& sectionNode = *m_sectionStack.back(); sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats ); }
void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) { assert( !m_sectionStack.empty() ); SectionNode& node = *m_sectionStack.back(); node.stats = sectionStats; m_sectionStack.pop_back(); }
void CumulativeReporterBase::testCaseEnded( TestCaseStats const& testCaseStats ) { auto node = Detail::make_unique<TestCaseNode>( testCaseStats ); assert( m_sectionStack.size() == 0 ); node->children.push_back( CATCH_MOVE(m_rootSection) ); m_testCases.push_back( CATCH_MOVE(node) );
assert( m_deepestSection ); m_deepestSection->stdOut = testCaseStats.stdOut; m_deepestSection->stdErr = testCaseStats.stdErr; }
void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) { assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run"); m_testRun = Detail::make_unique<TestRunNode>( testRunStats ); m_testRun->children.swap( m_testCases ); testRunEndedCumulative(); }
bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const { return std::any_of( assertionsAndBenchmarks.begin(), assertionsAndBenchmarks.end(), []( Detail::AssertionOrBenchmarkResult const& res ) { return res.isAssertion(); } ); }
} // end namespace Catch
namespace Catch {
void EventListenerBase::fatalErrorEncountered( StringRef ) {}
void EventListenerBase::benchmarkPreparing( StringRef ) {} void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {} void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {} void EventListenerBase::benchmarkFailed( StringRef ) {}
void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
void EventListenerBase::assertionEnded( AssertionStats const& ) {} void EventListenerBase::listReporters( std::vector<ReporterDescription> const& ) {} void EventListenerBase::listListeners( std::vector<ListenerDescription> const& ) {} void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {} void EventListenerBase::listTags( std::vector<TagInfo> const& ) {} void EventListenerBase::noMatchingTestCases( StringRef ) {} void EventListenerBase::reportInvalidTestSpec( StringRef ) {} void EventListenerBase::testRunStarting( TestRunInfo const& ) {} void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {} void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {} void EventListenerBase::sectionStarting( SectionInfo const& ) {} void EventListenerBase::sectionEnded( SectionStats const& ) {} void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {} void EventListenerBase::testCaseEnded( TestCaseStats const& ) {} void EventListenerBase::testRunEnded( TestRunStats const& ) {} void EventListenerBase::skipTest( TestCaseInfo const& ) {}} // namespace Catch
#include <algorithm>#include <cfloat>#include <cstdio>#include <ostream>#include <iomanip>
namespace Catch {
namespace { void listTestNamesOnly(std::ostream& out, std::vector<TestCaseHandle> const& tests) { for (auto const& test : tests) { auto const& testCaseInfo = test.getTestCaseInfo();
if (startsWith(testCaseInfo.name, '#')) { out << '"' << testCaseInfo.name << '"'; } else { out << testCaseInfo.name; }
out << '\n'; } out << std::flush; } } // end unnamed namespace
// Because formatting using c++ streams is stateful, drop down to C is // required Alternatively we could use stringstream, but its performance // is... not good. std::string getFormattedDuration( double duration ) { // Max exponent + 1 is required to represent the whole part // + 1 for decimal point // + 3 for the 3 decimal places // + 1 for null terminator const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1; char buffer[maxDoubleSize];
// Save previous errno, to prevent sprintf from overwriting it ErrnoGuard guard;#ifdef _MSC_VER size_t printedLength = static_cast<size_t>( sprintf_s( buffer, "%.3f", duration ) );#else size_t printedLength = static_cast<size_t>( std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );#endif return std::string( buffer, printedLength ); }
bool shouldShowDuration( IConfig const& config, double duration ) { if ( config.showDurations() == ShowDurations::Always ) { return true; } if ( config.showDurations() == ShowDurations::Never ) { return false; } const double min = config.minDuration(); return min >= 0 && duration >= min; }
std::string serializeFilters( std::vector<std::string> const& filters ) { // We add a ' ' separator between each filter size_t serialized_size = filters.size() - 1; for (auto const& filter : filters) { serialized_size += filter.size(); }
std::string serialized; serialized.reserve(serialized_size); bool first = true;
for (auto const& filter : filters) { if (!first) { serialized.push_back(' '); } first = false; serialized.append(filter); }
return serialized; }
std::ostream& operator<<( std::ostream& out, lineOfChars value ) { for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) { out.put( value.c ); } return out; }
void defaultListReporters( std::ostream& out, std::vector<ReporterDescription> const& descriptions, Verbosity verbosity ) { out << "Available reporters:\n"; const auto maxNameLen = std::max_element( descriptions.begin(), descriptions.end(), []( ReporterDescription const& lhs, ReporterDescription const& rhs ) { return lhs.name.size() < rhs.name.size(); } ) ->name.size();
for ( auto const& desc : descriptions ) { if ( verbosity == Verbosity::Quiet ) { out << TextFlow::Column( desc.name ) .indent( 2 ) .width( 5 + maxNameLen ) << '\n'; } else { out << TextFlow::Column( desc.name + ':' ) .indent( 2 ) .width( 5 + maxNameLen ) + TextFlow::Column( desc.description ) .initialIndent( 0 ) .indent( 2 ) .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 ) << '\n'; } } out << '\n' << std::flush; }
void defaultListListeners( std::ostream& out, std::vector<ListenerDescription> const& descriptions ) { out << "Registered listeners:\n";
if(descriptions.empty()) { return; }
const auto maxNameLen = std::max_element( descriptions.begin(), descriptions.end(), []( ListenerDescription const& lhs, ListenerDescription const& rhs ) { return lhs.name.size() < rhs.name.size(); } ) ->name.size();
for ( auto const& desc : descriptions ) { out << TextFlow::Column( static_cast<std::string>( desc.name ) + ':' ) .indent( 2 ) .width( maxNameLen + 5 ) + TextFlow::Column( desc.description ) .initialIndent( 0 ) .indent( 2 ) .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 ) << '\n'; }
out << '\n' << std::flush; }
void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered ) { if ( isFiltered ) { out << "Tags for matching test cases:\n"; } else { out << "All available tags:\n"; }
for ( auto const& tagCount : tags ) { ReusableStringStream rss; rss << " " << std::setw( 2 ) << tagCount.count << " "; auto str = rss.str(); auto wrapper = TextFlow::Column( tagCount.all() ) .initialIndent( 0 ) .indent( str.size() ) .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 ); out << str << wrapper << '\n'; } out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush; }
void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) { // We special case this to provide the equivalent of old // `--list-test-names-only`, which could then be used by the // `--input-file` option. if (verbosity == Verbosity::Quiet) { listTestNamesOnly(out, tests); return; }
if (isFiltered) { out << "Matching test cases:\n"; } else { out << "All available test cases:\n"; }
for (auto const& test : tests) { auto const& testCaseInfo = test.getTestCaseInfo(); Colour::Code colour = testCaseInfo.isHidden() ? Colour::SecondaryText : Colour::None; auto colourGuard = streamColour->guardColour( colour ).engage( out );
out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n'; if (verbosity >= Verbosity::High) { out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n'; } if (!testCaseInfo.tags.empty() && verbosity > Verbosity::Quiet) { out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n'; } }
if (isFiltered) { out << pluralise(tests.size(), "matching test case"_sr); } else { out << pluralise(tests.size(), "test case"_sr); } out << "\n\n" << std::flush; }
namespace { class SummaryColumn { public: SummaryColumn( std::string suffix, Colour::Code colour ): m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
SummaryColumn&& addRow( std::uint64_t count ) && { std::string row = std::to_string(count); auto const new_width = std::max( m_width, row.size() ); if ( new_width > m_width ) { for ( auto& oldRow : m_rows ) { oldRow.insert( 0, new_width - m_width, ' ' ); } } else { row.insert( 0, m_width - row.size(), ' ' ); } m_width = new_width; m_rows.push_back( row ); return std::move( *this ); }
std::string const& getSuffix() const { return m_suffix; } Colour::Code getColour() const { return m_colour; } std::string const& getRow( std::size_t index ) const { return m_rows[index]; }
private: std::string m_suffix; Colour::Code m_colour; std::size_t m_width = 0; std::vector<std::string> m_rows; };
void printSummaryRow( std::ostream& stream, ColourImpl& colour, StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row ) { for ( auto const& col : cols ) { auto const& value = col.getRow( row ); auto const& suffix = col.getSuffix(); if ( suffix.empty() ) { stream << label << ": "; if ( value != "0" ) { stream << value; } else { stream << colour.guardColour( Colour::Warning ) << "- none -"; } } else if ( value != "0" ) { stream << colour.guardColour( Colour::LightGrey ) << " | " << colour.guardColour( col.getColour() ) << value << ' ' << suffix; } } stream << '\n'; } } // namespace
void printTestRunTotals( std::ostream& stream, ColourImpl& streamColour, Totals const& totals ) { if ( totals.testCases.total() == 0 ) { stream << streamColour.guardColour( Colour::Warning ) << "No tests ran\n"; return; }
if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) { stream << streamColour.guardColour( Colour::ResultSuccess ) << "All tests passed"; stream << " (" << pluralise( totals.assertions.passed, "assertion"_sr ) << " in " << pluralise( totals.testCases.passed, "test case"_sr ) << ')' << '\n'; return; }
std::vector<SummaryColumn> columns; // Don't include "skipped assertions" in total count const auto totalAssertionCount = totals.assertions.total() - totals.assertions.skipped; columns.push_back( SummaryColumn( "", Colour::None ) .addRow( totals.testCases.total() ) .addRow( totalAssertionCount ) ); columns.push_back( SummaryColumn( "passed", Colour::Success ) .addRow( totals.testCases.passed ) .addRow( totals.assertions.passed ) ); columns.push_back( SummaryColumn( "failed", Colour::ResultError ) .addRow( totals.testCases.failed ) .addRow( totals.assertions.failed ) ); columns.push_back( SummaryColumn( "skipped", Colour::Skip ) .addRow( totals.testCases.skipped ) // Don't print "skipped assertions" .addRow( 0 ) ); columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) .addRow( totals.testCases.failedButOk ) .addRow( totals.assertions.failedButOk ) ); printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 ); printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 ); }
} // namespace Catch
//
namespace Catch { namespace { void writeSourceInfo( JsonObjectWriter& writer, SourceLineInfo const& sourceInfo ) { auto source_location_writer = writer.write( "source-location"_sr ).writeObject(); source_location_writer.write( "filename"_sr ) .write( sourceInfo.file ); source_location_writer.write( "line"_sr ).write( sourceInfo.line ); }
void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) { for ( auto const& tag : tags ) { writer.write( tag.original ); } }
void writeProperties( JsonArrayWriter writer, TestCaseInfo const& info ) { if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); } if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); } if ( info.expectedToFail() ) { writer.write( "expected-to-fail"_sr ); } if ( info.throws() ) { writer.write( "throws"_sr ); } }
} // namespace
JsonReporter::JsonReporter( ReporterConfig&& config ): StreamingReporterBase{ CATCH_MOVE( config ) } {
m_preferences.shouldRedirectStdOut = true; // TBD: Do we want to report all assertions? XML reporter does // not, but for machine-parseable reporters I think the answer // should be yes. m_preferences.shouldReportAllAssertions = true;
m_objectWriters.emplace( m_stream ); m_writers.emplace( Writer::Object ); auto& writer = m_objectWriters.top();
writer.write( "version"_sr ).write( 1 );
{ auto metadata_writer = writer.write( "metadata"_sr ).writeObject(); metadata_writer.write( "name"_sr ).write( m_config->name() ); metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() ); metadata_writer.write( "catch2-version"_sr ) .write( libraryVersion() ); if ( m_config->testSpec().hasFilters() ) { metadata_writer.write( "filters"_sr ) .write( m_config->testSpec() ); } } }
JsonReporter::~JsonReporter() { endListing(); // TODO: Ensure this closes the top level object, add asserts assert( m_writers.size() == 1 && "Only the top level object should be open" ); assert( m_writers.top() == Writer::Object ); endObject(); m_stream << '\n' << std::flush; assert( m_writers.empty() ); }
JsonArrayWriter& JsonReporter::startArray() { m_arrayWriters.emplace( m_arrayWriters.top().writeArray() ); m_writers.emplace( Writer::Array ); return m_arrayWriters.top(); } JsonArrayWriter& JsonReporter::startArray( StringRef key ) { m_arrayWriters.emplace( m_objectWriters.top().write( key ).writeArray() ); m_writers.emplace( Writer::Array ); return m_arrayWriters.top(); }
JsonObjectWriter& JsonReporter::startObject() { m_objectWriters.emplace( m_arrayWriters.top().writeObject() ); m_writers.emplace( Writer::Object ); return m_objectWriters.top(); } JsonObjectWriter& JsonReporter::startObject( StringRef key ) { m_objectWriters.emplace( m_objectWriters.top().write( key ).writeObject() ); m_writers.emplace( Writer::Object ); return m_objectWriters.top(); }
void JsonReporter::endObject() { assert( isInside( Writer::Object ) ); m_objectWriters.pop(); m_writers.pop(); } void JsonReporter::endArray() { assert( isInside( Writer::Array ) ); m_arrayWriters.pop(); m_writers.pop(); }
bool JsonReporter::isInside( Writer writer ) { return !m_writers.empty() && m_writers.top() == writer; }
void JsonReporter::startListing() { if ( !m_startedListing ) { startObject( "listings"_sr ); } m_startedListing = true; } void JsonReporter::endListing() { if ( m_startedListing ) { endObject(); } m_startedListing = false; }
std::string JsonReporter::getDescription() { return "Outputs listings as JSON. Test listing is Work-in-Progress!"; }
void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) { StreamingReporterBase::testRunStarting( runInfo ); endListing();
assert( isInside( Writer::Object ) ); startObject( "test-run"_sr ); startArray( "test-cases"_sr ); }
static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) { writer.write( "passed"_sr ).write( counts.passed ); writer.write( "failed"_sr ).write( counts.failed ); writer.write( "fail-but-ok"_sr ).write( counts.failedButOk ); writer.write( "skipped"_sr ).write( counts.skipped ); }
void JsonReporter::testRunEnded(TestRunStats const& runStats) { assert( isInside( Writer::Array ) ); // End "test-cases" endArray();
{ auto totals = m_objectWriters.top().write( "totals"_sr ).writeObject(); writeCounts( totals.write( "assertions"_sr ).writeObject(), runStats.totals.assertions ); writeCounts( totals.write( "test-cases"_sr ).writeObject(), runStats.totals.testCases ); }
// End the "test-run" object endObject(); }
void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) { StreamingReporterBase::testCaseStarting( tcInfo );
assert( isInside( Writer::Array ) && "We should be in the 'test-cases' array" ); startObject(); // "test-info" prelude { auto testInfo = m_objectWriters.top().write( "test-info"_sr ).writeObject(); // TODO: handle testName vs className!! testInfo.write( "name"_sr ).write( tcInfo.name ); writeSourceInfo(testInfo, tcInfo.lineInfo); writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags ); writeProperties( testInfo.write( "properties"_sr ).writeArray(), tcInfo ); }
// Start the array for individual test runs (testCasePartial pairs) startArray( "runs"_sr ); }
void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) { StreamingReporterBase::testCaseEnded( tcStats );
// We need to close the 'runs' array before finishing the test case assert( isInside( Writer::Array ) ); endArray();
{ auto totals = m_objectWriters.top().write( "totals"_sr ).writeObject(); writeCounts( totals.write( "assertions"_sr ).writeObject(), tcStats.totals.assertions ); // We do not write the test case totals, because there will always be just one test case here. // TODO: overall "result" -> success, skip, fail here? Or in partial result? } // We do not write out stderr/stdout, because we instead wrote those out in partial runs
// TODO: aborting?
// And we also close this test case's object assert( isInside( Writer::Object ) ); endObject(); }
void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/, uint64_t index ) { startObject(); m_objectWriters.top().write( "run-idx"_sr ).write( index ); startArray( "path"_sr ); // TODO: we want to delay most of the printing to the 'root' section // TODO: childSection key name? }
void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats, uint64_t /*index*/ ) { // Fixme: the top level section handles this. //// path object endArray(); if ( !tcStats.stdOut.empty() ) { m_objectWriters.top() .write( "captured-stdout"_sr ) .write( tcStats.stdOut ); } if ( !tcStats.stdErr.empty() ) { m_objectWriters.top() .write( "captured-stderr"_sr ) .write( tcStats.stdErr ); } { auto totals = m_objectWriters.top().write( "totals"_sr ).writeObject(); writeCounts( totals.write( "assertions"_sr ).writeObject(), tcStats.totals.assertions ); // We do not write the test case totals, because there will // always be just one test case here. // TODO: overall "result" -> success, skip, fail here? Or in // partial result? } // TODO: aborting? // run object endObject(); }
void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) { assert( isInside( Writer::Array ) && "Section should always start inside an object" ); // We want to nest top level sections, even though it shares name // and source loc with the TEST_CASE auto& sectionObject = startObject(); sectionObject.write( "kind"_sr ).write( "section"_sr ); sectionObject.write( "name"_sr ).write( sectionInfo.name ); writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
// TBD: Do we want to create this event lazily? It would become // rather complex, but we could do it, and it would look // better for empty sections. OTOH, empty sections should // be rare. startArray( "path"_sr ); } void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) { // End the subpath array endArray(); // TODO: metadata // TODO: what info do we have here?
// End the section object endObject(); }
void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {} void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) { // TODO: There is lot of different things to handle here, but // we can fill it in later, after we show that the basic // outline and streaming reporter impl works well enough. //if ( !m_config->includeSuccessfulResults() // && assertionStats.assertionResult.isOk() ) { // return; //} assert( isInside( Writer::Array ) ); auto assertionObject = m_arrayWriters.top().writeObject();
assertionObject.write( "kind"_sr ).write( "assertion"_sr ); writeSourceInfo( assertionObject, assertionStats.assertionResult.getSourceInfo() ); assertionObject.write( "status"_sr ) .write( assertionStats.assertionResult.isOk() ); // TODO: handling of result. // TODO: messages // TODO: totals? }
void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; } void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {} void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {} void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
void JsonReporter::listReporters( std::vector<ReporterDescription> const& descriptions ) { startListing();
auto writer = m_objectWriters.top().write( "reporters"_sr ).writeArray(); for ( auto const& desc : descriptions ) { auto desc_writer = writer.writeObject(); desc_writer.write( "name"_sr ).write( desc.name ); desc_writer.write( "description"_sr ).write( desc.description ); } } void JsonReporter::listListeners( std::vector<ListenerDescription> const& descriptions ) { startListing();
auto writer = m_objectWriters.top().write( "listeners"_sr ).writeArray();
for ( auto const& desc : descriptions ) { auto desc_writer = writer.writeObject(); desc_writer.write( "name"_sr ).write( desc.name ); desc_writer.write( "description"_sr ).write( desc.description ); } } void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) { startListing();
auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
for ( auto const& test : tests ) { auto desc_writer = writer.writeObject(); auto const& info = test.getTestCaseInfo();
desc_writer.write( "name"_sr ).write( info.name ); desc_writer.write( "class-name"_sr ).write( info.className ); { auto tag_writer = desc_writer.write( "tags"_sr ).writeArray(); for ( auto const& tag : info.tags ) { tag_writer.write( tag.original ); } } writeSourceInfo( desc_writer, info.lineInfo ); } } void JsonReporter::listTags( std::vector<TagInfo> const& tags ) { startListing();
auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray(); for ( auto const& tag : tags ) { auto tag_writer = writer.writeObject(); { auto aliases_writer = tag_writer.write( "aliases"_sr ).writeArray(); for ( auto alias : tag.spellings ) { aliases_writer.write( alias ); } } tag_writer.write( "count"_sr ).write( tag.count ); } }} // namespace Catch
#include <cassert>#include <ctime>#include <algorithm>#include <iomanip>
namespace Catch {
namespace { std::string getCurrentTimestamp() { time_t rawtime; std::time(&rawtime);
std::tm timeInfo = {};#if defined (_MSC_VER) || defined (__MINGW32__) gmtime_s(&timeInfo, &rawtime);#elif defined (CATCH_PLATFORM_PLAYSTATION) gmtime_s(&rawtime, &timeInfo);#elif defined (__IAR_SYSTEMS_ICC__) timeInfo = *std::gmtime(&rawtime);#else gmtime_r(&rawtime, &timeInfo);#endif
auto const timeStampSize = sizeof("2017-01-16T17:06:45Z"); char timeStamp[timeStampSize]; const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
return std::string(timeStamp, timeStampSize - 1); }
std::string fileNameTag(std::vector<Tag> const& tags) { auto it = std::find_if(begin(tags), end(tags), [] (Tag const& tag) { return tag.original.size() > 0 && tag.original[0] == '#'; }); if (it != tags.end()) { return static_cast<std::string>( it->original.substr(1, it->original.size() - 1) ); } return std::string(); }
// Formats the duration in seconds to 3 decimal places. // This is done because some genius defined Maven Surefire schema // in a way that only accepts 3 decimal places, and tools like // Jenkins use that schema for validation JUnit reporter output. std::string formatDuration( double seconds ) { ReusableStringStream rss; rss << std::fixed << std::setprecision( 3 ) << seconds; return rss.str(); }
static void normalizeNamespaceMarkers(std::string& str) { std::size_t pos = str.find( "::" ); while ( pos != std::string::npos ) { str.replace( pos, 2, "." ); pos += 1; pos = str.find( "::", pos ); } }
} // anonymous namespace
JunitReporter::JunitReporter( ReporterConfig&& _config ) : CumulativeReporterBase( CATCH_MOVE(_config) ), xml( m_stream ) { m_preferences.shouldRedirectStdOut = true; m_preferences.shouldReportAllAssertions = true; m_shouldStoreSuccesfulAssertions = false; }
std::string JunitReporter::getDescription() { return "Reports test results in an XML format that looks like Ant's junitreport target"; }
void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) { CumulativeReporterBase::testRunStarting( runInfo ); xml.startElement( "testsuites" ); suiteTimer.start(); stdOutForSuite.clear(); stdErrForSuite.clear(); unexpectedExceptions = 0; }
void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) { m_okToFail = testCaseInfo.okToFail(); }
void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) { if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail ) unexpectedExceptions++; CumulativeReporterBase::assertionEnded( assertionStats ); }
void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { stdOutForSuite += testCaseStats.stdOut; stdErrForSuite += testCaseStats.stdErr; CumulativeReporterBase::testCaseEnded( testCaseStats ); }
void JunitReporter::testRunEndedCumulative() { const auto suiteTime = suiteTimer.getElapsedSeconds(); writeRun( *m_testRun, suiteTime ); xml.endElement(); }
void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) { XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
TestRunStats const& stats = testRunNode.value; xml.writeAttribute( "name"_sr, stats.runInfo.name ); xml.writeAttribute( "errors"_sr, unexpectedExceptions ); xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions ); xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped ); xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() ); xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD if( m_config->showDurations() == ShowDurations::Never ) xml.writeAttribute( "time"_sr, ""_sr ); else xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) ); xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
// Write properties { auto properties = xml.scopedElement("properties"); xml.scopedElement("property") .writeAttribute("name"_sr, "random-seed"_sr) .writeAttribute("value"_sr, m_config->rngSeed()); if (m_config->testSpec().hasFilters()) { xml.scopedElement("property") .writeAttribute("name"_sr, "filters"_sr) .writeAttribute("value"_sr, m_config->testSpec()); } }
// Write test cases for( auto const& child : testRunNode.children ) writeTestCase( *child );
xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline ); xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline ); }
void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) { TestCaseStats const& stats = testCaseNode.value;
// All test cases have exactly one section - which represents the // test case itself. That section may have 0-n nested sections assert( testCaseNode.children.size() == 1 ); SectionNode const& rootSection = *testCaseNode.children.front();
std::string className = static_cast<std::string>( stats.testInfo->className );
if( className.empty() ) { className = fileNameTag(stats.testInfo->tags); if ( className.empty() ) { className = "global"; } }
if ( !m_config->name().empty() ) className = static_cast<std::string>(m_config->name()) + '.' + className;
normalizeNamespaceMarkers(className);
writeSection( className, "", rootSection, stats.testInfo->okToFail() ); }
void JunitReporter::writeSection( std::string const& className, std::string const& rootName, SectionNode const& sectionNode, bool testOkToFail) { std::string name = trim( sectionNode.stats.sectionInfo.name ); if( !rootName.empty() ) name = rootName + '/' + name;
if( sectionNode.hasAnyAssertions() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty() ) { XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); if( className.empty() ) { xml.writeAttribute( "classname"_sr, name ); xml.writeAttribute( "name"_sr, "root"_sr ); } else { xml.writeAttribute( "classname"_sr, className ); xml.writeAttribute( "name"_sr, name ); } xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) ); // This is not ideal, but it should be enough to mimic gtest's // junit output. // Ideally the JUnit reporter would also handle `skipTest` // events and write those out appropriately. xml.writeAttribute( "status"_sr, "run"_sr );
if (sectionNode.stats.assertions.failedButOk) { xml.scopedElement("skipped") .writeAttribute("message", "TEST_CASE tagged with !mayfail"); }
writeAssertions( sectionNode );
if( !sectionNode.stdOut.empty() ) xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline ); if( !sectionNode.stdErr.empty() ) xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline ); } for( auto const& childNode : sectionNode.childSections ) if( className.empty() ) writeSection( name, "", *childNode, testOkToFail ); else writeSection( className, name, *childNode, testOkToFail ); }
void JunitReporter::writeAssertions( SectionNode const& sectionNode ) { for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) { if (assertionOrBenchmark.isAssertion()) { writeAssertion(assertionOrBenchmark.asAssertion()); } } }
void JunitReporter::writeAssertion( AssertionStats const& stats ) { AssertionResult const& result = stats.assertionResult; if ( !result.isOk() || result.getResultType() == ResultWas::ExplicitSkip ) { std::string elementName; switch( result.getResultType() ) { case ResultWas::ThrewException: case ResultWas::FatalErrorCondition: elementName = "error"; break; case ResultWas::ExplicitFailure: case ResultWas::ExpressionFailed: case ResultWas::DidntThrowException: elementName = "failure"; break; case ResultWas::ExplicitSkip: elementName = "skipped"; break; // We should never see these here: case ResultWas::Info: case ResultWas::Warning: case ResultWas::Ok: case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: elementName = "internalError"; break; }
XmlWriter::ScopedElement e = xml.scopedElement( elementName );
xml.writeAttribute( "message"_sr, result.getExpression() ); xml.writeAttribute( "type"_sr, result.getTestMacroName() );
ReusableStringStream rss; if ( result.getResultType() == ResultWas::ExplicitSkip ) { rss << "SKIPPED\n"; } else { rss << "FAILED" << ":\n"; if (result.hasExpression()) { rss << " "; rss << result.getExpressionInMacro(); rss << '\n'; } if (result.hasExpandedExpression()) { rss << "with expansion:\n"; rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n'; } }
if( result.hasMessage() ) rss << result.getMessage() << '\n'; for( auto const& msg : stats.infoMessages ) if( msg.type == ResultWas::Info ) rss << msg.message << '\n';
rss << "at " << result.getSourceInfo(); xml.writeText( rss.str(), XmlFormatting::Newline ); } }
} // end namespace Catch
#include <ostream>
namespace Catch { void MultiReporter::updatePreferences(IEventListener const& reporterish) { m_preferences.shouldRedirectStdOut |= reporterish.getPreferences().shouldRedirectStdOut; m_preferences.shouldReportAllAssertions |= reporterish.getPreferences().shouldReportAllAssertions; }
void MultiReporter::addListener( IEventListenerPtr&& listener ) { updatePreferences(*listener); m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) ); ++m_insertedListeners; }
void MultiReporter::addReporter( IEventListenerPtr&& reporter ) { updatePreferences(*reporter);
// We will need to output the captured stdout if there are reporters // that do not want it captured. // We do not consider listeners, because it is generally assumed that // listeners are output-transparent, even though they can ask for stdout // capture to do something with it. m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
// Reporters can always be placed to the back without breaking the // reporting order m_reporterLikes.push_back( CATCH_MOVE( reporter ) ); }
void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->noMatchingTestCases( unmatchedSpec ); } }
void MultiReporter::fatalErrorEncountered( StringRef error ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->fatalErrorEncountered( error ); } }
void MultiReporter::reportInvalidTestSpec( StringRef arg ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->reportInvalidTestSpec( arg ); } }
void MultiReporter::benchmarkPreparing( StringRef name ) { for (auto& reporterish : m_reporterLikes) { reporterish->benchmarkPreparing(name); } } void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->benchmarkStarting( benchmarkInfo ); } } void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->benchmarkEnded( benchmarkStats ); } }
void MultiReporter::benchmarkFailed( StringRef error ) { for (auto& reporterish : m_reporterLikes) { reporterish->benchmarkFailed(error); } }
void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->testRunStarting( testRunInfo ); } }
void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->testCaseStarting( testInfo ); } }
void MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->testCasePartialStarting( testInfo, partNumber ); } }
void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->sectionStarting( sectionInfo ); } }
void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->assertionStarting( assertionInfo ); } }
void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) { const bool reportByDefault = assertionStats.assertionResult.getResultType() != ResultWas::Ok || m_config->includeSuccessfulResults();
for ( auto & reporterish : m_reporterLikes ) { if ( reportByDefault || reporterish->getPreferences().shouldReportAllAssertions ) { reporterish->assertionEnded( assertionStats ); } } }
void MultiReporter::sectionEnded( SectionStats const& sectionStats ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->sectionEnded( sectionStats ); } }
void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats, uint64_t partNumber ) { if ( m_preferences.shouldRedirectStdOut && m_haveNoncapturingReporters ) { if ( !testStats.stdOut.empty() ) { Catch::cout() << testStats.stdOut << std::flush; } if ( !testStats.stdErr.empty() ) { Catch::cerr() << testStats.stdErr << std::flush; } }
for ( auto& reporterish : m_reporterLikes ) { reporterish->testCasePartialEnded( testStats, partNumber ); } }
void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->testCaseEnded( testCaseStats ); } }
void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->testRunEnded( testRunStats ); } }
void MultiReporter::skipTest( TestCaseInfo const& testInfo ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->skipTest( testInfo ); } }
void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) { for (auto& reporterish : m_reporterLikes) { reporterish->listReporters(descriptions); } }
void MultiReporter::listListeners( std::vector<ListenerDescription> const& descriptions ) { for ( auto& reporterish : m_reporterLikes ) { reporterish->listListeners( descriptions ); } }
void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) { for (auto& reporterish : m_reporterLikes) { reporterish->listTests(tests); } }
void MultiReporter::listTags(std::vector<TagInfo> const& tags) { for (auto& reporterish : m_reporterLikes) { reporterish->listTags(tags); } }
} // end namespace Catch
namespace Catch { namespace Detail {
void registerReporterImpl( std::string const& name, IReporterFactoryPtr reporterPtr ) { CATCH_TRY { getMutableRegistryHub().registerReporter( name, CATCH_MOVE( reporterPtr ) ); } CATCH_CATCH_ALL { // Do not throw when constructing global objects, instead // register the exception to be processed later getMutableRegistryHub().registerStartupException(); } }
void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) { getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) ); }
} // namespace Detail} // namespace Catch
#include <map>
namespace Catch {
namespace { std::string createMetadataString(IConfig const& config) { ReusableStringStream sstr; if ( config.testSpec().hasFilters() ) { sstr << "filters='" << config.testSpec() << "' "; } sstr << "rng-seed=" << config.rngSeed(); return sstr.str(); } }
void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) { CumulativeReporterBase::testRunStarting(testRunInfo);
xml.writeComment( createMetadataString( *m_config ) ); xml.startElement("testExecutions"); xml.writeAttribute("version"_sr, '1'); }
void SonarQubeReporter::writeRun( TestRunNode const& runNode ) { std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
for ( auto const& child : runNode.children ) { testsPerFile[child->value.testInfo->lineInfo.file].push_back( child.get() ); }
for ( auto const& kv : testsPerFile ) { writeTestFile( kv.first, kv.second ); } }
void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) { XmlWriter::ScopedElement e = xml.scopedElement("file"); xml.writeAttribute("path"_sr, filename);
for (auto const& child : testCaseNodes) writeTestCase(*child); }
void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) { // All test cases have exactly one section - which represents the // test case itself. That section may have 0-n nested sections assert(testCaseNode.children.size() == 1); SectionNode const& rootSection = *testCaseNode.children.front(); writeSection("", rootSection, testCaseNode.value.testInfo->okToFail()); }
void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) { std::string name = trim(sectionNode.stats.sectionInfo.name); if (!rootName.empty()) name = rootName + '/' + name;
if ( sectionNode.hasAnyAssertions() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty() ) { XmlWriter::ScopedElement e = xml.scopedElement("testCase"); xml.writeAttribute("name"_sr, name); xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
writeAssertions(sectionNode, okToFail); }
for (auto const& childNode : sectionNode.childSections) writeSection(name, *childNode, okToFail); }
void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) { for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) { if (assertionOrBenchmark.isAssertion()) { writeAssertion(assertionOrBenchmark.asAssertion(), okToFail); } } }
void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) { AssertionResult const& result = stats.assertionResult; if ( !result.isOk() || result.getResultType() == ResultWas::ExplicitSkip ) { std::string elementName; if (okToFail) { elementName = "skipped"; } else { switch (result.getResultType()) { case ResultWas::ThrewException: case ResultWas::FatalErrorCondition: elementName = "error"; break; case ResultWas::ExplicitFailure: case ResultWas::ExpressionFailed: case ResultWas::DidntThrowException: elementName = "failure"; break; case ResultWas::ExplicitSkip: elementName = "skipped"; break; // We should never see these here: case ResultWas::Info: case ResultWas::Warning: case ResultWas::Ok: case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: elementName = "internalError"; break; } }
XmlWriter::ScopedElement e = xml.scopedElement(elementName);
ReusableStringStream messageRss; messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')'; xml.writeAttribute("message"_sr, messageRss.str());
ReusableStringStream textRss; if ( result.getResultType() == ResultWas::ExplicitSkip ) { textRss << "SKIPPED\n"; } else { textRss << "FAILED:\n"; if (result.hasExpression()) { textRss << '\t' << result.getExpressionInMacro() << '\n'; } if (result.hasExpandedExpression()) { textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n'; } }
if (result.hasMessage()) textRss << result.getMessage() << '\n';
for (auto const& msg : stats.infoMessages) if (msg.type == ResultWas::Info) textRss << msg.message << '\n';
textRss << "at " << result.getSourceInfo(); xml.writeText(textRss.str(), XmlFormatting::Newline); } }
} // end namespace Catch
namespace Catch {
StreamingReporterBase::~StreamingReporterBase() = default;
void StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) { currentTestRunInfo = _testRunInfo; }
void StreamingReporterBase::testRunEnded( TestRunStats const& ) { currentTestCaseInfo = nullptr; }
} // end namespace Catch
#include <algorithm>#include <ostream>
namespace Catch {
namespace { // Yes, this has to be outside the class and namespaced by naming. // Making older compiler happy is hard. static constexpr StringRef tapFailedString = "not ok"_sr; static constexpr StringRef tapPassedString = "ok"_sr; static constexpr Colour::Code tapDimColour = Colour::FileName;
class TapAssertionPrinter { public: TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete; TapAssertionPrinter(TapAssertionPrinter const&) = delete; TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_) : stream(_stream) , result(_stats.assertionResult) , messages(_stats.infoMessages) , itMessage(_stats.infoMessages.begin()) , printInfoMessages(true) , counter(_counter) , colourImpl( colour_ ) {}
void print() { itMessage = messages.begin();
switch (result.getResultType()) { case ResultWas::Ok: printResultType(tapPassedString); printOriginalExpression(); printReconstructedExpression(); if (!result.hasExpression()) printRemainingMessages(Colour::None); else printRemainingMessages(); break; case ResultWas::ExpressionFailed: if (result.isOk()) { printResultType(tapPassedString); } else { printResultType(tapFailedString); } printOriginalExpression(); printReconstructedExpression(); if (result.isOk()) { printIssue(" # TODO"); } printRemainingMessages(); break; case ResultWas::ThrewException: printResultType(tapFailedString); printIssue("unexpected exception with message:"_sr); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::FatalErrorCondition: printResultType(tapFailedString); printIssue("fatal error condition with message:"_sr); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::DidntThrowException: printResultType(tapFailedString); printIssue("expected exception, got none"_sr); printExpressionWas(); printRemainingMessages(); break; case ResultWas::Info: printResultType("info"_sr); printMessage(); printRemainingMessages(); break; case ResultWas::Warning: printResultType("warning"_sr); printMessage(); printRemainingMessages(); break; case ResultWas::ExplicitFailure: printResultType(tapFailedString); printIssue("explicitly"_sr); printRemainingMessages(Colour::None); break; case ResultWas::ExplicitSkip: printResultType(tapPassedString); printIssue(" # SKIP"_sr); printMessage(); printRemainingMessages(); break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: printResultType("** internal error **"_sr); break; } }
private: void printResultType(StringRef passOrFail) const { if (!passOrFail.empty()) { stream << passOrFail << ' ' << counter << " -"; } }
void printIssue(StringRef issue) const { stream << ' ' << issue; }
void printExpressionWas() { if (result.hasExpression()) { stream << ';'; stream << colourImpl->guardColour( tapDimColour ) << " expression was:"; printOriginalExpression(); } }
void printOriginalExpression() const { if (result.hasExpression()) { stream << ' ' << result.getExpression(); } }
void printReconstructedExpression() const { if (result.hasExpandedExpression()) { stream << colourImpl->guardColour( tapDimColour ) << " for: ";
std::string expr = result.getExpandedExpression(); std::replace(expr.begin(), expr.end(), '\n', ' '); stream << expr; } }
void printMessage() { if (itMessage != messages.end()) { stream << " '" << itMessage->message << '\''; ++itMessage; } }
void printRemainingMessages(Colour::Code colour = tapDimColour) { if (itMessage == messages.end()) { return; }
// using messages.end() directly (or auto) yields compilation error: std::vector<MessageInfo>::const_iterator itEnd = messages.end(); const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
stream << colourImpl->guardColour( colour ) << " with " << pluralise( N, "message"_sr ) << ':';
for (; itMessage != itEnd; ) { // If this assertion is a warning ignore any INFO messages if (printInfoMessages || itMessage->type != ResultWas::Info) { stream << " '" << itMessage->message << '\''; if (++itMessage != itEnd) { stream << colourImpl->guardColour(tapDimColour) << " and"; } } } }
private: std::ostream& stream; AssertionResult const& result; std::vector<MessageInfo> const& messages; std::vector<MessageInfo>::const_iterator itMessage; bool printInfoMessages; std::size_t counter; ColourImpl* colourImpl; };
} // End anonymous namespace
void TAPReporter::testRunStarting( TestRunInfo const& ) { if ( m_config->testSpec().hasFilters() ) { m_stream << "# filters: " << m_config->testSpec() << '\n'; } m_stream << "# rng-seed: " << m_config->rngSeed() << '\n'; }
void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) { m_stream << "# No test cases matched '" << unmatchedSpec << "'\n"; }
void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) { ++counter;
m_stream << "# " << currentTestCaseInfo->name << '\n'; TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get()); printer.print();
m_stream << '\n' << std::flush; }
void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) { m_stream << "1.." << _testRunStats.totals.assertions.total(); if (_testRunStats.totals.testCases.total() == 0) { m_stream << " # Skipped: No tests ran."; } m_stream << "\n\n" << std::flush; StreamingReporterBase::testRunEnded(_testRunStats); }
} // end namespace Catch
#include <cassert>#include <ostream>
namespace Catch {
namespace { // if string has a : in first line will set indent to follow it on // subsequent lines void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) { std::size_t i = _string.find(": "); if (i != std::string::npos) i += 2; else i = 0; os << TextFlow::Column(_string) .indent(indent + i) .initialIndent(indent) << '\n'; }
std::string escape(StringRef str) { std::string escaped = static_cast<std::string>(str); replaceInPlace(escaped, "|", "||"); replaceInPlace(escaped, "'", "|'"); replaceInPlace(escaped, "\n", "|n"); replaceInPlace(escaped, "\r", "|r"); replaceInPlace(escaped, "[", "|["); replaceInPlace(escaped, "]", "|]"); return escaped; } } // end anonymous namespace
TeamCityReporter::~TeamCityReporter() = default;
void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) { m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name ) << "']\n"; }
void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) { m_stream << "##teamcity[testSuiteFinished name='" << escape( runStats.runInfo.name ) << "']\n"; }
void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) { AssertionResult const& result = assertionStats.assertionResult; if ( !result.isOk() || result.getResultType() == ResultWas::ExplicitSkip ) {
ReusableStringStream msg; if (!m_headerPrintedForThisSection) printSectionHeader(msg.get()); m_headerPrintedForThisSection = true;
msg << result.getSourceInfo() << '\n';
switch (result.getResultType()) { case ResultWas::ExpressionFailed: msg << "expression failed"; break; case ResultWas::ThrewException: msg << "unexpected exception"; break; case ResultWas::FatalErrorCondition: msg << "fatal error condition"; break; case ResultWas::DidntThrowException: msg << "no exception was thrown where one was expected"; break; case ResultWas::ExplicitFailure: msg << "explicit failure"; break; case ResultWas::ExplicitSkip: msg << "explicit skip"; break;
// We shouldn't get here because of the isOk() test case ResultWas::Ok: case ResultWas::Info: case ResultWas::Warning: CATCH_ERROR("Internal error in TeamCity reporter"); // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: CATCH_ERROR("Not implemented"); } if (assertionStats.infoMessages.size() == 1) msg << " with message:"; if (assertionStats.infoMessages.size() > 1) msg << " with messages:"; for (auto const& messageInfo : assertionStats.infoMessages) msg << "\n \"" << messageInfo.message << '"';
if (result.hasExpression()) { msg << "\n " << result.getExpressionInMacro() << "\n" "with expansion:\n" " " << result.getExpandedExpression() << '\n'; }
if ( result.getResultType() == ResultWas::ExplicitSkip ) { m_stream << "##teamcity[testIgnored"; } else if ( currentTestCaseInfo->okToFail() ) { msg << "- failure ignore as test marked as 'ok to fail'\n"; m_stream << "##teamcity[testIgnored"; } else { m_stream << "##teamcity[testFailed"; } m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\'' << " message='" << escape( msg.str() ) << '\'' << "]\n"; } m_stream.flush(); }
void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) { m_testTimer.start(); StreamingReporterBase::testCaseStarting(testInfo); m_stream << "##teamcity[testStarted name='" << escape(testInfo.name) << "']\n"; m_stream.flush(); }
void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) { StreamingReporterBase::testCaseEnded(testCaseStats); auto const& testCaseInfo = *testCaseStats.testInfo; if (!testCaseStats.stdOut.empty()) m_stream << "##teamcity[testStdOut name='" << escape(testCaseInfo.name) << "' out='" << escape(testCaseStats.stdOut) << "']\n"; if (!testCaseStats.stdErr.empty()) m_stream << "##teamcity[testStdErr name='" << escape(testCaseInfo.name) << "' out='" << escape(testCaseStats.stdErr) << "']\n"; m_stream << "##teamcity[testFinished name='" << escape(testCaseInfo.name) << "' duration='" << m_testTimer.getElapsedMilliseconds() << "']\n"; m_stream.flush(); }
void TeamCityReporter::printSectionHeader(std::ostream& os) { assert(!m_sectionStack.empty());
if (m_sectionStack.size() > 1) { os << lineOfChars('-') << '\n';
std::vector<SectionInfo>::const_iterator it = m_sectionStack.begin() + 1, // Skip first section (test case) itEnd = m_sectionStack.end(); for (; it != itEnd; ++it) printHeaderString(os, it->name); os << lineOfChars('-') << '\n'; }
SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
os << lineInfo << '\n'; os << lineOfChars('.') << "\n\n"; }
} // end namespace Catch
#if defined(_MSC_VER)#pragma warning(push)#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch // Note that 4062 (not all labels are handled // and default is missing) is enabled#endif
namespace Catch { XmlReporter::XmlReporter( ReporterConfig&& _config ) : StreamingReporterBase( CATCH_MOVE(_config) ), m_xml(m_stream) { m_preferences.shouldRedirectStdOut = true; m_preferences.shouldReportAllAssertions = true; }
XmlReporter::~XmlReporter() = default;
std::string XmlReporter::getDescription() { return "Reports test results as an XML document"; }
std::string XmlReporter::getStylesheetRef() const { return std::string(); }
void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) { m_xml .writeAttribute( "filename"_sr, sourceInfo.file ) .writeAttribute( "line"_sr, sourceInfo.line ); }
void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) { StreamingReporterBase::testRunStarting( testInfo ); std::string stylesheetRef = getStylesheetRef(); if( !stylesheetRef.empty() ) m_xml.writeStylesheetRef( stylesheetRef ); m_xml.startElement("Catch2TestRun") .writeAttribute("name"_sr, m_config->name()) .writeAttribute("rng-seed"_sr, m_config->rngSeed()) .writeAttribute("xml-format-version"_sr, 3) .writeAttribute("catch2-version"_sr, libraryVersion()); if ( m_config->testSpec().hasFilters() ) { m_xml.writeAttribute( "filters"_sr, m_config->testSpec() ); } }
void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) { StreamingReporterBase::testCaseStarting(testInfo); m_xml.startElement( "TestCase" ) .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) ) .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
writeSourceInfo( testInfo.lineInfo );
if ( m_config->showDurations() == ShowDurations::Always ) m_testCaseTimer.start(); m_xml.ensureTagClosed(); }
void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) { StreamingReporterBase::sectionStarting( sectionInfo ); if( m_sectionDepth++ > 0 ) { m_xml.startElement( "Section" ) .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) ); writeSourceInfo( sectionInfo.lineInfo ); m_xml.ensureTagClosed(); } }
void XmlReporter::assertionStarting( AssertionInfo const& ) { }
void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
AssertionResult const& result = assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
if( includeResults || result.getResultType() == ResultWas::Warning ) { // Print any info messages in <Info> tags. for( auto const& msg : assertionStats.infoMessages ) { if( msg.type == ResultWas::Info && includeResults ) { auto t = m_xml.scopedElement( "Info" ); writeSourceInfo( msg.lineInfo ); t.writeText( msg.message ); } else if ( msg.type == ResultWas::Warning ) { auto t = m_xml.scopedElement( "Warning" ); writeSourceInfo( msg.lineInfo ); t.writeText( msg.message ); } } }
// Drop out if result was successful but we're not printing them. if ( !includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip ) { return; }
// Print the expression if there is one. if( result.hasExpression() ) { m_xml.startElement( "Expression" ) .writeAttribute( "success"_sr, result.succeeded() ) .writeAttribute( "type"_sr, result.getTestMacroName() );
writeSourceInfo( result.getSourceInfo() );
m_xml.scopedElement( "Original" ) .writeText( result.getExpression() ); m_xml.scopedElement( "Expanded" ) .writeText( result.getExpandedExpression() ); }
// And... Print a result applicable to each result type. switch( result.getResultType() ) { case ResultWas::ThrewException: m_xml.startElement( "Exception" ); writeSourceInfo( result.getSourceInfo() ); m_xml.writeText( result.getMessage() ); m_xml.endElement(); break; case ResultWas::FatalErrorCondition: m_xml.startElement( "FatalErrorCondition" ); writeSourceInfo( result.getSourceInfo() ); m_xml.writeText( result.getMessage() ); m_xml.endElement(); break; case ResultWas::Info: m_xml.scopedElement( "Info" ) .writeText( result.getMessage() ); break; case ResultWas::Warning: // Warning will already have been written break; case ResultWas::ExplicitFailure: m_xml.startElement( "Failure" ); writeSourceInfo( result.getSourceInfo() ); m_xml.writeText( result.getMessage() ); m_xml.endElement(); break; case ResultWas::ExplicitSkip: m_xml.startElement( "Skip" ); writeSourceInfo( result.getSourceInfo() ); m_xml.writeText( result.getMessage() ); m_xml.endElement(); break; default: break; }
if( result.hasExpression() ) m_xml.endElement(); }
void XmlReporter::sectionEnded( SectionStats const& sectionStats ) { StreamingReporterBase::sectionEnded( sectionStats ); if ( --m_sectionDepth > 0 ) { { XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); e.writeAttribute( "successes"_sr, sectionStats.assertions.passed ); e.writeAttribute( "failures"_sr, sectionStats.assertions.failed ); e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk ); e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds ); } // Ends assertion tag m_xml.endElement(); } }
void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) { StreamingReporterBase::testCaseEnded( testCaseStats ); XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() ); e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() ); if( !testCaseStats.stdOut.empty() ) m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline ); if( !testCaseStats.stdErr.empty() ) m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
m_xml.endElement(); }
void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) { StreamingReporterBase::testRunEnded( testRunStats ); m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed ) .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed ) .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk ) .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped ); m_xml.scopedElement( "OverallResultsCases") .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed ) .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed ) .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk ) .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped ); m_xml.endElement(); }
void XmlReporter::benchmarkPreparing( StringRef name ) { m_xml.startElement("BenchmarkResults") .writeAttribute("name"_sr, name); }
void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) { m_xml.writeAttribute("samples"_sr, info.samples) .writeAttribute("resamples"_sr, info.resamples) .writeAttribute("iterations"_sr, info.iterations) .writeAttribute("clockResolution"_sr, info.clockResolution) .writeAttribute("estimatedDuration"_sr, info.estimatedDuration) .writeComment("All values in nano seconds"_sr); }
void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) { m_xml.scopedElement("mean") .writeAttribute("value"_sr, benchmarkStats.mean.point.count()) .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count()) .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count()) .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval); m_xml.scopedElement("standardDeviation") .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count()) .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count()) .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count()) .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval); m_xml.scopedElement("outliers") .writeAttribute("variance"_sr, benchmarkStats.outlierVariance) .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild) .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe) .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild) .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe); m_xml.endElement(); }
void XmlReporter::benchmarkFailed(StringRef error) { m_xml.scopedElement("failed"). writeAttribute("message"_sr, error); m_xml.endElement(); }
void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) { auto outerTag = m_xml.scopedElement("AvailableReporters"); for (auto const& reporter : descriptions) { auto inner = m_xml.scopedElement("Reporter"); m_xml.startElement("Name", XmlFormatting::Indent) .writeText(reporter.name, XmlFormatting::None) .endElement(XmlFormatting::Newline); m_xml.startElement("Description", XmlFormatting::Indent) .writeText(reporter.description, XmlFormatting::None) .endElement(XmlFormatting::Newline); } }
void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) { auto outerTag = m_xml.scopedElement( "RegisteredListeners" ); for ( auto const& listener : descriptions ) { auto inner = m_xml.scopedElement( "Listener" ); m_xml.startElement( "Name", XmlFormatting::Indent ) .writeText( listener.name, XmlFormatting::None ) .endElement( XmlFormatting::Newline ); m_xml.startElement( "Description", XmlFormatting::Indent ) .writeText( listener.description, XmlFormatting::None ) .endElement( XmlFormatting::Newline ); } }
void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) { auto outerTag = m_xml.scopedElement("MatchingTests"); for (auto const& test : tests) { auto innerTag = m_xml.scopedElement("TestCase"); auto const& testInfo = test.getTestCaseInfo(); m_xml.startElement("Name", XmlFormatting::Indent) .writeText(testInfo.name, XmlFormatting::None) .endElement(XmlFormatting::Newline); m_xml.startElement("ClassName", XmlFormatting::Indent) .writeText(testInfo.className, XmlFormatting::None) .endElement(XmlFormatting::Newline); m_xml.startElement("Tags", XmlFormatting::Indent) .writeText(testInfo.tagsAsString(), XmlFormatting::None) .endElement(XmlFormatting::Newline);
auto sourceTag = m_xml.scopedElement("SourceInfo"); m_xml.startElement("File", XmlFormatting::Indent) .writeText(testInfo.lineInfo.file, XmlFormatting::None) .endElement(XmlFormatting::Newline); m_xml.startElement("Line", XmlFormatting::Indent) .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None) .endElement(XmlFormatting::Newline); } }
void XmlReporter::listTags(std::vector<TagInfo> const& tags) { auto outerTag = m_xml.scopedElement("TagsFromMatchingTests"); for (auto const& tag : tags) { auto innerTag = m_xml.scopedElement("Tag"); m_xml.startElement("Count", XmlFormatting::Indent) .writeText(std::to_string(tag.count), XmlFormatting::None) .endElement(XmlFormatting::Newline); auto aliasTag = m_xml.scopedElement("Aliases"); for (auto const& alias : tag.spellings) { m_xml.startElement("Alias", XmlFormatting::Indent) .writeText(alias, XmlFormatting::None) .endElement(XmlFormatting::Newline); } } }
} // end namespace Catch
#if defined(_MSC_VER)#pragma warning(pop)#endif