From 4d2da1b9e492e6c76a1355c9fbd1cd62c9fc9129 Mon Sep 17 00:00:00 2001
From: Nico <nico.igramos@gmail.com>
Date: Fri, 6 Dec 2024 18:06:32 -0300
Subject: [PATCH] Tentando fazer as obras funcionares
---
.gitignore | 1 +
sources/ControladorObras.cpp | 39 +-
sources/ControladorObras.hpp | 4 +-
sources/ControladorObras.o | Bin 11336 -> 53008 bytes
sources/DescricaoObra.cpp | 14 +-
sources/DescricaoObra.hpp | 8 +-
sources/DescricaoObra.o | Bin 4920 -> 8216 bytes
sources/Livro.cpp | 17 +-
sources/Livro.o | Bin 6616 -> 14592 bytes
sources/Obra.cpp | 28 +-
sources/Obra.hpp | 2 +-
sources/Obra.o | Bin 5832 -> 13840 bytes
sources/Periodico.cpp | 4 +-
sources/Periodico.o | Bin 4856 -> 13488 bytes
tdd/Makefile | 32 +
tdd/doctest.h | 7106 ++++++++++++++++++++++++++++++++++
tdd/main.cpp | 2 +
tdd/obras-test.cpp | 40 +
18 files changed, 7244 insertions(+), 53 deletions(-)
create mode 100644 .gitignore
create mode 100644 tdd/Makefile
create mode 100644 tdd/doctest.h
create mode 100644 tdd/main.cpp
create mode 100644 tdd/obras-test.cpp
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5761abc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+*.o
diff --git a/sources/ControladorObras.cpp b/sources/ControladorObras.cpp
index d21b400..7449a1e 100644
--- a/sources/ControladorObras.cpp
+++ b/sources/ControladorObras.cpp
@@ -1,4 +1,5 @@
#include <iostream>
+#include <algorithm>
#include "./ControladorObras.hpp"
@@ -10,34 +11,42 @@ ControladorObras::ControladorObras() {}
// Method to display all Obras details
void ControladorObras::mostrarDetalhes() const {
- for (const auto& obra : obras) {
+ for (const auto& obra : this->obras) {
obra.mostrarDetalhes();
}
}
-
// Methods
-pair<int, int> ControladorObras::pesquisarObra(string tipo, DescricaoObra descricao){
- pair <int, int> p;
+pair<int, int> ControladorObras::pesquisarObra(DescricaoObra descricao){
+ pair <int, int> p = make_pair(0, 0);
+
+ auto it_obra = find_if(this->obras.begin(), this->obras.end(), [&descricao](Obra& d) {
+ d.mostrarDetalhes();
+ return descricao == d.getDescricaoObra();
+ });
+
+ if (it_obra != this->obras.end()) {
+ cout << "> Erro: Obra não encontrada" << endl;
+ } else {
+ p = make_pair(it_obra->getTotal(), it_obra->getDisponiveis());
+ }
return p;
}
+void ControladorObras::adicionarObra(DescricaoObra descricao){
+ auto it_obra = find_if(this->obras.begin(), this->obras.end(), [&descricao](Obra& d) {
+ return descricao == d.getDescricaoObra();
+ });
-bool ControladorObras::adicionarObra(string tipo, DescricaoObra descricao){
- // Check if exists
-
- if (tipo == "livro") {
-
- } else if (tipo == "periodico") {
-
-
+ if (it_obra == this->obras.end()) {
+ Obra obra(descricao);
+ this->obras.push_back(obra);
+ } else {
+ it_obra->adicionarObra();
}
-
- return true;
}
-
bool ControladorObras::solicitarEmprestimo(DescricaoObra descricao){
return true;
diff --git a/sources/ControladorObras.hpp b/sources/ControladorObras.hpp
index 19a0ac6..82958e7 100644
--- a/sources/ControladorObras.hpp
+++ b/sources/ControladorObras.hpp
@@ -19,8 +19,8 @@ class ControladorObras {
void mostrarDetalhes() const;
// Methods
- pair<int, int> pesquisarObra(string tipo, DescricaoObra descricao);
- bool adicionarObra(string tipo, DescricaoObra descricao);
+ pair<int, int> pesquisarObra(DescricaoObra descricao);
+ void adicionarObra(DescricaoObra descricao);
bool solicitarEmprestimo(DescricaoObra descricao);
bool devolverEmprestimo(DescricaoObra descricao);
diff --git a/sources/ControladorObras.o b/sources/ControladorObras.o
index c575f3e81849aa428491909aa0ae458191695abb..908ec4754d9bc2991fa28aca9bb1c84aded298be 100644
GIT binary patch
literal 53008
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
literal 11336
zcmb<-^>JfjWMqH=Mg}_u1P><4z~CW|U^{@B4h$v?#$dI=3=9k+3=CklC<6n77?dr+
zz`!60WlJ$IFi1n$G7Jn1vQV}h0|NudXpo%>P%%X)t;E2<pbTZJFfcHvLfL9iS{+Jj
zKxs_|28Pf4a=$`7I-hzpzY*~0to`B9?fS!`^Y{yplP8=!JON4G!K1VGM2bf@iz>(f
zk51Pgh6g;lT~By)y1ww}c6|ZU=F#bT1C9USwZ2EM>kT9oA3VBUKX`OAcytSZS)IrK
zUqVsR8~OmkzXsFQa-ekA1d#huJhUNhC}9P=^W<S9R~mS9*1quQEPde78F~ZVwZ~mQ
zfIJ4au{-ofiifrc*fVg0ko~Iw4v)^#4<4PNAP;`<=mo_VgGVQ_lf=M=VaV(NMG$iM
zfx@=4^aEHt7Aag&#gRNB&{_MZv-C%E?H|Tc>&Dt2|Nk>Elp1;TvVwg8jUqVr5S(?)
zqZ>uZ1Vr%c1DUZO<gyo&|Ns9ViyUs)VxLgz$jK}#%4aA@Ey~PK$xP12pPE212aC!H
zCl4c=4GQTO=yBB@`og2v^#f99gF_l?v>^o>cC%bxc=QHvkZfMCNAnvAc!EMs<J}S-
z-L4N{{sARq%ftLr4|sIP{y_E{D0V?Ps++;1H^2cB1fT@}11angYLEnB*%6fdx<f&^
z<p)wov>xD}asb&Lm~xO^(4>J9#xOgMgAxw|*d50mI6xdITL8qKfaCy>4zT5*YzlU=
zN2kDqSfqFZspxh^^9e`=$S62=cXqZ?&<IT`%_}KYFf`ON(KFCBECq87>x_)_3`{hk
z!eA{d3=9k)w}6tcyI&{+69dBmkQg&q7E*44n2c3H42%^5jM6;p91|EB7(itt2!rH6
z<s*YDpFkUvGcQ{h4?D=8AUPY5B((g*CLcpUz6L743`E1sXPOJP0A&6gkT?SagC~fF
z%R9j3_khG17#RFPG+f>dE`J9k&cMJR4x(Z5eqd>^|Nel)@yN@7ayA14gEmMVOn(wW
zzYSF02U(uU8LR;0{uroy0E)ajT)qY>Z;veR+RR+Y!_EQHKL;ugs(aw!8x7VDcK;rz
zJh&8vxz7h7e+MeBhirZ-LjDg_9#{OzFo85OFc^U-nE9Cq{Wef}P<;t^Uj#xv1}ZOv
ztltwMUjvorN0x^~AJ~6$pz>kJ@=U&913=-k2PzM$<KgxPfTck?uwsyxSr|V4$0o_l
z0Cow66f*<Z2Poo@HU>f*WG+krGXtna0^=cQW(IIfAq1c-W=IN!@(>g=1E>Xq;KNwV
z44~EwjEA6^!J&rW!&uA=pjHlyhoG4mKrJ2wAI4&40LLhd3#XYGKrJFT7tUa20H;tm
zAI4y20JW50JOs_m0BSiQ_%IeT1E?Vc;~{8f22jfi!3VKa85kIt82B0bp#cw0BMb}-
zp-}OsP;qeDU|?XV18D-c5Wx&Mu>{P5CL}N$LL3HDuu>At0TbWBBo~-OCOE+MaU%<X
z*^Xdw9xxl3=m3lJAq#=o8yFcFl#tR7IBzmAFkAzRBhmx7Ok!YQ;9|nA-T*9)NN+H6
z{Bek<FfcF(A*Fwq`aCA=;vG<NSPBA{;S3B6o51EH(kHlV1i2q94$8G)Z!&<(L<R<i
zA7F7rdV{&xh8g59nCT4g6jl!wN2F(P*~!4baETdG&p}K_kdK)m?mq?<0@o!B3=BRj
z5OD!;JV5IZ1_p+$EFgOk=^R{kg3=T#M12BOJ-AL`U|_I?idUeCm$QP*!HlofU~xo#
zfraxPus9;WfXiG428OR-aYTNBg_I2&$b3Y8ft5tfY}mu$7+5_bAHhnxcVKZ$_xuNo
zW4gzJ9b_-2d+NdBnC35M$L^l}AaTrW$8ZKD4vi~h>Jbj{UpT}Wob&Tait=+3Q}T=a
zlZq0H^^yw;7~-RXOMEQi<1_O!^D;{q;-gFq<Kv4<5=%0Z<3S>si8+~7i6xo&dGU#P
zDe)<(#U(|h$zZ-gW+p?tyN|z<qfdN%acNS#XMB8=pP?DLJ<dk1Weo9Ae!(S%M)6^(
z$tC$k@kxorsh%bvX9OpD1{=h?x;mS}RGF25)!>rGX9z+rGq)fIZe$|FEF?P+3Nc+`
zXby8F$dLGy#F9jqNtW^P>3OB`$rTlb=JD})`9-;jIq{h#sYQt;`9+=q-Vh&^z<dyF
z7!UHEVZ1BYe?i{C#_^z#Kr+TSFSR^AF()TK8EgdD03zK<T(}~93i6G!AuN;;;+P?T
zPzCb|*j*sMfTIc?q1dINc3?>fP#JGbDMQoT{Nj?L#3Gl}lEj>h)MAJ`y@TO_iQ)v)
zq}24xJp5{mQ}a@wDv$!4)Obrtg_uEs5d{V4M&za9Pb{uULEe7B@z@esNPGw=4uYNI
z8NeAeIXgZ%BRf7VF*660w6KJ%aY1TvVQFS@A~@T-`URJm$Agowp`lSyVsU12d~r!p
zW?s5ya&U>EVRA-dQG7{JVrEIPXR>Q>qGz(JtE-{0OKNd)QD$;tJ}A%PvM4bnGdVLq
zkE#|0m!uZrb{ROFaQO!uR3V_;7vLRi3eI_0g2%ErKPNLevm~*|HMgKBwYVfRH=jrk
zTco6x<>!>863~gi;6r3Ya0Z3tEqIv)6Tn+~Vk@(t8YxJ)&W5h=GRvC+b4)-*3?vVD
zlb-s_lk;;65{pt@1H6+#DG$jZ*h^2S$AjTP2rYI9!~>RMAF2__MpBCpXCp)qA{m3-
z;ZW;>ODr<;i@|lIiDzDB38XlVPbtoi&q&Nm$w`G*yZ&x&!LA|kA&yQyuHf{IuGIx>
zWPEZ(VtisrYDH!V1H1<X8uI|Po&NlX0PvUr0|Ns{9MqS9iN`}59UyT~>jx%Yh$Ieb
z{lLVhAc=!oV=(dMNaCPY5ls95lDHNF0|QK)6WV?R*^4Z$4;2SBmDrKgTS3J^>UELC
zJ)z<-^&lE#We8LpUHxXLI7l6+w*zy}Zm2j&y)}~ghoIsh^`P+|nEEqF;>hNJ`Yj;)
zL4LABGUpytJ;;1e8y;p3ti=ox2etCCiG#-Ov56ZZnGb8xg3JN6rD5t}?Rk*6F_L;W
zkRze#0pwPgdXQd_6uNpZkRTTIAh&^}K<Z79%+~=4Le(RSgXR}NQXuuFNa~Tp!3;?p
zq!xrh!3T;1SU(rmQv!*B#`-{NKo~Mt0_rO>FtC9Hpf~|agVcjCl*`ZnWq`y$7-sGQ
zG;vse3YMNhYC#y*pL&3%9@cMyb-_VuK^WF=QUG}f)X!pIU;vFTLbWqEAc=Fr1Q{3@
zVCI3$K<<q<AgM?0jW0kFNA8UuKoaLgGXDXRI7%-aWFgd@us#$>n*x$JXuK692Eq<V
z;({OnC{92U7lMj`s0Ji)<WZyrNa7$SY~14jhy!&GhzUy%40^?txh08740^>SMG!gz
z#wtq9Nz^Mzttes812y*<^pc8;8T8<ydW3r~pgIR#1NPQ2L}fn29ulm;(oR6NkYHPx
zIOWi0Gpb@l)kU4AD>$%0!HO^#TVoe*j|$wZh8sjl`vly^NAWNfTb(H8`XL%6;B){=
zbD&@dCaZM^_dErm2ydXk4WlF^VJ$tlVMs2+-sS-Z12`Lih8yA&i;5B}8T69#b8}Pk
zN*MI=@=H?n-2Fmzi%Sxdv!VR-yi&b_qWpr?qLNBzHciclPb*5yO=ZwaFUl`102Le*
z;^)i^49MjZ%s5#60V^{>bu4J?8&qF`)WB$5`eEaL$ofHJXE1#*8khbEkR=QZ49NOH
zbt6n4jK-xOG_DCU0$D$(y$90=qjBkng)OpvP`ePO4@TqC51Zpc)(>hA!t}vtT>3je
zjz_8!LE#T-XTtQsXk7XyV9^h1zrysvXk7YdK=mWLAJpE2>4VX@^h3tiQR5FZCJ)mG
zqjBlq0JR_1CII;#G`bAa2cvQ6-+@IxXdMVlAB@JOAJ)D>wjb1fgXx3Oxb&aEVn1jU
z9HtLOgW6f3CI@mG4W#t~h+tq~_y>}NvOyH6t_RUD4D%B#zrw^5K$(?+fdMqH01^X*
zAE?~|^A9L5fy6;+8e|2i?GEC@@Hupgpb{XpP$rlHwQoUY;?j?<9-R+r<ATK4(CmZR
zFAuf_L7*vP0Qn0Pmaz5~Or-$SgHQ^r4%Ds!xfP@aCY}ym!-H=BJE%p3>`#KW?a}Sm
zfLZ{h!1jaYIMD6yf!YtX4&*d2=7k0*a+?w)0SYS+4Z|~``qAAl2h|UoFM_E@w+GaZ
z#TI@JP=^~pHG;w!B!uq%8#wIug4z$O2cX7))*--{VEQtS@GAgW#=yXUY(FUfqubBU
z2wDGy?*C~}`(g7<V9TKGWf&VoGciKO0?^}c0T%l~`4`=O6CCzGgW3=3<AUsgVf6R|
z_4BcX{{<}egZjnj_V?njUkzj^17iLRW<PrTgZk+pH=&207gRqe&BFA8XmtImOxVLe
z9;zSK?*{1wVUS%Q8iqmrCy-L~@CPs8V?d1KfYKjmb`IVDwK(kW0~rciqXM%GOZ-<b
zVUK?aP-TT?KWJ<L-To;!>|Y19A2yBva{_w!UB;pR0aQO|><XqAM5F6hV8$N)Owhpq
z<US@g{kb^wi$L{*>I{%R7)G~$0W$*wsGkf??l5Hx8c_YP@PbLe_%M1lGc^2R3ZS$B
zmhcCS&%pFSvj@W(sQY2%1XMeN0n~m_{R9&O(XjLfqqjo!gXEBL3{*d|7>Eti2V#Tp
zQDz1P(D)pBxFkUJgX(vXIv9qzAI856wI5x7162PFGzoP5H*kcX2Q>Typ!z}iM<1y@
z2@5}vf1pZWP6E>rFpHoK6Hqz^jd8(*VfsO1Gw5*-G9Ut!C>R(Rz>CH}0#FRH56T2n
UpuPuI{h)>o0|Uc5G)Z**0I5&SMgRZ+
diff --git a/sources/DescricaoObra.cpp b/sources/DescricaoObra.cpp
index 9a5e05c..a038c1d 100644
--- a/sources/DescricaoObra.cpp
+++ b/sources/DescricaoObra.cpp
@@ -5,16 +5,24 @@
using namespace std;
// Constructor
-DescricaoObra::DescricaoObra(const std::string& t, int ano)
- : titulo(t), anoPublicacao(ano) {
-}
+DescricaoObra::DescricaoObra(const string& tipo, const string& titulo, int ano)
+ : tipo(tipo), titulo(titulo), anoPublicacao(ano) {}
void DescricaoObra::mostrarDetalhes() const {
cout << "Título: " << titulo << "\n";
cout << "Ano de Publicação: " << anoPublicacao << "\n";
}
+// Operators
+bool DescricaoObra::operator==(const DescricaoObra& other) const {
+ return this->titulo == other.titulo;
+}
+
// Methods
+string DescricaoObra::getTipo() {
+ return this->tipo;
+}
+
string DescricaoObra::getTitulo(){
return this->titulo;
}
diff --git a/sources/DescricaoObra.hpp b/sources/DescricaoObra.hpp
index 1a021ca..738ece8 100644
--- a/sources/DescricaoObra.hpp
+++ b/sources/DescricaoObra.hpp
@@ -9,19 +9,23 @@ class DescricaoObra {
private:
protected:
+ string tipo;
string titulo;
int anoPublicacao;
public:
// Contructor
DescricaoObra();
- DescricaoObra(const string& t, int ano);
+ DescricaoObra(const string& tipo, const string& titulo, int ano);
virtual void mostrarDetalhes() const;
+ // Operators
+ bool operator==(const DescricaoObra& other) const;
+
// Methods
string getTitulo();
+ string getTipo();
int getAnoPublicacao();
-
};
diff --git a/sources/DescricaoObra.o b/sources/DescricaoObra.o
index 7f8107649b776efe570d1b180cbc6599963cc976..8a180334ad540b9d1c4abe036f150cdf7b5ce5f2 100644
GIT binary patch
literal 8216
zcmb<-^>JfjWMqH=Mg}_u1P><4z#t)xU^{@B4h$*`%3!rT3=CkJmw|zS56Tu~U|<k}
zvV|EK7(}3KQ3eJEF(?~kB*-o)1_lOc1_p-D{BplSJvyHTdo;h%@aU|4;n7+8z@szt
zMyKx;k6w^Y29Ivn7apAgV5&EO!=u~vfk)>tkIw5aKyHExYj||K-ar%X4!zPD;PF}s
zWQRxRVX(^P0~{Wm$00g9Z@`(|u|G~82B`zN#iRL+fJbNT5073}unnEZ;4GNVLmu6(
zKRlWbXdqkJc?hl!;XDFnbUP3-VZzD76EIxXS^B}F+x3G-Zve>SP?ubTc?Z7^Pze6;
z=!B~Vc?G`?h#k0ffWoTV^+&gZM=VMpcGmvsEd9}3`-idAy0P}h|NjgOrAF{Df`%n5
zfRF>P8yfHsB@+-)vkzp(eoz8>G5P=h|47z>+yDucAN<=GIzbWifqxr=#UcJl2auFC
zzcD~gWggA7HyBE}c7Wpf<xB<!1~9ATKuLwian~Op(busa-JuUaVdTMh$fMi$1%!D5
zDF9mzl(6sk|NsC0*HIqbp-=@NwNPysYC-OQt>@9~`hyW{nzieVqM2ZuUrTs&hu-k$
z_62Eu;n8^x7NrwT9{&HIk=KTmfgzYRg`ts=m4PAT@Y<5noO~+<1}+B2ynKa}RE2=j
zq@2v;#KX%EF9wOj(v4#XD1U(xH6(w5a}*?SAsOQV%pMQR!==vPoC3`yo}EV^ISyI*
z3z%}B&PN`d_h7u%1EuUcz@B3T`^KaBh(NSsOzdG$KoXA)ja^cUlZ!Hw6Z8F(iV`t3
zx;r~tDQJWymFAU{Di|8-ndlkl8kT~&hIK|pdIlz%P+_oM76t|e0R{#JP@;183uRzp
zU^oC0V+PAY$|(?&u_}mxu|j}RnuncZ0wV*13<Cs%<kUfgE1y6clQS<{91lAORL%w@
z&cMKM1VqE+nRbH}fb@fe8LI+(z$UZL263ff=BqF;Fn};fu!n(x0punIm>I6k%uID)
zW5DiM0#d}lzyM04a5YR5zzRV2fbC~sU@!!!gPD;5mImv80usj~&jN}zJn||~d2opg
zGv5bdz5)XSg9}u?17r_O-o1ypnT4qWqzdH545*qgWHn5_AZZ4W868l0No4r|urx>n
zCkAO_VfgqTn*wGAP)uRUFf(vt3NkP-Ff)K^HcTmI22f3hDh{gS7?I2YxdWzxnSme1
zM4_3%DG@~o%wc8#)t+D`oKRw5U|?e4V7Lf17#wa43=Ba~adjq$QgC=NFfeRnU|>)}
zaz8lDGB7Y)1dAiw4@)cGq4@%03W5aXI3c8P1Eo!n>^}wu21O=N%?;u)z*R^wGB7AI
zfI<TzE&-t!^cW%e4$6g7IXJ|Z;SguVA-<In)ZReEFU*~+Ob~GxADm|x7#MVzu)D_$
zhj<<i@k=<w??CNUgT@y)FETJNd}jj13nG5Od4z$1p`IDy&ImO1i=pCOXyPZK;(MUt
z;JnDd!0>??yT9~Uu#4xgfZ_|L8=<BFhx%n;^`Mp;Bnm-gDTuWThx$t(acJ5Ese|GB
zAaNK6iT;X1oR<~hHYDW?3@FuuUUESJLwr<liH}8md}e-TUS<hHe3Xe{e0*_9Vo7Fl
zJV+!nF(<Psu_QA;FFr9ZB|as!xTL5w8O%4x%w&jn_wjdf^ofrzE=`K}jE|4<L#u<F
zja-Ag{enx(<KvSnDhv$`jgk_JGn3<sONuh{(mj)dOAHN@GZKs9ONtURONu>{U4s)n
zlU-e1gU#bJ8RDb-Fclc(l(+_YCkGqFW0yBi&d)7KEJ}3^04vI6$W6^n&MjbY3D+x1
zP1B2yPp_zmFGwva&d*EC$t<aiFEe0>j|vGxb2-FtQr+!r=o;i5Yyx!}sk&VZUCS8a
zL-Wcr^HSo2Qj1G-Q$fx^a~aqUO2X6|%|Jub-2CE_qQoMX)RM%UjMQR~E24r+Op^0U
zL1`kmB&XODGa_7rf=djIA@K>)pPHEKnH&=D8f+RL;GGOkS~<nIqZo_skoXXTcu>^i
zOEbYH@xi9?A%^j;uAsmP&d(`!1t%4BZ>1K3;sO*E!6m7Mp2@C$mhtiFd8Lq)7$2XS
zmzb238lRcw8BtsmTw)m?pIICaN{pT%@vi3a@nwlQrKzq-u4eJ^C6xuKcoTB4aXfke
z1slhM5;KT$bq#g}xdT0Sn5U<fgk%=vJDGwr2RPW#)mVbnfZD70R2iD3r<OS8<wM)C
z$%*+8!@Nn)dM3r0RjK6bPDw0D1nUm*L`!DiT;^wJ04@p=lQPQ;4M7<sC$YE~9Ki9J
zd1?8eI1LHL)ae&oVv(6&9G{d}oND5kms#Qr&MWaL#rg3WiFqkGsqn(c-_0%9H6%X7
z(a8rA>gZY_*(^S}A~8O(B();51X@VSLupVE461ctEgD;>IH;Wo>Zkt!^;!P^{~v-w
zyc|g!RJ+5}HzA3G`uH&M`A~6?y`WkdCcY9$9Mm>|iG$iJASsZ0Ky4V9_;HXRv^@-J
zZNS7q?HG_0%zQQwhk=3N4wObW=P^_qrXJ)bkkDHY0d7MvFd)0<D^wia98PF`3lay7
zS-{*Q3>Al&4|9(kR2-xp*<XQ3;<5}33@~%*k;IYXWg`ypuTXK2y`Vk}%$&baage=g
zNanME6hi$AY7@fL^C5{Nn<D`g*J5B`&_psv0V)nMA0!7eClV>#Kxqvo-ikwfFOoQD
z><FeFmTp1jD<avehol}^+#ZLxACfqz4Gl9t7KeB?k~pZ93{wwFFQ8ymhN=Nku=Wo~
z9MLKQ$v`kj9MrFasY5nL6`}-%1gQrFEv!8clLUz)T4@a6J`zX{q!tuLAT|g?#^ykM
z1xOzkBnHATe}UA)+yWAB01?pi0Fr}p89Jd1kQh6Z4Wd?n2qg8ecJ&D~aag+-Ji3OY
z9@f6)0C@;W9M-<oKof_xZ#|I2IiYreC{X_aM1$N3!m$2P50ZM2I6OS{iYs$V5|bG8
zic5+hbOwx7l$w*MSCU#$!k`B#@fq}zii;V*0(yj6ZF+FM*p*^5;PldyljBn>l2Z#x
z;!8kvHiKSKKEzgJqXtJU5Ahwybs&~rQNCVIesW@t9=0YXNJSzz{6H*_+W08UY7^>N
zkO>$SBS>GO9;l@rpIB6sSjhkpfLjl-8(-5`FF8LqH#M(>K`$@ABvsGdFI2a<Br!P~
z%1_TL)hj5<FGwvaff=5f5ua9+n48L=mtK@#S^!E>lwnZ$2&!+<O@ZZ4SUCVH!$9RE
zEDytIT>3qr27>f}m>~V2atfvoM&r^CtKX6JgX$lcJ{XNle*(x-1_t=Z0?2-lKVkY{
zG%o!)SoDL+Q<y#&jZ1$8R6la~fyz;sJ{XNlKdih%_CKgRgz1CPpfM;=5dy2nq1H0M
z$~y;8p#l?xmSad<@O%cyELeQQ<Q_nWf(oGeLE#7T3kZYMfZ8A+8dPV4><87wAU+JA
zf$D?tVKhiBj18i77$9RZxb&l|N9TjaD?nmwX!gPE2elnQ_P{VmEsPDKW1w?9==wiH
z&4Z0Qfz*O9y8duzn-4vl13--;1_lOLJ^+OuDE*^{A81?!WG2))kQHFO9U35@Gz%7h
z5+JouCYYK9bw9fP6Hxu2wggxqlt9<N9I7AP|F59>LGFWU1ykty7vb>#45<GnfOUb!
zZWzF$h3NjbVuZ}eF{62)0+c8jAZ=Z!5nu|YAIxE3U@&Ebj6tJ^zXquB&%nT7096PI
ze~=JNKP>&G;jn)K)P7K&gBk&*VEVxv1_p*i9QH?mEJL#&)GmVQhuPl_wVw&i{|j)~
zkM5oojF7oZXmr7x#jpXYA7&p+0>+2Yi(&4EDS*-)Q1`>!2?{?D8>SD$1}WVMbw7Ii
z?I2)3NG}L)f!UAle=PQc`c>%mKZV*4i)WCTAPk-?0ga!6I7k?leqr=GsD30RVCEaB
z`@tL}0;Ufp^pBB&0o3k9b3VfdsD4oS3{wlDVeSX9L0F6llK#>43xFnm7#J8p@e5K1
z!|3`2nV{((rT|LsfQFw1)WM+m1NBv4`eE@0l18^1WW)|=g~9>#2dEqY)kWy~L2X?0
vv<K3EfD1%2Fi1iD0pUUX3S)z4Q2B;U{|8Vfoq>S?-W~=ihL%-OCYS;M4YJD<
literal 4920
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
Le}Q=j0$o1<>$ed7
diff --git a/sources/Livro.cpp b/sources/Livro.cpp
index 3070c8d..3d5eb71 100644
--- a/sources/Livro.cpp
+++ b/sources/Livro.cpp
@@ -5,20 +5,8 @@
using namespace std;
-// Contructor
- //Livro::Livro() {
- // // Dados da Descricao da obra
- // cout << "Entre com o titulo da obra: "; cin >> titulo;
- // cout << "Entre com o ano da obra: "; cin >> anoPublicacao;
- //
- // // Dados do Livro
- // cout << "Entre com o autor: "; cin >> autor;
- // cout << "Entre com a editora: "; cin >> editora;
- //}
-
Livro::Livro(const string& t, int ano, const string& a, const string& e)
- : DescricaoObra(t, ano), autor(a), editora(e) {}
-
+ : DescricaoObra("livro", t, ano), autor(a), editora(e) {}
// Description
void Livro::mostrarDetalhes() const {
@@ -27,7 +15,6 @@ void Livro::mostrarDetalhes() const {
cout << "Editora: " << editora << "\n";
}
-
// Methods
string Livro::getAutor(){
return this->autor;
@@ -36,5 +23,3 @@ string Livro::getAutor(){
string Livro::getEditora(){
return this->editora;
}
-
-
diff --git a/sources/Livro.o b/sources/Livro.o
index 748592bd67a35cba6ab216855342db59f071be8d..e2a8e858996ace76a6dbe9851711ee800ca7d531 100644
GIT binary patch
literal 14592
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
literal 6616
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
BEiwQA
diff --git a/sources/Obra.cpp b/sources/Obra.cpp
index 1a584cd..e42f919 100644
--- a/sources/Obra.cpp
+++ b/sources/Obra.cpp
@@ -1,13 +1,13 @@
#include <iostream>
#include "./Obra.hpp"
-#include "DescricaoObra.hpp"
+#include "./DescricaoObra.hpp"
+#include "./Livro.hpp"
+#include "./Periodico.hpp"
// Constructor
-Obra::Obra(DescricaoObra desc, int disp, int total)
- : descricao(desc), disponiveis(disp), total(total){
-
-}
+Obra::Obra(DescricaoObra descricao)
+ : descricao(descricao), disponiveis(1), total(1) {}
void Obra::mostrarDetalhes() const {
this->descricao.mostrarDetalhes();
@@ -15,7 +15,6 @@ void Obra::mostrarDetalhes() const {
std::cout << "Quantidade total: " << total << "\n";
}
-
// Methods
bool Obra::emprestar(){
return 0;
@@ -26,11 +25,18 @@ void Obra::devolver(){
}
void Obra::adicionarObra(){
-
-}
-
-DescricaoObra Obra::getDescricaoObra(){
- return this->descricao;
+ this->total++;
+ this->disponiveis++;
+}
+
+DescricaoObra Obra::getDescricaoObra() {
+ if (this->descricao.getTipo() == "livro") {
+ Livro l = static_cast<Livro&>(this->descricao);
+ return Livro(l.getTitulo(), l.getAnoPublicacao(), l.getAutor(), l.getEditora());
+ } else {
+ Periodico p = static_cast<Periodico&>(this->descricao);
+ return Periodico(p.getTitulo(), p.getAnoPublicacao(), p.getVolume(), p.getMes());
+ }
}
int Obra::getDisponiveis(){
diff --git a/sources/Obra.hpp b/sources/Obra.hpp
index de0e1a7..f550c6a 100644
--- a/sources/Obra.hpp
+++ b/sources/Obra.hpp
@@ -12,7 +12,7 @@ class Obra {
public:
// Contructor
Obra();
- Obra(DescricaoObra descricao, int disponiveis, int total);
+ Obra(DescricaoObra descricao);
virtual void mostrarDetalhes() const;
// Methods
diff --git a/sources/Obra.o b/sources/Obra.o
index 7681d4f706482224b0776a391961f459aa0bf813..98833e4698d1967dcbd20e21b94a2e47ce8bb644 100644
GIT binary patch
literal 13840
zcmb<-^>JfjWMqH=Mg}_u1P><4z%W4r!FB*M9T?0QOu=de85kIZ7#J9Y85qEP5e5bZ
zQ7BuSfq_ASfq_91%9mnbV33BgWf&M3WT9+11_lOsC|iMnfk6?<R%T#eP=T^l85kJU
zplo#p1_qFmKyKB9is>*gFz7NcFns2h`xWZZ`P8HNjetjI?GKO6(hnZJAQv%sbi4lW
z=oA1`y#X8^-L4-zI*)mDUVj1d6G-^DLj=f72r~x6oN)3mhKV3!nh$VzbRLIj>}3V(
z?>y!KV?iZ44}nbTc8EZ-rSlM66~bzmKAa}R5HMlF$-@)i?(D4nu><6ySX8kIXncs<
zVtNA@L9EVz7!cL%5CIp6K-S?H>KGF2(fDQsBLjm+=U$J0|Nnb*Zgu$g|9^@{H;XDL
zIy^dEZx|l%=xzmxdVoT>x7Fc4NZmC=SV2Uf5z+~l=sfHJQw#~bmfQR-d?33}jN1UV
z7Ou;qw{-$Yq<1Q&L;)@dh*F3xU~2<#sO*KB4KZmeL>buqo}DK=IxlwKLU?N`*rVO8
zkZ?hEAXoyPR9eBNAh=+&5nQm12rjZyUzQOO8ps+PJCAzwwxWt0K@$P{A8aX>AlwR(
z0Q=ar^My<2L$Z7fHU)>D7D02Y2iPIVVe^_Dl%65t$bp0`j%+frII^ETI&Z*Y31J|K
z8a=vQZ=`r=LsEGOD<s!L<GS$(C`Uv)#yG}e&0i5%MPp)7ij~gVKb@sNnrr_smRdK~
z{`mi&fuYn0UQR%gDx8a4fOJEP9*7d8!fGGLjQyYz?8W5&|NkSb3-)M!BjM3m`@*BM
z^Z}w^d;uvKUwD8Dw(ige9?ge1JP_H_quUiErQrdQ(m<7Z&>i3bQqdXU@mdKM$`Boh
zQW6ml9^J7&P9FaMpOM#+m4P9IHIt!@krhkH4J{-<#VxedZa$y^i%d{q1$HbnWlcDF
zIIuJ^uOu@iF(p+YC9}97KQFT^HOESUfr|l2rX;^45hR$CSyq$}uPsnR1>|&)N0Iyw
zcMDQL1wcb105vo~0aXB%DnOEYZH^i=0Why1k}k+%sDF^sEj+x0lvx=Vd|2BV8PZwv
z7#4s64ekSYeFt|bysm3LPyn+E8ftK>!F;HV6HXq+G!1+02}vX$FcZlS4^R|!hk~Tg
z63GWhBKgr7;DOU7P*j67V+(kwcRq9n_<&s938p@D2LwQP0Z54-Pgo%Q`u{(pk!J`4
z!$wBdRjdrB7+EK=GTdZT_{GAofQj`H3&S#IRtAQx%r1{v878r?o@Qk@#%hNpk%9sU
z<YbW35zcNsz(3`{$-|±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
b2H6LqVHniDz^4BND6=v!Ff2xM9J+o0v%Ykh
literal 5832
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
diff --git a/sources/Periodico.cpp b/sources/Periodico.cpp
index 95da272..dac1632 100644
--- a/sources/Periodico.cpp
+++ b/sources/Periodico.cpp
@@ -4,7 +4,7 @@
// Contructor
Periodico::Periodico(const std::string& t, int ano, int vol, int m)
- : DescricaoObra(t, ano), volume(vol), mes(m) {}
+ : DescricaoObra("periodico", t, ano), volume(vol), mes(m) {}
void Periodico::mostrarDetalhes() const {
DescricaoObra::mostrarDetalhes();
@@ -19,5 +19,3 @@ int Periodico::getVolume(){
int Periodico::getMes(){
return this->mes;
}
-
-
diff --git a/sources/Periodico.o b/sources/Periodico.o
index f323539898ae8b5d89a8eeda5432f37826f38371..e8d98d8378267cd2fc90b85ef330841542419b1b 100644
GIT binary patch
literal 13488
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
literal 4856
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
diff --git a/tdd/Makefile b/tdd/Makefile
new file mode 100644
index 0000000..662b868
--- /dev/null
+++ b/tdd/Makefile
@@ -0,0 +1,32 @@
+# Variáveis
+CXX = g++
+CXXFLAGS = -I../sources
+LDFLAGS = -lm
+SRCS = main.cpp obras-test.cpp \
+ ../sources/ControladorObras.cpp \
+ ../sources/Periodico.cpp \
+ ../sources/Livro.cpp \
+ ../sources/DescricaoObra.cpp \
+ ../sources/Obra.cpp
+OBJ = $(SRCS:.cpp=.o)
+TARGET = main
+
+# Regras
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+ $(CXX) $(OBJ) $(LDFLAGS) -o $(TARGET)
+
+# Regra para compilar arquivos .cpp para .o
+%.o: %.cpp
+ $(CXX) $(CXXFLAGS) -c $< -o $@
+
+# Limpar arquivos gerados
+clean:
+ rm -f $(OBJ) $(TARGET)
+
+# Rebuild completo
+rebuild: clean all
+
+.PHONY: all clean rebuild
+
diff --git a/tdd/doctest.h b/tdd/doctest.h
new file mode 100644
index 0000000..5c754cd
--- /dev/null
+++ b/tdd/doctest.h
@@ -0,0 +1,7106 @@
+// ====================================================================== lgtm [cpp/missing-header-guard]
+// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! ==
+// ======================================================================
+//
+// doctest.h - the lightest feature-rich C++ single-header testing framework for unit tests and TDD
+//
+// Copyright (c) 2016-2023 Viktor Kirilov
+//
+// Distributed under the MIT Software License
+// See accompanying file LICENSE.txt or copy at
+// https://opensource.org/licenses/MIT
+//
+// The documentation can be found at the library's page:
+// https://github.com/doctest/doctest/blob/master/doc/markdown/readme.md
+//
+// =================================================================================================
+// =================================================================================================
+// =================================================================================================
+//
+// The library is heavily influenced by Catch - https://github.com/catchorg/Catch2
+// which uses the Boost Software License - Version 1.0
+// see here - https://github.com/catchorg/Catch2/blob/master/LICENSE.txt
+//
+// The concept of subcases (sections in Catch) and expression decomposition are from there.
+// Some parts of the code are taken directly:
+// - stringification - the detection of "ostream& operator<<(ostream&, const T&)" and StringMaker<>
+// - the Approx() helper class for floating point comparison
+// - colors in the console
+// - breaking into a debugger
+// - signal / SEH handling
+// - timer
+// - XmlWriter class - thanks to Phil Nash for allowing the direct reuse (AKA copy/paste)
+//
+// The expression decomposing templates are taken from lest - https://github.com/martinmoene/lest
+// which uses the Boost Software License - Version 1.0
+// see here - https://github.com/martinmoene/lest/blob/master/LICENSE.txt
+//
+// =================================================================================================
+// =================================================================================================
+// =================================================================================================
+
+#ifndef DOCTEST_LIBRARY_INCLUDED
+#define DOCTEST_LIBRARY_INCLUDED
+
+// =================================================================================================
+// == VERSION ======================================================================================
+// =================================================================================================
+
+#define DOCTEST_VERSION_MAJOR 2
+#define DOCTEST_VERSION_MINOR 4
+#define DOCTEST_VERSION_PATCH 11
+
+// util we need here
+#define DOCTEST_TOSTR_IMPL(x) #x
+#define DOCTEST_TOSTR(x) DOCTEST_TOSTR_IMPL(x)
+
+#define DOCTEST_VERSION_STR \
+ DOCTEST_TOSTR(DOCTEST_VERSION_MAJOR) "." \
+ DOCTEST_TOSTR(DOCTEST_VERSION_MINOR) "." \
+ DOCTEST_TOSTR(DOCTEST_VERSION_PATCH)
+
+#define DOCTEST_VERSION \
+ (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH)
+
+// =================================================================================================
+// == COMPILER VERSION =============================================================================
+// =================================================================================================
+
+// ideas for the version stuff are taken from here: https://github.com/cxxstuff/cxx_detect
+
+#ifdef _MSC_VER
+#define DOCTEST_CPLUSPLUS _MSVC_LANG
+#else
+#define DOCTEST_CPLUSPLUS __cplusplus
+#endif
+
+#define DOCTEST_COMPILER(MAJOR, MINOR, PATCH) ((MAJOR)*10000000 + (MINOR)*100000 + (PATCH))
+
+// GCC/Clang and GCC/MSVC are mutually exclusive, but Clang/MSVC are not because of clang-cl...
+#if defined(_MSC_VER) && defined(_MSC_FULL_VER)
+#if _MSC_VER == _MSC_FULL_VER / 10000
+#define DOCTEST_MSVC DOCTEST_COMPILER(_MSC_VER / 100, _MSC_VER % 100, _MSC_FULL_VER % 10000)
+#else // MSVC
+#define DOCTEST_MSVC \
+ DOCTEST_COMPILER(_MSC_VER / 100, (_MSC_FULL_VER / 100000) % 100, _MSC_FULL_VER % 100000)
+#endif // MSVC
+#endif // MSVC
+#if defined(__clang__) && defined(__clang_minor__) && defined(__clang_patchlevel__)
+#define DOCTEST_CLANG DOCTEST_COMPILER(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#elif defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && \
+ !defined(__INTEL_COMPILER)
+#define DOCTEST_GCC DOCTEST_COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#endif // GCC
+#if defined(__INTEL_COMPILER)
+#define DOCTEST_ICC DOCTEST_COMPILER(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif // ICC
+
+#ifndef DOCTEST_MSVC
+#define DOCTEST_MSVC 0
+#endif // DOCTEST_MSVC
+#ifndef DOCTEST_CLANG
+#define DOCTEST_CLANG 0
+#endif // DOCTEST_CLANG
+#ifndef DOCTEST_GCC
+#define DOCTEST_GCC 0
+#endif // DOCTEST_GCC
+#ifndef DOCTEST_ICC
+#define DOCTEST_ICC 0
+#endif // DOCTEST_ICC
+
+// =================================================================================================
+// == COMPILER WARNINGS HELPERS ====================================================================
+// =================================================================================================
+
+#if DOCTEST_CLANG && !DOCTEST_ICC
+#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
+#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH _Pragma("clang diagnostic push")
+#define DOCTEST_CLANG_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(clang diagnostic ignored w)
+#define DOCTEST_CLANG_SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop")
+#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING(w)
+#else // DOCTEST_CLANG
+#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+#define DOCTEST_CLANG_SUPPRESS_WARNING(w)
+#define DOCTEST_CLANG_SUPPRESS_WARNING_POP
+#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)
+#endif // DOCTEST_CLANG
+
+#if DOCTEST_GCC
+#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
+#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH _Pragma("GCC diagnostic push")
+#define DOCTEST_GCC_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(GCC diagnostic ignored w)
+#define DOCTEST_GCC_SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop")
+#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w) \
+ DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_GCC_SUPPRESS_WARNING(w)
+#else // DOCTEST_GCC
+#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH
+#define DOCTEST_GCC_SUPPRESS_WARNING(w)
+#define DOCTEST_GCC_SUPPRESS_WARNING_POP
+#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)
+#endif // DOCTEST_GCC
+
+#if DOCTEST_MSVC
+#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH __pragma(warning(push))
+#define DOCTEST_MSVC_SUPPRESS_WARNING(w) __pragma(warning(disable : w))
+#define DOCTEST_MSVC_SUPPRESS_WARNING_POP __pragma(warning(pop))
+#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w) \
+ DOCTEST_MSVC_SUPPRESS_WARNING_PUSH DOCTEST_MSVC_SUPPRESS_WARNING(w)
+#else // DOCTEST_MSVC
+#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
+#define DOCTEST_MSVC_SUPPRESS_WARNING(w)
+#define DOCTEST_MSVC_SUPPRESS_WARNING_POP
+#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)
+#endif // DOCTEST_MSVC
+
+// =================================================================================================
+// == COMPILER WARNINGS ============================================================================
+// =================================================================================================
+
+// both the header and the implementation suppress all of these,
+// so it only makes sense to aggregate them like so
+#define DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH \
+ DOCTEST_CLANG_SUPPRESS_WARNING_PUSH \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas") \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables") \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded") \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes") \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat") \
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic") \
+ \
+ DOCTEST_GCC_SUPPRESS_WARNING_PUSH \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast") \
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept") \
+ \
+ DOCTEST_MSVC_SUPPRESS_WARNING_PUSH \
+ /* these 4 also disabled globally via cmake: */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4514) /* unreferenced inline function has been removed */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4571) /* SEH related */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4710) /* function not inlined */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4711) /* function selected for inline expansion*/ \
+ /* common ones */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4616) /* invalid compiler warning */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4619) /* invalid compiler warning */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4996) /* The compiler encountered a deprecated declaration */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4706) /* assignment within conditional expression */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4512) /* 'class' : assignment operator could not be generated */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4127) /* conditional expression is constant */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4640) /* construction of local static object not thread-safe */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5264) /* 'variable-name': 'const' variable is not used */ \
+ /* static analysis */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(26439) /* Function may not throw. Declare it 'noexcept' */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(26495) /* Always initialize a member variable */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(26451) /* Arithmetic overflow ... */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(26444) /* Avoid unnamed objects with custom ctor and dtor... */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(26812) /* Prefer 'enum class' over 'enum' */
+
+#define DOCTEST_SUPPRESS_COMMON_WARNINGS_POP \
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP \
+ DOCTEST_GCC_SUPPRESS_WARNING_POP \
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
+
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wnon-virtual-dtor")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wdeprecated")
+
+DOCTEST_GCC_SUPPRESS_WARNING_PUSH
+DOCTEST_GCC_SUPPRESS_WARNING("-Wctor-dtor-privacy")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wnon-virtual-dtor")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-promo")
+
+DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
+DOCTEST_MSVC_SUPPRESS_WARNING(4623) // default constructor was implicitly defined as deleted
+
+#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN \
+ DOCTEST_MSVC_SUPPRESS_WARNING_PUSH \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4548) /* before comma no effect; expected side - effect */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4265) /* virtual functions, but destructor is not virtual */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4986) /* exception specification does not match previous */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4350) /* 'member1' called instead of 'member2' */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4668) /* not defined as a preprocessor macro */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4365) /* signed/unsigned mismatch */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4774) /* format string not a string literal */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4623) /* default constructor was implicitly deleted */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5039) /* pointer to pot. throwing function passed to extern C */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5105) /* macro producing 'defined' has undefined behavior */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(4738) /* storing float result in memory, loss of performance */ \
+ DOCTEST_MSVC_SUPPRESS_WARNING(5262) /* implicit fall-through */
+
+#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+// =================================================================================================
+// == FEATURE DETECTION ============================================================================
+// =================================================================================================
+
+// general compiler feature support table: https://en.cppreference.com/w/cpp/compiler_support
+// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx
+// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html
+// MSVC version table:
+// https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
+// MSVC++ 14.3 (17) _MSC_VER == 1930 (Visual Studio 2022)
+// MSVC++ 14.2 (16) _MSC_VER == 1920 (Visual Studio 2019)
+// MSVC++ 14.1 (15) _MSC_VER == 1910 (Visual Studio 2017)
+// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
+// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
+// MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008)
+// MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005)
+
+// Universal Windows Platform support
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define DOCTEST_CONFIG_NO_WINDOWS_SEH
+#endif // WINAPI_FAMILY
+#if DOCTEST_MSVC && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
+#define DOCTEST_CONFIG_WINDOWS_SEH
+#endif // MSVC
+#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH)
+#undef DOCTEST_CONFIG_WINDOWS_SEH
+#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH
+
+#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && \
+ !defined(__EMSCRIPTEN__) && !defined(__wasi__)
+#define DOCTEST_CONFIG_POSIX_SIGNALS
+#endif // _WIN32
+#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS)
+#undef DOCTEST_CONFIG_POSIX_SIGNALS
+#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND) \
+ || defined(__wasi__)
+#define DOCTEST_CONFIG_NO_EXCEPTIONS
+#endif // no exceptions
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+#define DOCTEST_CONFIG_NO_EXCEPTIONS
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+
+#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS)
+#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
+
+#ifdef __wasi__
+#define DOCTEST_CONFIG_NO_MULTITHREADING
+#endif
+
+#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT)
+#define DOCTEST_CONFIG_IMPLEMENT
+#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#if DOCTEST_MSVC
+#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport)
+#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport)
+#else // MSVC
+#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport))
+#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport))
+#endif // MSVC
+#else // _WIN32
+#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default")))
+#define DOCTEST_SYMBOL_IMPORT
+#endif // _WIN32
+
+#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
+#ifdef DOCTEST_CONFIG_IMPLEMENT
+#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT
+#else // DOCTEST_CONFIG_IMPLEMENT
+#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT
+#endif // DOCTEST_CONFIG_IMPLEMENT
+#else // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
+#define DOCTEST_INTERFACE
+#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
+
+// needed for extern template instantiations
+// see https://github.com/fmtlib/fmt/issues/2228
+#if DOCTEST_MSVC
+#define DOCTEST_INTERFACE_DECL
+#define DOCTEST_INTERFACE_DEF DOCTEST_INTERFACE
+#else // DOCTEST_MSVC
+#define DOCTEST_INTERFACE_DECL DOCTEST_INTERFACE
+#define DOCTEST_INTERFACE_DEF
+#endif // DOCTEST_MSVC
+
+#define DOCTEST_EMPTY
+
+#if DOCTEST_MSVC
+#define DOCTEST_NOINLINE __declspec(noinline)
+#define DOCTEST_UNUSED
+#define DOCTEST_ALIGNMENT(x)
+#elif DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 5, 0)
+#define DOCTEST_NOINLINE
+#define DOCTEST_UNUSED
+#define DOCTEST_ALIGNMENT(x)
+#else
+#define DOCTEST_NOINLINE __attribute__((noinline))
+#define DOCTEST_UNUSED __attribute__((unused))
+#define DOCTEST_ALIGNMENT(x) __attribute__((aligned(x)))
+#endif
+
+#ifdef DOCTEST_CONFIG_NO_CONTRADICTING_INLINE
+#define DOCTEST_INLINE_NOINLINE inline
+#else
+#define DOCTEST_INLINE_NOINLINE inline DOCTEST_NOINLINE
+#endif
+
+#ifndef DOCTEST_NORETURN
+#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
+#define DOCTEST_NORETURN
+#else // DOCTEST_MSVC
+#define DOCTEST_NORETURN [[noreturn]]
+#endif // DOCTEST_MSVC
+#endif // DOCTEST_NORETURN
+
+#ifndef DOCTEST_NOEXCEPT
+#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
+#define DOCTEST_NOEXCEPT
+#else // DOCTEST_MSVC
+#define DOCTEST_NOEXCEPT noexcept
+#endif // DOCTEST_MSVC
+#endif // DOCTEST_NOEXCEPT
+
+#ifndef DOCTEST_CONSTEXPR
+#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
+#define DOCTEST_CONSTEXPR const
+#define DOCTEST_CONSTEXPR_FUNC inline
+#else // DOCTEST_MSVC
+#define DOCTEST_CONSTEXPR constexpr
+#define DOCTEST_CONSTEXPR_FUNC constexpr
+#endif // DOCTEST_MSVC
+#endif // DOCTEST_CONSTEXPR
+
+#ifndef DOCTEST_NO_SANITIZE_INTEGER
+#if DOCTEST_CLANG >= DOCTEST_COMPILER(3, 7, 0)
+#define DOCTEST_NO_SANITIZE_INTEGER __attribute__((no_sanitize("integer")))
+#else
+#define DOCTEST_NO_SANITIZE_INTEGER
+#endif
+#endif // DOCTEST_NO_SANITIZE_INTEGER
+
+// =================================================================================================
+// == FEATURE DETECTION END ========================================================================
+// =================================================================================================
+
+#define DOCTEST_DECLARE_INTERFACE(name) \
+ virtual ~name(); \
+ name() = default; \
+ name(const name&) = delete; \
+ name(name&&) = delete; \
+ name& operator=(const name&) = delete; \
+ name& operator=(name&&) = delete;
+
+#define DOCTEST_DEFINE_INTERFACE(name) \
+ name::~name() = default;
+
+// internal macros for string concatenation and anonymous variable name generation
+#define DOCTEST_CAT_IMPL(s1, s2) s1##s2
+#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2)
+#ifdef __COUNTER__ // not standard and may be missing for some compilers
+#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__)
+#else // __COUNTER__
+#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__)
+#endif // __COUNTER__
+
+#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
+#define DOCTEST_REF_WRAP(x) x&
+#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
+#define DOCTEST_REF_WRAP(x) x
+#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
+
+// not using __APPLE__ because... this is how Catch does it
+#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
+#define DOCTEST_PLATFORM_MAC
+#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#define DOCTEST_PLATFORM_IPHONE
+#elif defined(_WIN32)
+#define DOCTEST_PLATFORM_WINDOWS
+#elif defined(__wasi__)
+#define DOCTEST_PLATFORM_WASI
+#else // DOCTEST_PLATFORM
+#define DOCTEST_PLATFORM_LINUX
+#endif // DOCTEST_PLATFORM
+
+namespace doctest { namespace detail {
+ static DOCTEST_CONSTEXPR int consume(const int*, int) noexcept { return 0; }
+}}
+
+#define DOCTEST_GLOBAL_NO_WARNINGS(var, ...) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wglobal-constructors") \
+ static const int var = doctest::detail::consume(&var, __VA_ARGS__); \
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+#ifndef DOCTEST_BREAK_INTO_DEBUGGER
+// should probably take a look at https://github.com/scottt/debugbreak
+#ifdef DOCTEST_PLATFORM_LINUX
+#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+// Break at the location of the failing check if possible
+#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
+#else
+#include <signal.h>
+#define DOCTEST_BREAK_INTO_DEBUGGER() raise(SIGTRAP)
+#endif
+#elif defined(DOCTEST_PLATFORM_MAC)
+#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64__) || defined(__i386)
+#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
+#elif defined(__ppc__) || defined(__ppc64__)
+// https://www.cocoawithlove.com/2008/03/break-into-debugger.html
+#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n": : : "memory","r0","r3","r4") // NOLINT(hicpp-no-assembler)
+#else
+#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("brk #0"); // NOLINT(hicpp-no-assembler)
+#endif
+#elif DOCTEST_MSVC
+#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak()
+#elif defined(__MINGW32__)
+DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wredundant-decls")
+extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+DOCTEST_GCC_SUPPRESS_WARNING_POP
+#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak()
+#else // linux
+#define DOCTEST_BREAK_INTO_DEBUGGER() (static_cast<void>(0))
+#endif // linux
+#endif // DOCTEST_BREAK_INTO_DEBUGGER
+
+// this is kept here for backwards compatibility since the config option was changed
+#ifdef DOCTEST_CONFIG_USE_IOSFWD
+#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
+#define DOCTEST_CONFIG_USE_STD_HEADERS
+#endif
+#endif // DOCTEST_CONFIG_USE_IOSFWD
+
+// for clang - always include ciso646 (which drags some std stuff) because
+// we want to check if we are using libc++ with the _LIBCPP_VERSION macro in
+// which case we don't want to forward declare stuff from std - for reference:
+// https://github.com/doctest/doctest/issues/126
+// https://github.com/doctest/doctest/issues/356
+#if DOCTEST_CLANG
+#include <ciso646>
+#endif // clang
+
+#ifdef _LIBCPP_VERSION
+#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
+#define DOCTEST_CONFIG_USE_STD_HEADERS
+#endif
+#endif // _LIBCPP_VERSION
+
+#ifdef DOCTEST_CONFIG_USE_STD_HEADERS
+#ifndef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+#define DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
+#include <cstddef>
+#include <ostream>
+#include <istream>
+DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
+#else // DOCTEST_CONFIG_USE_STD_HEADERS
+
+// Forward declaring 'X' in namespace std is not permitted by the C++ Standard.
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4643)
+
+namespace std { // NOLINT(cert-dcl58-cpp)
+typedef decltype(nullptr) nullptr_t; // NOLINT(modernize-use-using)
+typedef decltype(sizeof(void*)) size_t; // NOLINT(modernize-use-using)
+template <class charT>
+struct char_traits;
+template <>
+struct char_traits<char>;
+template <class charT, class traits>
+class basic_ostream; // NOLINT(fuchsia-virtual-inheritance)
+typedef basic_ostream<char, char_traits<char>> ostream; // NOLINT(modernize-use-using)
+template<class traits>
+// NOLINTNEXTLINE
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char*);
+template <class charT, class traits>
+class basic_istream;
+typedef basic_istream<char, char_traits<char>> istream; // NOLINT(modernize-use-using)
+template <class... Types>
+class tuple;
+#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
+// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
+template <class Ty>
+class allocator;
+template <class Elem, class Traits, class Alloc>
+class basic_string;
+using string = basic_string<char, char_traits<char>, allocator<char>>;
+#endif // VS 2019
+} // namespace std
+
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+#endif // DOCTEST_CONFIG_USE_STD_HEADERS
+
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+#include <type_traits>
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+
+namespace doctest {
+
+using std::size_t;
+
+DOCTEST_INTERFACE extern bool is_running_in_test;
+
+#ifndef DOCTEST_CONFIG_STRING_SIZE_TYPE
+#define DOCTEST_CONFIG_STRING_SIZE_TYPE unsigned
+#endif
+
+// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length
+// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for:
+// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128)
+// - if small - capacity left before going on the heap - using the lowest 5 bits
+// - if small - 2 bits are left unused - the second and third highest ones
+// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator)
+// and the "is small" bit remains "0" ("as well as the capacity left") so its OK
+// Idea taken from this lecture about the string implementation of facebook/folly - fbstring
+// https://www.youtube.com/watch?v=kPR8h4-qZdk
+// TODO:
+// - optimizations - like not deleting memory unnecessarily in operator= and etc.
+// - resize/reserve/clear
+// - replace
+// - back/front
+// - iterator stuff
+// - find & friends
+// - push_back/pop_back
+// - assign/insert/erase
+// - relational operators as free functions - taking const char* as one of the params
+class DOCTEST_INTERFACE String
+{
+public:
+ using size_type = DOCTEST_CONFIG_STRING_SIZE_TYPE;
+
+private:
+ static DOCTEST_CONSTEXPR size_type len = 24; //!OCLINT avoid private static members
+ static DOCTEST_CONSTEXPR size_type last = len - 1; //!OCLINT avoid private static members
+
+ struct view // len should be more than sizeof(view) - because of the final byte for flags
+ {
+ char* ptr;
+ size_type size;
+ size_type capacity;
+ };
+
+ union
+ {
+ char buf[len]; // NOLINT(*-avoid-c-arrays)
+ view data;
+ };
+
+ char* allocate(size_type sz);
+
+ bool isOnStack() const noexcept { return (buf[last] & 128) == 0; }
+ void setOnHeap() noexcept;
+ void setLast(size_type in = last) noexcept;
+ void setSize(size_type sz) noexcept;
+
+ void copy(const String& other);
+
+public:
+ static DOCTEST_CONSTEXPR size_type npos = static_cast<size_type>(-1);
+
+ String() noexcept;
+ ~String();
+
+ // cppcheck-suppress noExplicitConstructor
+ String(const char* in);
+ String(const char* in, size_type in_size);
+
+ String(std::istream& in, size_type in_size);
+
+ String(const String& other);
+ String& operator=(const String& other);
+
+ String& operator+=(const String& other);
+
+ String(String&& other) noexcept;
+ String& operator=(String&& other) noexcept;
+
+ char operator[](size_type i) const;
+ char& operator[](size_type i);
+
+ // the only functions I'm willing to leave in the interface - available for inlining
+ const char* c_str() const { return const_cast<String*>(this)->c_str(); } // NOLINT
+ char* c_str() {
+ if (isOnStack()) {
+ return reinterpret_cast<char*>(buf);
+ }
+ return data.ptr;
+ }
+
+ size_type size() const;
+ size_type capacity() const;
+
+ String substr(size_type pos, size_type cnt = npos) &&;
+ String substr(size_type pos, size_type cnt = npos) const &;
+
+ size_type find(char ch, size_type pos = 0) const;
+ size_type rfind(char ch, size_type pos = npos) const;
+
+ int compare(const char* other, bool no_case = false) const;
+ int compare(const String& other, bool no_case = false) const;
+
+friend DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, const String& in);
+};
+
+DOCTEST_INTERFACE String operator+(const String& lhs, const String& rhs);
+
+DOCTEST_INTERFACE bool operator==(const String& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator!=(const String& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator<(const String& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator>(const String& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator<=(const String& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator>=(const String& lhs, const String& rhs);
+
+class DOCTEST_INTERFACE Contains {
+public:
+ explicit Contains(const String& string);
+
+ bool checkWith(const String& other) const;
+
+ String string;
+};
+
+DOCTEST_INTERFACE String toString(const Contains& in);
+
+DOCTEST_INTERFACE bool operator==(const String& lhs, const Contains& rhs);
+DOCTEST_INTERFACE bool operator==(const Contains& lhs, const String& rhs);
+DOCTEST_INTERFACE bool operator!=(const String& lhs, const Contains& rhs);
+DOCTEST_INTERFACE bool operator!=(const Contains& lhs, const String& rhs);
+
+namespace Color {
+ enum Enum
+ {
+ None = 0,
+ White,
+ Red,
+ Green,
+ Blue,
+ Cyan,
+ Yellow,
+ Grey,
+
+ Bright = 0x10,
+
+ BrightRed = Bright | Red,
+ BrightGreen = Bright | Green,
+ LightGrey = Bright | Grey,
+ BrightWhite = Bright | White
+ };
+
+ DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, Color::Enum code);
+} // namespace Color
+
+namespace assertType {
+ enum Enum
+ {
+ // macro traits
+
+ is_warn = 1,
+ is_check = 2 * is_warn,
+ is_require = 2 * is_check,
+
+ is_normal = 2 * is_require,
+ is_throws = 2 * is_normal,
+ is_throws_as = 2 * is_throws,
+ is_throws_with = 2 * is_throws_as,
+ is_nothrow = 2 * is_throws_with,
+
+ is_false = 2 * is_nothrow,
+ is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types
+
+ is_eq = 2 * is_unary,
+ is_ne = 2 * is_eq,
+
+ is_lt = 2 * is_ne,
+ is_gt = 2 * is_lt,
+
+ is_ge = 2 * is_gt,
+ is_le = 2 * is_ge,
+
+ // macro types
+
+ DT_WARN = is_normal | is_warn,
+ DT_CHECK = is_normal | is_check,
+ DT_REQUIRE = is_normal | is_require,
+
+ DT_WARN_FALSE = is_normal | is_false | is_warn,
+ DT_CHECK_FALSE = is_normal | is_false | is_check,
+ DT_REQUIRE_FALSE = is_normal | is_false | is_require,
+
+ DT_WARN_THROWS = is_throws | is_warn,
+ DT_CHECK_THROWS = is_throws | is_check,
+ DT_REQUIRE_THROWS = is_throws | is_require,
+
+ DT_WARN_THROWS_AS = is_throws_as | is_warn,
+ DT_CHECK_THROWS_AS = is_throws_as | is_check,
+ DT_REQUIRE_THROWS_AS = is_throws_as | is_require,
+
+ DT_WARN_THROWS_WITH = is_throws_with | is_warn,
+ DT_CHECK_THROWS_WITH = is_throws_with | is_check,
+ DT_REQUIRE_THROWS_WITH = is_throws_with | is_require,
+
+ DT_WARN_THROWS_WITH_AS = is_throws_with | is_throws_as | is_warn,
+ DT_CHECK_THROWS_WITH_AS = is_throws_with | is_throws_as | is_check,
+ DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require,
+
+ DT_WARN_NOTHROW = is_nothrow | is_warn,
+ DT_CHECK_NOTHROW = is_nothrow | is_check,
+ DT_REQUIRE_NOTHROW = is_nothrow | is_require,
+
+ DT_WARN_EQ = is_normal | is_eq | is_warn,
+ DT_CHECK_EQ = is_normal | is_eq | is_check,
+ DT_REQUIRE_EQ = is_normal | is_eq | is_require,
+
+ DT_WARN_NE = is_normal | is_ne | is_warn,
+ DT_CHECK_NE = is_normal | is_ne | is_check,
+ DT_REQUIRE_NE = is_normal | is_ne | is_require,
+
+ DT_WARN_GT = is_normal | is_gt | is_warn,
+ DT_CHECK_GT = is_normal | is_gt | is_check,
+ DT_REQUIRE_GT = is_normal | is_gt | is_require,
+
+ DT_WARN_LT = is_normal | is_lt | is_warn,
+ DT_CHECK_LT = is_normal | is_lt | is_check,
+ DT_REQUIRE_LT = is_normal | is_lt | is_require,
+
+ DT_WARN_GE = is_normal | is_ge | is_warn,
+ DT_CHECK_GE = is_normal | is_ge | is_check,
+ DT_REQUIRE_GE = is_normal | is_ge | is_require,
+
+ DT_WARN_LE = is_normal | is_le | is_warn,
+ DT_CHECK_LE = is_normal | is_le | is_check,
+ DT_REQUIRE_LE = is_normal | is_le | is_require,
+
+ DT_WARN_UNARY = is_normal | is_unary | is_warn,
+ DT_CHECK_UNARY = is_normal | is_unary | is_check,
+ DT_REQUIRE_UNARY = is_normal | is_unary | is_require,
+
+ DT_WARN_UNARY_FALSE = is_normal | is_false | is_unary | is_warn,
+ DT_CHECK_UNARY_FALSE = is_normal | is_false | is_unary | is_check,
+ DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require,
+ };
+} // namespace assertType
+
+DOCTEST_INTERFACE const char* assertString(assertType::Enum at);
+DOCTEST_INTERFACE const char* failureString(assertType::Enum at);
+DOCTEST_INTERFACE const char* skipPathFromFilename(const char* file);
+
+struct DOCTEST_INTERFACE TestCaseData
+{
+ String m_file; // the file in which the test was registered (using String - see #350)
+ unsigned m_line; // the line where the test was registered
+ const char* m_name; // name of the test case
+ const char* m_test_suite; // the test suite in which the test was added
+ const char* m_description;
+ bool m_skip;
+ bool m_no_breaks;
+ bool m_no_output;
+ bool m_may_fail;
+ bool m_should_fail;
+ int m_expected_failures;
+ double m_timeout;
+};
+
+struct DOCTEST_INTERFACE AssertData
+{
+ // common - for all asserts
+ const TestCaseData* m_test_case;
+ assertType::Enum m_at;
+ const char* m_file;
+ int m_line;
+ const char* m_expr;
+ bool m_failed;
+
+ // exception-related - for all asserts
+ bool m_threw;
+ String m_exception;
+
+ // for normal asserts
+ String m_decomp;
+
+ // for specific exception-related asserts
+ bool m_threw_as;
+ const char* m_exception_type;
+
+ class DOCTEST_INTERFACE StringContains {
+ private:
+ Contains content;
+ bool isContains;
+
+ public:
+ StringContains(const String& str) : content(str), isContains(false) { }
+ StringContains(Contains cntn) : content(static_cast<Contains&&>(cntn)), isContains(true) { }
+
+ bool check(const String& str) { return isContains ? (content == str) : (content.string == str); }
+
+ operator const String&() const { return content.string; }
+
+ const char* c_str() const { return content.string.c_str(); }
+ } m_exception_string;
+
+ AssertData(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type, const StringContains& exception_string);
+};
+
+struct DOCTEST_INTERFACE MessageData
+{
+ String m_string;
+ const char* m_file;
+ int m_line;
+ assertType::Enum m_severity;
+};
+
+struct DOCTEST_INTERFACE SubcaseSignature
+{
+ String m_name;
+ const char* m_file;
+ int m_line;
+
+ bool operator==(const SubcaseSignature& other) const;
+ bool operator<(const SubcaseSignature& other) const;
+};
+
+struct DOCTEST_INTERFACE IContextScope
+{
+ DOCTEST_DECLARE_INTERFACE(IContextScope)
+ virtual void stringify(std::ostream*) const = 0;
+};
+
+namespace detail {
+ struct DOCTEST_INTERFACE TestCase;
+} // namespace detail
+
+struct ContextOptions //!OCLINT too many fields
+{
+ std::ostream* cout = nullptr; // stdout stream
+ String binary_name; // the test binary name
+
+ const detail::TestCase* currentTest = nullptr;
+
+ // == parameters from the command line
+ String out; // output filename
+ String order_by; // how tests should be ordered
+ unsigned rand_seed; // the seed for rand ordering
+
+ unsigned first; // the first (matching) test to be executed
+ unsigned last; // the last (matching) test to be executed
+
+ int abort_after; // stop tests after this many failed assertions
+ int subcase_filter_levels; // apply the subcase filters for the first N levels
+
+ bool success; // include successful assertions in output
+ bool case_sensitive; // if filtering should be case sensitive
+ bool exit; // if the program should be exited after the tests are ran/whatever
+ bool duration; // print the time duration of each test case
+ bool minimal; // minimal console output (only test failures)
+ bool quiet; // no console output
+ bool no_throw; // to skip exceptions-related assertion macros
+ bool no_exitcode; // if the framework should return 0 as the exitcode
+ bool no_run; // to not run the tests at all (can be done with an "*" exclude)
+ bool no_intro; // to not print the intro of the framework
+ bool no_version; // to not print the version of the framework
+ bool no_colors; // if output to the console should be colorized
+ bool force_colors; // forces the use of colors even when a tty cannot be detected
+ bool no_breaks; // to not break into the debugger
+ bool no_skip; // don't skip test cases which are marked to be skipped
+ bool gnu_file_line; // if line numbers should be surrounded with :x: and not (x):
+ bool no_path_in_filenames; // if the path to files should be removed from the output
+ bool no_line_numbers; // if source code line numbers should be omitted from the output
+ bool no_debug_output; // no output in the debug console when a debugger is attached
+ bool no_skipped_summary; // don't print "skipped" in the summary !!! UNDOCUMENTED !!!
+ bool no_time_in_output; // omit any time/timestamps from output !!! UNDOCUMENTED !!!
+
+ bool help; // to print the help
+ bool version; // to print the version
+ bool count; // if only the count of matching tests is to be retrieved
+ bool list_test_cases; // to list all tests matching the filters
+ bool list_test_suites; // to list all suites matching the filters
+ bool list_reporters; // lists all registered reporters
+};
+
+namespace detail {
+ namespace types {
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+ using namespace std;
+#else
+ template <bool COND, typename T = void>
+ struct enable_if { };
+
+ template <typename T>
+ struct enable_if<true, T> { using type = T; };
+
+ struct true_type { static DOCTEST_CONSTEXPR bool value = true; };
+ struct false_type { static DOCTEST_CONSTEXPR bool value = false; };
+
+ template <typename T> struct remove_reference { using type = T; };
+ template <typename T> struct remove_reference<T&> { using type = T; };
+ template <typename T> struct remove_reference<T&&> { using type = T; };
+
+ template <typename T> struct is_rvalue_reference : false_type { };
+ template <typename T> struct is_rvalue_reference<T&&> : true_type { };
+
+ template<typename T> struct remove_const { using type = T; };
+ template <typename T> struct remove_const<const T> { using type = T; };
+
+ // Compiler intrinsics
+ template <typename T> struct is_enum { static DOCTEST_CONSTEXPR bool value = __is_enum(T); };
+ template <typename T> struct underlying_type { using type = __underlying_type(T); };
+
+ template <typename T> struct is_pointer : false_type { };
+ template <typename T> struct is_pointer<T*> : true_type { };
+
+ template <typename T> struct is_array : false_type { };
+ // NOLINTNEXTLINE(*-avoid-c-arrays)
+ template <typename T, size_t SIZE> struct is_array<T[SIZE]> : true_type { };
+#endif
+ }
+
+ // <utility>
+ template <typename T>
+ T&& declval();
+
+ template <class T>
+ DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type& t) DOCTEST_NOEXCEPT {
+ return static_cast<T&&>(t);
+ }
+
+ template <class T>
+ DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type&& t) DOCTEST_NOEXCEPT {
+ return static_cast<T&&>(t);
+ }
+
+ template <typename T>
+ struct deferred_false : types::false_type { };
+
+// MSVS 2015 :(
+#if !DOCTEST_CLANG && defined(_MSC_VER) && _MSC_VER <= 1900
+ template <typename T, typename = void>
+ struct has_global_insertion_operator : types::false_type { };
+
+ template <typename T>
+ struct has_global_insertion_operator<T, decltype(::operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
+
+ template <typename T, typename = void>
+ struct has_insertion_operator { static DOCTEST_CONSTEXPR bool value = has_global_insertion_operator<T>::value; };
+
+ template <typename T, bool global>
+ struct insert_hack;
+
+ template <typename T>
+ struct insert_hack<T, true> {
+ static void insert(std::ostream& os, const T& t) { ::operator<<(os, t); }
+ };
+
+ template <typename T>
+ struct insert_hack<T, false> {
+ static void insert(std::ostream& os, const T& t) { operator<<(os, t); }
+ };
+
+ template <typename T>
+ using insert_hack_t = insert_hack<T, has_global_insertion_operator<T>::value>;
+#else
+ template <typename T, typename = void>
+ struct has_insertion_operator : types::false_type { };
+#endif
+
+ template <typename T>
+ struct has_insertion_operator<T, decltype(operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
+
+ template <typename T>
+ struct should_stringify_as_underlying_type {
+ static DOCTEST_CONSTEXPR bool value = detail::types::is_enum<T>::value && !doctest::detail::has_insertion_operator<T>::value;
+ };
+
+ DOCTEST_INTERFACE std::ostream* tlssPush();
+ DOCTEST_INTERFACE String tlssPop();
+
+ template <bool C>
+ struct StringMakerBase {
+ template <typename T>
+ static String convert(const DOCTEST_REF_WRAP(T)) {
+#ifdef DOCTEST_CONFIG_REQUIRE_STRINGIFICATION_FOR_ALL_USED_TYPES
+ static_assert(deferred_false<T>::value, "No stringification detected for type T. See string conversion manual");
+#endif
+ return "{?}";
+ }
+ };
+
+ template <typename T>
+ struct filldata;
+
+ template <typename T>
+ void filloss(std::ostream* stream, const T& in) {
+ filldata<T>::fill(stream, in);
+ }
+
+ template <typename T, size_t N>
+ void filloss(std::ostream* stream, const T (&in)[N]) { // NOLINT(*-avoid-c-arrays)
+ // T[N], T(&)[N], T(&&)[N] have same behaviour.
+ // Hence remove reference.
+ filloss<typename types::remove_reference<decltype(in)>::type>(stream, in);
+ }
+
+ template <typename T>
+ String toStream(const T& in) {
+ std::ostream* stream = tlssPush();
+ filloss(stream, in);
+ return tlssPop();
+ }
+
+ template <>
+ struct StringMakerBase<true> {
+ template <typename T>
+ static String convert(const DOCTEST_REF_WRAP(T) in) {
+ return toStream(in);
+ }
+ };
+} // namespace detail
+
+template <typename T>
+struct StringMaker : public detail::StringMakerBase<
+ detail::has_insertion_operator<T>::value || detail::types::is_pointer<T>::value || detail::types::is_array<T>::value>
+{};
+
+#ifndef DOCTEST_STRINGIFY
+#ifdef DOCTEST_CONFIG_DOUBLE_STRINGIFY
+#define DOCTEST_STRINGIFY(...) toString(toString(__VA_ARGS__))
+#else
+#define DOCTEST_STRINGIFY(...) toString(__VA_ARGS__)
+#endif
+#endif
+
+template <typename T>
+String toString() {
+#if DOCTEST_CLANG == 0 && DOCTEST_GCC == 0 && DOCTEST_ICC == 0
+ String ret = __FUNCSIG__; // class doctest::String __cdecl doctest::toString<TYPE>(void)
+ String::size_type beginPos = ret.find('<');
+ return ret.substr(beginPos + 1, ret.size() - beginPos - static_cast<String::size_type>(sizeof(">(void)")));
+#else
+ String ret = __PRETTY_FUNCTION__; // doctest::String toString() [with T = TYPE]
+ String::size_type begin = ret.find('=') + 2;
+ return ret.substr(begin, ret.size() - begin - 1);
+#endif
+}
+
+template <typename T, typename detail::types::enable_if<!detail::should_stringify_as_underlying_type<T>::value, bool>::type = true>
+String toString(const DOCTEST_REF_WRAP(T) value) {
+ return StringMaker<T>::convert(value);
+}
+
+#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+DOCTEST_INTERFACE String toString(const char* in);
+#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+
+#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
+// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
+DOCTEST_INTERFACE String toString(const std::string& in);
+#endif // VS 2019
+
+DOCTEST_INTERFACE String toString(String in);
+
+DOCTEST_INTERFACE String toString(std::nullptr_t);
+
+DOCTEST_INTERFACE String toString(bool in);
+
+DOCTEST_INTERFACE String toString(float in);
+DOCTEST_INTERFACE String toString(double in);
+DOCTEST_INTERFACE String toString(double long in);
+
+DOCTEST_INTERFACE String toString(char in);
+DOCTEST_INTERFACE String toString(char signed in);
+DOCTEST_INTERFACE String toString(char unsigned in);
+DOCTEST_INTERFACE String toString(short in);
+DOCTEST_INTERFACE String toString(short unsigned in);
+DOCTEST_INTERFACE String toString(signed in);
+DOCTEST_INTERFACE String toString(unsigned in);
+DOCTEST_INTERFACE String toString(long in);
+DOCTEST_INTERFACE String toString(long unsigned in);
+DOCTEST_INTERFACE String toString(long long in);
+DOCTEST_INTERFACE String toString(long long unsigned in);
+
+template <typename T, typename detail::types::enable_if<detail::should_stringify_as_underlying_type<T>::value, bool>::type = true>
+String toString(const DOCTEST_REF_WRAP(T) value) {
+ using UT = typename detail::types::underlying_type<T>::type;
+ return (DOCTEST_STRINGIFY(static_cast<UT>(value)));
+}
+
+namespace detail {
+ template <typename T>
+ struct filldata
+ {
+ static void fill(std::ostream* stream, const T& in) {
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+ insert_hack_t<T>::insert(*stream, in);
+#else
+ operator<<(*stream, in);
+#endif
+ }
+ };
+
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
+// NOLINTBEGIN(*-avoid-c-arrays)
+ template <typename T, size_t N>
+ struct filldata<T[N]> {
+ static void fill(std::ostream* stream, const T(&in)[N]) {
+ *stream << "[";
+ for (size_t i = 0; i < N; i++) {
+ if (i != 0) { *stream << ", "; }
+ *stream << (DOCTEST_STRINGIFY(in[i]));
+ }
+ *stream << "]";
+ }
+ };
+// NOLINTEND(*-avoid-c-arrays)
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+ // Specialized since we don't want the terminating null byte!
+// NOLINTBEGIN(*-avoid-c-arrays)
+ template <size_t N>
+ struct filldata<const char[N]> {
+ static void fill(std::ostream* stream, const char (&in)[N]) {
+ *stream << String(in, in[N - 1] ? N : N - 1);
+ } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+ };
+// NOLINTEND(*-avoid-c-arrays)
+
+ template <>
+ struct filldata<const void*> {
+ static void fill(std::ostream* stream, const void* in);
+ };
+
+ template <typename T>
+ struct filldata<T*> {
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4180)
+ static void fill(std::ostream* stream, const T* in) {
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wmicrosoft-cast")
+ filldata<const void*>::fill(stream,
+#if DOCTEST_GCC == 0 || DOCTEST_GCC >= DOCTEST_COMPILER(4, 9, 0)
+ reinterpret_cast<const void*>(in)
+#else
+ *reinterpret_cast<const void* const*>(&in)
+#endif
+ );
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+ }
+ };
+}
+
+struct DOCTEST_INTERFACE Approx
+{
+ Approx(double value);
+
+ Approx operator()(double value) const;
+
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+ template <typename T>
+ explicit Approx(const T& value,
+ typename detail::types::enable_if<std::is_constructible<double, T>::value>::type* =
+ static_cast<T*>(nullptr)) {
+ *this = static_cast<double>(value);
+ }
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+
+ Approx& epsilon(double newEpsilon);
+
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+ template <typename T>
+ typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type epsilon(
+ const T& newEpsilon) {
+ m_epsilon = static_cast<double>(newEpsilon);
+ return *this;
+ }
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+
+ Approx& scale(double newScale);
+
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+ template <typename T>
+ typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type scale(
+ const T& newScale) {
+ m_scale = static_cast<double>(newScale);
+ return *this;
+ }
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+
+ // clang-format off
+ DOCTEST_INTERFACE friend bool operator==(double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator==(const Approx & lhs, double rhs);
+ DOCTEST_INTERFACE friend bool operator!=(double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator!=(const Approx & lhs, double rhs);
+ DOCTEST_INTERFACE friend bool operator<=(double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator<=(const Approx & lhs, double rhs);
+ DOCTEST_INTERFACE friend bool operator>=(double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator>=(const Approx & lhs, double rhs);
+ DOCTEST_INTERFACE friend bool operator< (double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator< (const Approx & lhs, double rhs);
+ DOCTEST_INTERFACE friend bool operator> (double lhs, const Approx & rhs);
+ DOCTEST_INTERFACE friend bool operator> (const Approx & lhs, double rhs);
+
+#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+#define DOCTEST_APPROX_PREFIX \
+ template <typename T> friend typename std::enable_if<std::is_constructible<double, T>::value, bool>::type
+
+ DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(static_cast<double>(lhs), rhs); }
+ DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); }
+ DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
+ DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); }
+ DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value || lhs == rhs; }
+ DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) || lhs == rhs; }
+ DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value || lhs == rhs; }
+ DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) || lhs == rhs; }
+ DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value && lhs != rhs; }
+ DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) && lhs != rhs; }
+ DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value && lhs != rhs; }
+ DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) && lhs != rhs; }
+#undef DOCTEST_APPROX_PREFIX
+#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
+
+ // clang-format on
+
+ double m_epsilon;
+ double m_scale;
+ double m_value;
+};
+
+DOCTEST_INTERFACE String toString(const Approx& in);
+
+DOCTEST_INTERFACE const ContextOptions* getContextOptions();
+
+template <typename F>
+struct DOCTEST_INTERFACE_DECL IsNaN
+{
+ F value; bool flipped;
+ IsNaN(F f, bool flip = false) : value(f), flipped(flip) { }
+ IsNaN<F> operator!() const { return { value, !flipped }; }
+ operator bool() const;
+};
+#ifndef __MINGW32__
+extern template struct DOCTEST_INTERFACE_DECL IsNaN<float>;
+extern template struct DOCTEST_INTERFACE_DECL IsNaN<double>;
+extern template struct DOCTEST_INTERFACE_DECL IsNaN<long double>;
+#endif
+DOCTEST_INTERFACE String toString(IsNaN<float> in);
+DOCTEST_INTERFACE String toString(IsNaN<double> in);
+DOCTEST_INTERFACE String toString(IsNaN<double long> in);
+
+#ifndef DOCTEST_CONFIG_DISABLE
+
+namespace detail {
+ // clang-format off
+#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+ template<class T> struct decay_array { using type = T; };
+ template<class T, unsigned N> struct decay_array<T[N]> { using type = T*; };
+ template<class T> struct decay_array<T[]> { using type = T*; };
+
+ template<class T> struct not_char_pointer { static DOCTEST_CONSTEXPR int value = 1; };
+ template<> struct not_char_pointer<char*> { static DOCTEST_CONSTEXPR int value = 0; };
+ template<> struct not_char_pointer<const char*> { static DOCTEST_CONSTEXPR int value = 0; };
+
+ template<class T> struct can_use_op : public not_char_pointer<typename decay_array<T>::type> {};
+#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+ // clang-format on
+
+ struct DOCTEST_INTERFACE TestFailureException
+ {
+ };
+
+ DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum at);
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ DOCTEST_NORETURN
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+ DOCTEST_INTERFACE void throwException();
+
+ struct DOCTEST_INTERFACE Subcase
+ {
+ SubcaseSignature m_signature;
+ bool m_entered = false;
+
+ Subcase(const String& name, const char* file, int line);
+ Subcase(const Subcase&) = delete;
+ Subcase(Subcase&&) = delete;
+ Subcase& operator=(const Subcase&) = delete;
+ Subcase& operator=(Subcase&&) = delete;
+ ~Subcase();
+
+ operator bool() const;
+
+ private:
+ bool checkFilters();
+ };
+
+ template <typename L, typename R>
+ String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
+ const DOCTEST_REF_WRAP(R) rhs) {
+ return (DOCTEST_STRINGIFY(lhs)) + op + (DOCTEST_STRINGIFY(rhs));
+ }
+
+#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
+DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-comparison")
+#endif
+
+// This will check if there is any way it could find a operator like member or friend and uses it.
+// If not it doesn't find the operator or if the operator at global scope is defined after
+// this template, the template won't be instantiated due to SFINAE. Once the template is not
+// instantiated it can look for global operator using normal conversions.
+#ifdef __NVCC__
+#define SFINAE_OP(ret,op) ret
+#else
+#define SFINAE_OP(ret,op) decltype((void)(doctest::detail::declval<L>() op doctest::detail::declval<R>()),ret{})
+#endif
+
+#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro) \
+ template <typename R> \
+ DOCTEST_NOINLINE SFINAE_OP(Result,op) operator op(R&& rhs) { \
+ bool res = op_macro(doctest::detail::forward<const L>(lhs), doctest::detail::forward<R>(rhs)); \
+ if(m_at & assertType::is_false) \
+ res = !res; \
+ if(!res || doctest::getContextOptions()->success) \
+ return Result(res, stringifyBinaryExpr(lhs, op_str, rhs)); \
+ return Result(res); \
+ }
+
+ // more checks could be added - like in Catch:
+ // https://github.com/catchorg/Catch2/pull/1480/files
+ // https://github.com/catchorg/Catch2/pull/1481/files
+#define DOCTEST_FORBIT_EXPRESSION(rt, op) \
+ template <typename R> \
+ rt& operator op(const R&) { \
+ static_assert(deferred_false<R>::value, \
+ "Expression Too Complex Please Rewrite As Binary Comparison!"); \
+ return *this; \
+ }
+
+ struct DOCTEST_INTERFACE Result // NOLINT(*-member-init)
+ {
+ bool m_passed;
+ String m_decomp;
+
+ Result() = default; // TODO: Why do we need this? (To remove NOLINT)
+ Result(bool passed, const String& decomposition = String());
+
+ // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
+ DOCTEST_FORBIT_EXPRESSION(Result, &)
+ DOCTEST_FORBIT_EXPRESSION(Result, ^)
+ DOCTEST_FORBIT_EXPRESSION(Result, |)
+ DOCTEST_FORBIT_EXPRESSION(Result, &&)
+ DOCTEST_FORBIT_EXPRESSION(Result, ||)
+ DOCTEST_FORBIT_EXPRESSION(Result, ==)
+ DOCTEST_FORBIT_EXPRESSION(Result, !=)
+ DOCTEST_FORBIT_EXPRESSION(Result, <)
+ DOCTEST_FORBIT_EXPRESSION(Result, >)
+ DOCTEST_FORBIT_EXPRESSION(Result, <=)
+ DOCTEST_FORBIT_EXPRESSION(Result, >=)
+ DOCTEST_FORBIT_EXPRESSION(Result, =)
+ DOCTEST_FORBIT_EXPRESSION(Result, +=)
+ DOCTEST_FORBIT_EXPRESSION(Result, -=)
+ DOCTEST_FORBIT_EXPRESSION(Result, *=)
+ DOCTEST_FORBIT_EXPRESSION(Result, /=)
+ DOCTEST_FORBIT_EXPRESSION(Result, %=)
+ DOCTEST_FORBIT_EXPRESSION(Result, <<=)
+ DOCTEST_FORBIT_EXPRESSION(Result, >>=)
+ DOCTEST_FORBIT_EXPRESSION(Result, &=)
+ DOCTEST_FORBIT_EXPRESSION(Result, ^=)
+ DOCTEST_FORBIT_EXPRESSION(Result, |=)
+ };
+
+#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
+
+ DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
+ DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-compare")
+ //DOCTEST_CLANG_SUPPRESS_WARNING("-Wdouble-promotion")
+ //DOCTEST_CLANG_SUPPRESS_WARNING("-Wconversion")
+ //DOCTEST_CLANG_SUPPRESS_WARNING("-Wfloat-equal")
+
+ DOCTEST_GCC_SUPPRESS_WARNING_PUSH
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
+ DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-compare")
+ //DOCTEST_GCC_SUPPRESS_WARNING("-Wdouble-promotion")
+ //DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
+ //DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal")
+
+ DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
+ // https://stackoverflow.com/questions/39479163 what's the difference between 4018 and 4389
+ DOCTEST_MSVC_SUPPRESS_WARNING(4388) // signed/unsigned mismatch
+ DOCTEST_MSVC_SUPPRESS_WARNING(4389) // 'operator' : signed/unsigned mismatch
+ DOCTEST_MSVC_SUPPRESS_WARNING(4018) // 'expression' : signed/unsigned mismatch
+ //DOCTEST_MSVC_SUPPRESS_WARNING(4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation
+
+#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
+
+ // clang-format off
+#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+#define DOCTEST_COMPARISON_RETURN_TYPE bool
+#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+#define DOCTEST_COMPARISON_RETURN_TYPE typename types::enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type
+ inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); }
+ inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); }
+ inline bool lt(const char* lhs, const char* rhs) { return String(lhs) < String(rhs); }
+ inline bool gt(const char* lhs, const char* rhs) { return String(lhs) > String(rhs); }
+ inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); }
+ inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); }
+#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+ // clang-format on
+
+#define DOCTEST_RELATIONAL_OP(name, op) \
+ template <typename L, typename R> \
+ DOCTEST_COMPARISON_RETURN_TYPE name(const DOCTEST_REF_WRAP(L) lhs, \
+ const DOCTEST_REF_WRAP(R) rhs) { \
+ return lhs op rhs; \
+ }
+
+ DOCTEST_RELATIONAL_OP(eq, ==)
+ DOCTEST_RELATIONAL_OP(ne, !=)
+ DOCTEST_RELATIONAL_OP(lt, <)
+ DOCTEST_RELATIONAL_OP(gt, >)
+ DOCTEST_RELATIONAL_OP(le, <=)
+ DOCTEST_RELATIONAL_OP(ge, >=)
+
+#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+#define DOCTEST_CMP_EQ(l, r) l == r
+#define DOCTEST_CMP_NE(l, r) l != r
+#define DOCTEST_CMP_GT(l, r) l > r
+#define DOCTEST_CMP_LT(l, r) l < r
+#define DOCTEST_CMP_GE(l, r) l >= r
+#define DOCTEST_CMP_LE(l, r) l <= r
+#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+#define DOCTEST_CMP_EQ(l, r) eq(l, r)
+#define DOCTEST_CMP_NE(l, r) ne(l, r)
+#define DOCTEST_CMP_GT(l, r) gt(l, r)
+#define DOCTEST_CMP_LT(l, r) lt(l, r)
+#define DOCTEST_CMP_GE(l, r) ge(l, r)
+#define DOCTEST_CMP_LE(l, r) le(l, r)
+#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+
+ template <typename L>
+ // cppcheck-suppress copyCtorAndEqOperator
+ struct Expression_lhs
+ {
+ L lhs;
+ assertType::Enum m_at;
+
+ explicit Expression_lhs(L&& in, assertType::Enum at)
+ : lhs(static_cast<L&&>(in))
+ , m_at(at) {}
+
+ DOCTEST_NOINLINE operator Result() {
+// this is needed only for MSVC 2015
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
+ bool res = static_cast<bool>(lhs);
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+ if(m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
+ res = !res;
+ }
+
+ if(!res || getContextOptions()->success) {
+ return { res, (DOCTEST_STRINGIFY(lhs)) };
+ }
+ return { res };
+ }
+
+ /* This is required for user-defined conversions from Expression_lhs to L */
+ operator L() const { return lhs; }
+
+ // clang-format off
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>, " > ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<, " < ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional
+ DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional
+ // clang-format on
+
+ // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &&)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ||)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, =)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, +=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, -=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, *=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, /=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, %=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^=)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |=)
+ // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the
+ // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression...
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<)
+ DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>)
+ };
+
+#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
+
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+ DOCTEST_GCC_SUPPRESS_WARNING_POP
+
+#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
+
+#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+#endif
+
+ struct DOCTEST_INTERFACE ExpressionDecomposer
+ {
+ assertType::Enum m_at;
+
+ ExpressionDecomposer(assertType::Enum at);
+
+ // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table)
+ // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now...
+ // https://github.com/catchorg/Catch2/issues/870
+ // https://github.com/catchorg/Catch2/issues/565
+ template <typename L>
+ Expression_lhs<L> operator<<(L&& operand) {
+ return Expression_lhs<L>(static_cast<L&&>(operand), m_at);
+ }
+
+ template <typename L,typename types::enable_if<!doctest::detail::types::is_rvalue_reference<L>::value,void >::type* = nullptr>
+ Expression_lhs<const L&> operator<<(const L &operand) {
+ return Expression_lhs<const L&>(operand, m_at);
+ }
+ };
+
+ struct DOCTEST_INTERFACE TestSuite
+ {
+ const char* m_test_suite = nullptr;
+ const char* m_description = nullptr;
+ bool m_skip = false;
+ bool m_no_breaks = false;
+ bool m_no_output = false;
+ bool m_may_fail = false;
+ bool m_should_fail = false;
+ int m_expected_failures = 0;
+ double m_timeout = 0;
+
+ TestSuite& operator*(const char* in);
+
+ template <typename T>
+ TestSuite& operator*(const T& in) {
+ in.fill(*this);
+ return *this;
+ }
+ };
+
+ using funcType = void (*)();
+
+ struct DOCTEST_INTERFACE TestCase : public TestCaseData
+ {
+ funcType m_test; // a function pointer to the test case
+
+ String m_type; // for templated test cases - gets appended to the real name
+ int m_template_id; // an ID used to distinguish between the different versions of a templated test case
+ String m_full_name; // contains the name (only for templated test cases!) + the template type
+
+ TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
+ const String& type = String(), int template_id = -1);
+
+ TestCase(const TestCase& other);
+ TestCase(TestCase&&) = delete;
+
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
+ TestCase& operator=(const TestCase& other);
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+ TestCase& operator=(TestCase&&) = delete;
+
+ TestCase& operator*(const char* in);
+
+ template <typename T>
+ TestCase& operator*(const T& in) {
+ in.fill(*this);
+ return *this;
+ }
+
+ bool operator<(const TestCase& other) const;
+
+ ~TestCase() = default;
+ };
+
+ // forward declarations of functions used by the macros
+ DOCTEST_INTERFACE int regTest(const TestCase& tc);
+ DOCTEST_INTERFACE int setTestSuite(const TestSuite& ts);
+ DOCTEST_INTERFACE bool isDebuggerActive();
+
+ template<typename T>
+ int instantiationHelper(const T&) { return 0; }
+
+ namespace binaryAssertComparison {
+ enum Enum
+ {
+ eq = 0,
+ ne,
+ gt,
+ lt,
+ ge,
+ le
+ };
+ } // namespace binaryAssertComparison
+
+ // clang-format off
+ template <int, class L, class R> struct RelationalComparator { bool operator()(const DOCTEST_REF_WRAP(L), const DOCTEST_REF_WRAP(R) ) const { return false; } };
+
+#define DOCTEST_BINARY_RELATIONAL_OP(n, op) \
+ template <class L, class R> struct RelationalComparator<n, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return op(lhs, rhs); } };
+ // clang-format on
+
+ DOCTEST_BINARY_RELATIONAL_OP(0, doctest::detail::eq)
+ DOCTEST_BINARY_RELATIONAL_OP(1, doctest::detail::ne)
+ DOCTEST_BINARY_RELATIONAL_OP(2, doctest::detail::gt)
+ DOCTEST_BINARY_RELATIONAL_OP(3, doctest::detail::lt)
+ DOCTEST_BINARY_RELATIONAL_OP(4, doctest::detail::ge)
+ DOCTEST_BINARY_RELATIONAL_OP(5, doctest::detail::le)
+
+ struct DOCTEST_INTERFACE ResultBuilder : public AssertData
+ {
+ ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type = "", const String& exception_string = "");
+
+ ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type, const Contains& exception_string);
+
+ void setResult(const Result& res);
+
+ template <int comparison, typename L, typename R>
+ DOCTEST_NOINLINE bool binary_assert(const DOCTEST_REF_WRAP(L) lhs,
+ const DOCTEST_REF_WRAP(R) rhs) {
+ m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
+ if (m_failed || getContextOptions()->success) {
+ m_decomp = stringifyBinaryExpr(lhs, ", ", rhs);
+ }
+ return !m_failed;
+ }
+
+ template <typename L>
+ DOCTEST_NOINLINE bool unary_assert(const DOCTEST_REF_WRAP(L) val) {
+ m_failed = !val;
+
+ if (m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
+ m_failed = !m_failed;
+ }
+
+ if (m_failed || getContextOptions()->success) {
+ m_decomp = (DOCTEST_STRINGIFY(val));
+ }
+
+ return !m_failed;
+ }
+
+ void translateException();
+
+ bool log();
+ void react() const;
+ };
+
+ namespace assertAction {
+ enum Enum
+ {
+ nothing = 0,
+ dbgbreak = 1,
+ shouldthrow = 2
+ };
+ } // namespace assertAction
+
+ DOCTEST_INTERFACE void failed_out_of_a_testing_context(const AssertData& ad);
+
+ DOCTEST_INTERFACE bool decomp_assert(assertType::Enum at, const char* file, int line,
+ const char* expr, const Result& result);
+
+#define DOCTEST_ASSERT_OUT_OF_TESTS(decomp) \
+ do { \
+ if(!is_running_in_test) { \
+ if(failed) { \
+ ResultBuilder rb(at, file, line, expr); \
+ rb.m_failed = failed; \
+ rb.m_decomp = decomp; \
+ failed_out_of_a_testing_context(rb); \
+ if(isDebuggerActive() && !getContextOptions()->no_breaks) \
+ DOCTEST_BREAK_INTO_DEBUGGER(); \
+ if(checkIfShouldThrow(at)) \
+ throwException(); \
+ } \
+ return !failed; \
+ } \
+ } while(false)
+
+#define DOCTEST_ASSERT_IN_TESTS(decomp) \
+ ResultBuilder rb(at, file, line, expr); \
+ rb.m_failed = failed; \
+ if(rb.m_failed || getContextOptions()->success) \
+ rb.m_decomp = decomp; \
+ if(rb.log()) \
+ DOCTEST_BREAK_INTO_DEBUGGER(); \
+ if(rb.m_failed && checkIfShouldThrow(at)) \
+ throwException()
+
+ template <int comparison, typename L, typename R>
+ DOCTEST_NOINLINE bool binary_assert(assertType::Enum at, const char* file, int line,
+ const char* expr, const DOCTEST_REF_WRAP(L) lhs,
+ const DOCTEST_REF_WRAP(R) rhs) {
+ bool failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
+
+ // ###################################################################################
+ // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
+ // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
+ // ###################################################################################
+ DOCTEST_ASSERT_OUT_OF_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
+ DOCTEST_ASSERT_IN_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
+ return !failed;
+ }
+
+ template <typename L>
+ DOCTEST_NOINLINE bool unary_assert(assertType::Enum at, const char* file, int line,
+ const char* expr, const DOCTEST_REF_WRAP(L) val) {
+ bool failed = !val;
+
+ if(at & assertType::is_false) //!OCLINT bitwise operator in conditional
+ failed = !failed;
+
+ // ###################################################################################
+ // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
+ // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
+ // ###################################################################################
+ DOCTEST_ASSERT_OUT_OF_TESTS((DOCTEST_STRINGIFY(val)));
+ DOCTEST_ASSERT_IN_TESTS((DOCTEST_STRINGIFY(val)));
+ return !failed;
+ }
+
+ struct DOCTEST_INTERFACE IExceptionTranslator
+ {
+ DOCTEST_DECLARE_INTERFACE(IExceptionTranslator)
+ virtual bool translate(String&) const = 0;
+ };
+
+ template <typename T>
+ class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class
+ {
+ public:
+ explicit ExceptionTranslator(String (*translateFunction)(T))
+ : m_translateFunction(translateFunction) {}
+
+ bool translate(String& res) const override {
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ try {
+ throw; // lgtm [cpp/rethrow-no-exception]
+ // cppcheck-suppress catchExceptionByValue
+ } catch(const T& ex) {
+ res = m_translateFunction(ex); //!OCLINT parameter reassignment
+ return true;
+ } catch(...) {} //!OCLINT - empty catch statement
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+ static_cast<void>(res); // to silence -Wunused-parameter
+ return false;
+ }
+
+ private:
+ String (*m_translateFunction)(T);
+ };
+
+ DOCTEST_INTERFACE void registerExceptionTranslatorImpl(const IExceptionTranslator* et);
+
+ // ContextScope base class used to allow implementing methods of ContextScope
+ // that don't depend on the template parameter in doctest.cpp.
+ struct DOCTEST_INTERFACE ContextScopeBase : public IContextScope {
+ ContextScopeBase(const ContextScopeBase&) = delete;
+
+ ContextScopeBase& operator=(const ContextScopeBase&) = delete;
+ ContextScopeBase& operator=(ContextScopeBase&&) = delete;
+
+ ~ContextScopeBase() override = default;
+
+ protected:
+ ContextScopeBase();
+ ContextScopeBase(ContextScopeBase&& other) noexcept;
+
+ void destroy();
+ bool need_to_destroy{true};
+ };
+
+ template <typename L> class ContextScope : public ContextScopeBase
+ {
+ L lambda_;
+
+ public:
+ explicit ContextScope(const L &lambda) : lambda_(lambda) {}
+ explicit ContextScope(L&& lambda) : lambda_(static_cast<L&&>(lambda)) { }
+
+ ContextScope(const ContextScope&) = delete;
+ ContextScope(ContextScope&&) noexcept = default;
+
+ ContextScope& operator=(const ContextScope&) = delete;
+ ContextScope& operator=(ContextScope&&) = delete;
+
+ void stringify(std::ostream* s) const override { lambda_(s); }
+
+ ~ContextScope() override {
+ if (need_to_destroy) {
+ destroy();
+ }
+ }
+ };
+
+ struct DOCTEST_INTERFACE MessageBuilder : public MessageData
+ {
+ std::ostream* m_stream;
+ bool logged = false;
+
+ MessageBuilder(const char* file, int line, assertType::Enum severity);
+
+ MessageBuilder(const MessageBuilder&) = delete;
+ MessageBuilder(MessageBuilder&&) = delete;
+
+ MessageBuilder& operator=(const MessageBuilder&) = delete;
+ MessageBuilder& operator=(MessageBuilder&&) = delete;
+
+ ~MessageBuilder();
+
+ // the preferred way of chaining parameters for stringification
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
+ template <typename T>
+ MessageBuilder& operator,(const T& in) {
+ *m_stream << (DOCTEST_STRINGIFY(in));
+ return *this;
+ }
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+ // kept here just for backwards-compatibility - the comma operator should be preferred now
+ template <typename T>
+ MessageBuilder& operator<<(const T& in) { return this->operator,(in); }
+
+ // the `,` operator has the lowest operator precedence - if `<<` is used by the user then
+ // the `,` operator will be called last which is not what we want and thus the `*` operator
+ // is used first (has higher operator precedence compared to `<<`) so that we guarantee that
+ // an operator of the MessageBuilder class is called first before the rest of the parameters
+ template <typename T>
+ MessageBuilder& operator*(const T& in) { return this->operator,(in); }
+
+ bool log();
+ void react();
+ };
+
+ template <typename L>
+ ContextScope<L> MakeContextScope(const L &lambda) {
+ return ContextScope<L>(lambda);
+ }
+} // namespace detail
+
+#define DOCTEST_DEFINE_DECORATOR(name, type, def) \
+ struct name \
+ { \
+ type data; \
+ name(type in = def) \
+ : data(in) {} \
+ void fill(detail::TestCase& state) const { state.DOCTEST_CAT(m_, name) = data; } \
+ void fill(detail::TestSuite& state) const { state.DOCTEST_CAT(m_, name) = data; } \
+ }
+
+DOCTEST_DEFINE_DECORATOR(test_suite, const char*, "");
+DOCTEST_DEFINE_DECORATOR(description, const char*, "");
+DOCTEST_DEFINE_DECORATOR(skip, bool, true);
+DOCTEST_DEFINE_DECORATOR(no_breaks, bool, true);
+DOCTEST_DEFINE_DECORATOR(no_output, bool, true);
+DOCTEST_DEFINE_DECORATOR(timeout, double, 0);
+DOCTEST_DEFINE_DECORATOR(may_fail, bool, true);
+DOCTEST_DEFINE_DECORATOR(should_fail, bool, true);
+DOCTEST_DEFINE_DECORATOR(expected_failures, int, 0);
+
+template <typename T>
+int registerExceptionTranslator(String (*translateFunction)(T)) {
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")
+ static detail::ExceptionTranslator<T> exceptionTranslator(translateFunction);
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+ detail::registerExceptionTranslatorImpl(&exceptionTranslator);
+ return 0;
+}
+
+} // namespace doctest
+
+// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro
+// introduces an anonymous namespace in which getCurrentTestSuite gets overridden
+namespace doctest_detail_test_suite_ns {
+DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite();
+} // namespace doctest_detail_test_suite_ns
+
+namespace doctest {
+#else // DOCTEST_CONFIG_DISABLE
+template <typename T>
+int registerExceptionTranslator(String (*)(T)) {
+ return 0;
+}
+#endif // DOCTEST_CONFIG_DISABLE
+
+namespace detail {
+ using assert_handler = void (*)(const AssertData&);
+ struct ContextState;
+} // namespace detail
+
+class DOCTEST_INTERFACE Context
+{
+ detail::ContextState* p;
+
+ void parseArgs(int argc, const char* const* argv, bool withDefaults = false);
+
+public:
+ explicit Context(int argc = 0, const char* const* argv = nullptr);
+
+ Context(const Context&) = delete;
+ Context(Context&&) = delete;
+
+ Context& operator=(const Context&) = delete;
+ Context& operator=(Context&&) = delete;
+
+ ~Context(); // NOLINT(performance-trivially-destructible)
+
+ void applyCommandLine(int argc, const char* const* argv);
+
+ void addFilter(const char* filter, const char* value);
+ void clearFilters();
+ void setOption(const char* option, bool value);
+ void setOption(const char* option, int value);
+ void setOption(const char* option, const char* value);
+
+ bool shouldExit();
+
+ void setAsDefaultForAssertsOutOfTestCases();
+
+ void setAssertHandler(detail::assert_handler ah);
+
+ void setCout(std::ostream* out);
+
+ int run();
+};
+
+namespace TestCaseFailureReason {
+ enum Enum
+ {
+ None = 0,
+ AssertFailure = 1, // an assertion has failed in the test case
+ Exception = 2, // test case threw an exception
+ Crash = 4, // a crash...
+ TooManyFailedAsserts = 8, // the abort-after option
+ Timeout = 16, // see the timeout decorator
+ ShouldHaveFailedButDidnt = 32, // see the should_fail decorator
+ ShouldHaveFailedAndDid = 64, // see the should_fail decorator
+ DidntFailExactlyNumTimes = 128, // see the expected_failures decorator
+ FailedExactlyNumTimes = 256, // see the expected_failures decorator
+ CouldHaveFailedAndDid = 512 // see the may_fail decorator
+ };
+} // namespace TestCaseFailureReason
+
+struct DOCTEST_INTERFACE CurrentTestCaseStats
+{
+ int numAssertsCurrentTest;
+ int numAssertsFailedCurrentTest;
+ double seconds;
+ int failure_flags; // use TestCaseFailureReason::Enum
+ bool testCaseSuccess;
+};
+
+struct DOCTEST_INTERFACE TestCaseException
+{
+ String error_string;
+ bool is_crash;
+};
+
+struct DOCTEST_INTERFACE TestRunStats
+{
+ unsigned numTestCases;
+ unsigned numTestCasesPassingFilters;
+ unsigned numTestSuitesPassingFilters;
+ unsigned numTestCasesFailed;
+ int numAsserts;
+ int numAssertsFailed;
+};
+
+struct QueryData
+{
+ const TestRunStats* run_stats = nullptr;
+ const TestCaseData** data = nullptr;
+ unsigned num_data = 0;
+};
+
+struct DOCTEST_INTERFACE IReporter
+{
+ // The constructor has to accept "const ContextOptions&" as a single argument
+ // which has most of the options for the run + a pointer to the stdout stream
+ // Reporter(const ContextOptions& in)
+
+ // called when a query should be reported (listing test cases, printing the version, etc.)
+ virtual void report_query(const QueryData&) = 0;
+
+ // called when the whole test run starts
+ virtual void test_run_start() = 0;
+ // called when the whole test run ends (caching a pointer to the input doesn't make sense here)
+ virtual void test_run_end(const TestRunStats&) = 0;
+
+ // called when a test case is started (safe to cache a pointer to the input)
+ virtual void test_case_start(const TestCaseData&) = 0;
+ // called when a test case is reentered because of unfinished subcases (safe to cache a pointer to the input)
+ virtual void test_case_reenter(const TestCaseData&) = 0;
+ // called when a test case has ended
+ virtual void test_case_end(const CurrentTestCaseStats&) = 0;
+
+ // called when an exception is thrown from the test case (or it crashes)
+ virtual void test_case_exception(const TestCaseException&) = 0;
+
+ // called whenever a subcase is entered (don't cache pointers to the input)
+ virtual void subcase_start(const SubcaseSignature&) = 0;
+ // called whenever a subcase is exited (don't cache pointers to the input)
+ virtual void subcase_end() = 0;
+
+ // called for each assert (don't cache pointers to the input)
+ virtual void log_assert(const AssertData&) = 0;
+ // called for each message (don't cache pointers to the input)
+ virtual void log_message(const MessageData&) = 0;
+
+ // called when a test case is skipped either because it doesn't pass the filters, has a skip decorator
+ // or isn't in the execution range (between first and last) (safe to cache a pointer to the input)
+ virtual void test_case_skipped(const TestCaseData&) = 0;
+
+ DOCTEST_DECLARE_INTERFACE(IReporter)
+
+ // can obtain all currently active contexts and stringify them if one wishes to do so
+ static int get_num_active_contexts();
+ static const IContextScope* const* get_active_contexts();
+
+ // can iterate through contexts which have been stringified automatically in their destructors when an exception has been thrown
+ static int get_num_stringified_contexts();
+ static const String* get_stringified_contexts();
+};
+
+namespace detail {
+ using reporterCreatorFunc = IReporter* (*)(const ContextOptions&);
+
+ DOCTEST_INTERFACE void registerReporterImpl(const char* name, int prio, reporterCreatorFunc c, bool isReporter);
+
+ template <typename Reporter>
+ IReporter* reporterCreator(const ContextOptions& o) {
+ return new Reporter(o);
+ }
+} // namespace detail
+
+template <typename Reporter>
+int registerReporter(const char* name, int priority, bool isReporter) {
+ detail::registerReporterImpl(name, priority, detail::reporterCreator<Reporter>, isReporter);
+ return 0;
+}
+} // namespace doctest
+
+#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
+#define DOCTEST_FUNC_EMPTY [] { return false; }()
+#else
+#define DOCTEST_FUNC_EMPTY (void)0
+#endif
+
+// if registering is not disabled
+#ifndef DOCTEST_CONFIG_DISABLE
+
+#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
+#define DOCTEST_FUNC_SCOPE_BEGIN [&]
+#define DOCTEST_FUNC_SCOPE_END ()
+#define DOCTEST_FUNC_SCOPE_RET(v) return v
+#else
+#define DOCTEST_FUNC_SCOPE_BEGIN do
+#define DOCTEST_FUNC_SCOPE_END while(false)
+#define DOCTEST_FUNC_SCOPE_RET(v) (void)0
+#endif
+
+// common code in asserts - for convenience
+#define DOCTEST_ASSERT_LOG_REACT_RETURN(b) \
+ if(b.log()) DOCTEST_BREAK_INTO_DEBUGGER(); \
+ b.react(); \
+ DOCTEST_FUNC_SCOPE_RET(!b.m_failed)
+
+#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
+#define DOCTEST_WRAP_IN_TRY(x) x;
+#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
+#define DOCTEST_WRAP_IN_TRY(x) \
+ try { \
+ x; \
+ } catch(...) { DOCTEST_RB.translateException(); }
+#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
+
+#ifdef DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
+#define DOCTEST_CAST_TO_VOID(...) \
+ DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wuseless-cast") \
+ static_cast<void>(__VA_ARGS__); \
+ DOCTEST_GCC_SUPPRESS_WARNING_POP
+#else // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
+#define DOCTEST_CAST_TO_VOID(...) __VA_ARGS__;
+#endif // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
+
+// registers the test by initializing a dummy var with a function
+#define DOCTEST_REGISTER_FUNCTION(global_prefix, f, decorators) \
+ global_prefix DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT */ \
+ doctest::detail::regTest( \
+ doctest::detail::TestCase( \
+ f, __FILE__, __LINE__, \
+ doctest_detail_test_suite_ns::getCurrentTestSuite()) * \
+ decorators))
+
+#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators) \
+ namespace { /* NOLINT */ \
+ struct der : public base \
+ { \
+ void f(); \
+ }; \
+ static DOCTEST_INLINE_NOINLINE void func() { \
+ der v; \
+ v.f(); \
+ } \
+ DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, func, decorators) \
+ } \
+ DOCTEST_INLINE_NOINLINE void der::f() // NOLINT(misc-definitions-in-headers)
+
+#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators) \
+ static void f(); \
+ DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, f, decorators) \
+ static void f()
+
+#define DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(f, proxy, decorators) \
+ static doctest::detail::funcType proxy() { return f; } \
+ DOCTEST_REGISTER_FUNCTION(inline, proxy(), decorators) \
+ static void f()
+
+// for registering tests
+#define DOCTEST_TEST_CASE(decorators) \
+ DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
+
+// for registering tests in classes - requires C++17 for inline variables!
+#if DOCTEST_CPLUSPLUS >= 201703L
+#define DOCTEST_TEST_CASE_CLASS(decorators) \
+ DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), \
+ DOCTEST_ANONYMOUS(DOCTEST_ANON_PROXY_), \
+ decorators)
+#else // DOCTEST_TEST_CASE_CLASS
+#define DOCTEST_TEST_CASE_CLASS(...) \
+ TEST_CASES_CAN_BE_REGISTERED_IN_CLASSES_ONLY_IN_CPP17_MODE_OR_WITH_VS_2017_OR_NEWER
+#endif // DOCTEST_TEST_CASE_CLASS
+
+// for registering tests with a fixture
+#define DOCTEST_TEST_CASE_FIXTURE(c, decorators) \
+ DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), c, \
+ DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
+
+// for converting types to strings without the <typeinfo> header and demangling
+#define DOCTEST_TYPE_TO_STRING_AS(str, ...) \
+ namespace doctest { \
+ template <> \
+ inline String toString<__VA_ARGS__>() { \
+ return str; \
+ } \
+ } \
+ static_assert(true, "")
+
+#define DOCTEST_TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING_AS(#__VA_ARGS__, __VA_ARGS__)
+
+#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, iter, func) \
+ template <typename T> \
+ static void func(); \
+ namespace { /* NOLINT */ \
+ template <typename Tuple> \
+ struct iter; \
+ template <typename Type, typename... Rest> \
+ struct iter<std::tuple<Type, Rest...>> \
+ { \
+ iter(const char* file, unsigned line, int index) { \
+ doctest::detail::regTest(doctest::detail::TestCase(func<Type>, file, line, \
+ doctest_detail_test_suite_ns::getCurrentTestSuite(), \
+ doctest::toString<Type>(), \
+ int(line) * 1000 + index) \
+ * dec); \
+ iter<std::tuple<Rest...>>(file, line, index + 1); \
+ } \
+ }; \
+ template <> \
+ struct iter<std::tuple<>> \
+ { \
+ iter(const char*, unsigned, int) {} \
+ }; \
+ } \
+ template <typename T> \
+ static void func()
+
+#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(dec, T, id) \
+ DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(id, ITERATOR), \
+ DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_))
+
+#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, anon, ...) \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY), /* NOLINT(cert-err58-cpp, fuchsia-statically-constructed-objects) */ \
+ doctest::detail::instantiationHelper( \
+ DOCTEST_CAT(id, ITERATOR)<__VA_ARGS__>(__FILE__, __LINE__, 0)))
+
+#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) \
+ DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), std::tuple<__VA_ARGS__>) \
+ static_assert(true, "")
+
+#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) \
+ DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__) \
+ static_assert(true, "")
+
+#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, anon, ...) \
+ DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(anon, ITERATOR), anon); \
+ DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(anon, anon, std::tuple<__VA_ARGS__>) \
+ template <typename T> \
+ static void anon()
+
+#define DOCTEST_TEST_CASE_TEMPLATE(dec, T, ...) \
+ DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__)
+
+// for subcases
+#define DOCTEST_SUBCASE(name) \
+ if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(DOCTEST_ANON_SUBCASE_) DOCTEST_UNUSED = \
+ doctest::detail::Subcase(name, __FILE__, __LINE__))
+
+// for grouping tests in test suites by using code blocks
+#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name) \
+ namespace ns_name { namespace doctest_detail_test_suite_ns { \
+ static DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() noexcept { \
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4640) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors") \
+ DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmissing-field-initializers") \
+ static doctest::detail::TestSuite data{}; \
+ static bool inited = false; \
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP \
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP \
+ DOCTEST_GCC_SUPPRESS_WARNING_POP \
+ if(!inited) { \
+ data* decorators; \
+ inited = true; \
+ } \
+ return data; \
+ } \
+ } \
+ } \
+ namespace ns_name
+
+#define DOCTEST_TEST_SUITE(decorators) \
+ DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(DOCTEST_ANON_SUITE_))
+
+// for starting a testsuite block
+#define DOCTEST_TEST_SUITE_BEGIN(decorators) \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */ \
+ doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators)) \
+ static_assert(true, "")
+
+// for ending a testsuite block
+#define DOCTEST_TEST_SUITE_END \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */ \
+ doctest::detail::setTestSuite(doctest::detail::TestSuite() * "")) \
+ using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
+
+// for registering exception translators
+#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature) \
+ inline doctest::String translatorName(signature); \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_), /* NOLINT(cert-err58-cpp) */ \
+ doctest::registerExceptionTranslator(translatorName)) \
+ doctest::String translatorName(signature)
+
+#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \
+ DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_), \
+ signature)
+
+// for registering reporters
+#define DOCTEST_REGISTER_REPORTER(name, priority, reporter) \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
+ doctest::registerReporter<reporter>(name, priority, true)) \
+ static_assert(true, "")
+
+// for registering listeners
+#define DOCTEST_REGISTER_LISTENER(name, priority, reporter) \
+ DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
+ doctest::registerReporter<reporter>(name, priority, false)) \
+ static_assert(true, "")
+
+// clang-format off
+// for logging - disabling formatting because it's important to have these on 2 separate lines - see PR #557
+#define DOCTEST_INFO(...) \
+ DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_), \
+ DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_OTHER_), \
+ __VA_ARGS__)
+// clang-format on
+
+#define DOCTEST_INFO_IMPL(mb_name, s_name, ...) \
+ auto DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_) = doctest::detail::MakeContextScope( \
+ [&](std::ostream* s_name) { \
+ doctest::detail::MessageBuilder mb_name(__FILE__, __LINE__, doctest::assertType::is_warn); \
+ mb_name.m_stream = s_name; \
+ mb_name * __VA_ARGS__; \
+ })
+
+#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := ", x)
+
+#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ doctest::detail::MessageBuilder mb(file, line, doctest::assertType::type); \
+ mb * __VA_ARGS__; \
+ if(mb.log()) \
+ DOCTEST_BREAK_INTO_DEBUGGER(); \
+ mb.react(); \
+ } DOCTEST_FUNC_SCOPE_END
+
+// clang-format off
+#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
+#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
+#define DOCTEST_ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
+// clang-format on
+
+#define DOCTEST_MESSAGE(...) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, __VA_ARGS__)
+#define DOCTEST_FAIL_CHECK(...) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, __VA_ARGS__)
+#define DOCTEST_FAIL(...) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, __VA_ARGS__)
+
+#define DOCTEST_TO_LVALUE(...) __VA_ARGS__ // Not removed to keep backwards compatibility.
+
+#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#define DOCTEST_ASSERT_IMPLEMENT_2(assert_type, ...) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses") \
+ /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */ \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, #__VA_ARGS__); \
+ DOCTEST_WRAP_IN_TRY(DOCTEST_RB.setResult( \
+ doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type) \
+ << __VA_ARGS__)) /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */ \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ DOCTEST_ASSERT_IMPLEMENT_2(assert_type, __VA_ARGS__); \
+ } DOCTEST_FUNC_SCOPE_END // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+
+#define DOCTEST_BINARY_ASSERT(assert_type, comp, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, #__VA_ARGS__); \
+ DOCTEST_WRAP_IN_TRY( \
+ DOCTEST_RB.binary_assert<doctest::detail::binaryAssertComparison::comp>( \
+ __VA_ARGS__)) \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB); \
+ } DOCTEST_FUNC_SCOPE_END
+
+#define DOCTEST_UNARY_ASSERT(assert_type, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, #__VA_ARGS__); \
+ DOCTEST_WRAP_IN_TRY(DOCTEST_RB.unary_assert(__VA_ARGS__)) \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB); \
+ } DOCTEST_FUNC_SCOPE_END
+
+#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+// necessary for <ASSERT>_MESSAGE
+#define DOCTEST_ASSERT_IMPLEMENT_2 DOCTEST_ASSERT_IMPLEMENT_1
+
+#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...) \
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses") \
+ doctest::detail::decomp_assert( \
+ doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, \
+ doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type) \
+ << __VA_ARGS__) DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+#define DOCTEST_BINARY_ASSERT(assert_type, comparison, ...) \
+ doctest::detail::binary_assert<doctest::detail::binaryAssertComparison::comparison>( \
+ doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, __VA_ARGS__)
+
+#define DOCTEST_UNARY_ASSERT(assert_type, ...) \
+ doctest::detail::unary_assert(doctest::assertType::assert_type, __FILE__, __LINE__, \
+ #__VA_ARGS__, __VA_ARGS__)
+
+#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN, __VA_ARGS__)
+#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK, __VA_ARGS__)
+#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE, __VA_ARGS__)
+#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN_FALSE, __VA_ARGS__)
+#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK_FALSE, __VA_ARGS__)
+#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE_FALSE, __VA_ARGS__)
+
+// clang-format off
+#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN, cond); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK, cond); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE, cond); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
+// clang-format on
+
+#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, eq, __VA_ARGS__)
+#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, eq, __VA_ARGS__)
+#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, eq, __VA_ARGS__)
+#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, ne, __VA_ARGS__)
+#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, ne, __VA_ARGS__)
+#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, ne, __VA_ARGS__)
+#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, gt, __VA_ARGS__)
+#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, gt, __VA_ARGS__)
+#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, gt, __VA_ARGS__)
+#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lt, __VA_ARGS__)
+#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lt, __VA_ARGS__)
+#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lt, __VA_ARGS__)
+#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, ge, __VA_ARGS__)
+#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, ge, __VA_ARGS__)
+#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, ge, __VA_ARGS__)
+#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, le, __VA_ARGS__)
+#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, le, __VA_ARGS__)
+#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, le, __VA_ARGS__)
+
+#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, __VA_ARGS__)
+#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, __VA_ARGS__)
+#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, __VA_ARGS__)
+#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, __VA_ARGS__)
+#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, __VA_ARGS__)
+#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, __VA_ARGS__)
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#define DOCTEST_ASSERT_THROWS_AS(expr, assert_type, message, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ if(!doctest::getContextOptions()->no_throw) { \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, #expr, #__VA_ARGS__, message); \
+ try { \
+ DOCTEST_CAST_TO_VOID(expr) \
+ } catch(const typename doctest::detail::types::remove_const< \
+ typename doctest::detail::types::remove_reference<__VA_ARGS__>::type>::type&) {\
+ DOCTEST_RB.translateException(); \
+ DOCTEST_RB.m_threw_as = true; \
+ } catch(...) { DOCTEST_RB.translateException(); } \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB); \
+ } else { /* NOLINT(*-else-after-return) */ \
+ DOCTEST_FUNC_SCOPE_RET(false); \
+ } \
+ } DOCTEST_FUNC_SCOPE_END
+
+#define DOCTEST_ASSERT_THROWS_WITH(expr, expr_str, assert_type, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ if(!doctest::getContextOptions()->no_throw) { \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, expr_str, "", __VA_ARGS__); \
+ try { \
+ DOCTEST_CAST_TO_VOID(expr) \
+ } catch(...) { DOCTEST_RB.translateException(); } \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB); \
+ } else { /* NOLINT(*-else-after-return) */ \
+ DOCTEST_FUNC_SCOPE_RET(false); \
+ } \
+ } DOCTEST_FUNC_SCOPE_END
+
+#define DOCTEST_ASSERT_NOTHROW(assert_type, ...) \
+ DOCTEST_FUNC_SCOPE_BEGIN { \
+ doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
+ __LINE__, #__VA_ARGS__); \
+ try { \
+ DOCTEST_CAST_TO_VOID(__VA_ARGS__) \
+ } catch(...) { DOCTEST_RB.translateException(); } \
+ DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB); \
+ } DOCTEST_FUNC_SCOPE_END
+
+// clang-format off
+#define DOCTEST_WARN_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_WARN_THROWS, "")
+#define DOCTEST_CHECK_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_CHECK_THROWS, "")
+#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_REQUIRE_THROWS, "")
+
+#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_AS, "", __VA_ARGS__)
+#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_AS, "", __VA_ARGS__)
+#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_AS, "", __VA_ARGS__)
+
+#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_WARN_THROWS_WITH, __VA_ARGS__)
+#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_CHECK_THROWS_WITH, __VA_ARGS__)
+#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_REQUIRE_THROWS_WITH, __VA_ARGS__)
+
+#define DOCTEST_WARN_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_WITH_AS, message, __VA_ARGS__)
+#define DOCTEST_CHECK_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_WITH_AS, message, __VA_ARGS__)
+#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_WITH_AS, message, __VA_ARGS__)
+
+#define DOCTEST_WARN_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_WARN_NOTHROW, __VA_ARGS__)
+#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_CHECK_NOTHROW, __VA_ARGS__)
+#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_REQUIRE_NOTHROW, __VA_ARGS__)
+
+#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
+#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
+// clang-format on
+
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+// =================================================================================================
+// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING! ==
+// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY! ==
+// =================================================================================================
+#else // DOCTEST_CONFIG_DISABLE
+
+#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name) \
+ namespace /* NOLINT */ { \
+ template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \
+ struct der : public base \
+ { void f(); }; \
+ } \
+ template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \
+ inline void der<DOCTEST_UNUSED_TEMPLATE_TYPE>::f()
+
+#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name) \
+ template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \
+ static inline void f()
+
+// for registering tests
+#define DOCTEST_TEST_CASE(name) \
+ DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
+
+// for registering tests in classes
+#define DOCTEST_TEST_CASE_CLASS(name) \
+ DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
+
+// for registering tests with a fixture
+#define DOCTEST_TEST_CASE_FIXTURE(x, name) \
+ DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), x, \
+ DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
+
+// for converting types to strings without the <typeinfo> header and demangling
+#define DOCTEST_TYPE_TO_STRING_AS(str, ...) static_assert(true, "")
+#define DOCTEST_TYPE_TO_STRING(...) static_assert(true, "")
+
+// for typed tests
+#define DOCTEST_TEST_CASE_TEMPLATE(name, type, ...) \
+ template <typename type> \
+ inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
+
+#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id) \
+ template <typename type> \
+ inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
+
+#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) static_assert(true, "")
+#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) static_assert(true, "")
+
+// for subcases
+#define DOCTEST_SUBCASE(name)
+
+// for a testsuite block
+#define DOCTEST_TEST_SUITE(name) namespace // NOLINT
+
+// for starting a testsuite block
+#define DOCTEST_TEST_SUITE_BEGIN(name) static_assert(true, "")
+
+// for ending a testsuite block
+#define DOCTEST_TEST_SUITE_END using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
+
+#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \
+ template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \
+ static inline doctest::String DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_)(signature)
+
+#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)
+#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)
+
+#define DOCTEST_INFO(...) (static_cast<void>(0))
+#define DOCTEST_CAPTURE(x) (static_cast<void>(0))
+#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) (static_cast<void>(0))
+#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) (static_cast<void>(0))
+#define DOCTEST_ADD_FAIL_AT(file, line, ...) (static_cast<void>(0))
+#define DOCTEST_MESSAGE(...) (static_cast<void>(0))
+#define DOCTEST_FAIL_CHECK(...) (static_cast<void>(0))
+#define DOCTEST_FAIL(...) (static_cast<void>(0))
+
+#if defined(DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED) \
+ && defined(DOCTEST_CONFIG_ASSERTS_RETURN_VALUES)
+
+#define DOCTEST_WARN(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_CHECK(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_REQUIRE(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_WARN_FALSE(...) [&] { return !(__VA_ARGS__); }()
+#define DOCTEST_CHECK_FALSE(...) [&] { return !(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_FALSE(...) [&] { return !(__VA_ARGS__); }()
+
+#define DOCTEST_WARN_MESSAGE(cond, ...) [&] { return cond; }()
+#define DOCTEST_CHECK_MESSAGE(cond, ...) [&] { return cond; }()
+#define DOCTEST_REQUIRE_MESSAGE(cond, ...) [&] { return cond; }()
+#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
+#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
+#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
+
+namespace doctest {
+namespace detail {
+#define DOCTEST_RELATIONAL_OP(name, op) \
+ template <typename L, typename R> \
+ bool name(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs op rhs; }
+
+ DOCTEST_RELATIONAL_OP(eq, ==)
+ DOCTEST_RELATIONAL_OP(ne, !=)
+ DOCTEST_RELATIONAL_OP(lt, <)
+ DOCTEST_RELATIONAL_OP(gt, >)
+ DOCTEST_RELATIONAL_OP(le, <=)
+ DOCTEST_RELATIONAL_OP(ge, >=)
+} // namespace detail
+} // namespace doctest
+
+#define DOCTEST_WARN_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
+#define DOCTEST_CHECK_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
+#define DOCTEST_WARN_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
+#define DOCTEST_CHECK_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
+#define DOCTEST_WARN_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
+#define DOCTEST_CHECK_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
+#define DOCTEST_WARN_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
+#define DOCTEST_CHECK_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
+#define DOCTEST_WARN_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
+#define DOCTEST_CHECK_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
+#define DOCTEST_WARN_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
+#define DOCTEST_CHECK_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
+#define DOCTEST_WARN_UNARY(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_CHECK_UNARY(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_REQUIRE_UNARY(...) [&] { return __VA_ARGS__; }()
+#define DOCTEST_WARN_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
+#define DOCTEST_CHECK_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
+#define DOCTEST_REQUIRE_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#define DOCTEST_WARN_THROWS_WITH(expr, with, ...) [] { static_assert(false, "Exception translation is not available when doctest is disabled."); return false; }()
+#define DOCTEST_CHECK_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_REQUIRE_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+
+#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
+
+#define DOCTEST_WARN_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_CHECK_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_REQUIRE_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_WARN_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_CHECK_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_WARN_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+#define DOCTEST_CHECK_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+#define DOCTEST_REQUIRE_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+
+#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
+#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
+#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
+
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#else // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
+
+#define DOCTEST_WARN(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_FALSE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_FALSE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_FUNC_EMPTY
+
+#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
+
+#define DOCTEST_WARN_EQ(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_EQ(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_EQ(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_NE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_NE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_NE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_GT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_GT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_GT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_LT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_LT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_LT(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_GE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_GE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_GE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_LE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_LE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_LE(...) DOCTEST_FUNC_EMPTY
+
+#define DOCTEST_WARN_UNARY(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_UNARY(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#define DOCTEST_WARN_THROWS(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_NOTHROW(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_FUNC_EMPTY
+
+#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
+
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#endif // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
+
+#endif // DOCTEST_CONFIG_DISABLE
+
+#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS
+
+#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+#define DOCTEST_EXCEPTION_EMPTY_FUNC DOCTEST_FUNC_EMPTY
+#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+#define DOCTEST_EXCEPTION_EMPTY_FUNC [] { static_assert(false, "Exceptions are disabled! " \
+ "Use DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS if you want to compile with exceptions disabled."); return false; }()
+
+#undef DOCTEST_REQUIRE
+#undef DOCTEST_REQUIRE_FALSE
+#undef DOCTEST_REQUIRE_MESSAGE
+#undef DOCTEST_REQUIRE_FALSE_MESSAGE
+#undef DOCTEST_REQUIRE_EQ
+#undef DOCTEST_REQUIRE_NE
+#undef DOCTEST_REQUIRE_GT
+#undef DOCTEST_REQUIRE_LT
+#undef DOCTEST_REQUIRE_GE
+#undef DOCTEST_REQUIRE_LE
+#undef DOCTEST_REQUIRE_UNARY
+#undef DOCTEST_REQUIRE_UNARY_FALSE
+
+#define DOCTEST_REQUIRE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_FALSE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_EQ DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_NE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_GT DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_LT DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_GE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_LE DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_UNARY DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_UNARY_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
+
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+
+#define DOCTEST_WARN_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
+
+#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
+
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+// clang-format off
+// KEPT FOR BACKWARDS COMPATIBILITY - FORWARDING TO THE RIGHT MACROS
+#define DOCTEST_FAST_WARN_EQ DOCTEST_WARN_EQ
+#define DOCTEST_FAST_CHECK_EQ DOCTEST_CHECK_EQ
+#define DOCTEST_FAST_REQUIRE_EQ DOCTEST_REQUIRE_EQ
+#define DOCTEST_FAST_WARN_NE DOCTEST_WARN_NE
+#define DOCTEST_FAST_CHECK_NE DOCTEST_CHECK_NE
+#define DOCTEST_FAST_REQUIRE_NE DOCTEST_REQUIRE_NE
+#define DOCTEST_FAST_WARN_GT DOCTEST_WARN_GT
+#define DOCTEST_FAST_CHECK_GT DOCTEST_CHECK_GT
+#define DOCTEST_FAST_REQUIRE_GT DOCTEST_REQUIRE_GT
+#define DOCTEST_FAST_WARN_LT DOCTEST_WARN_LT
+#define DOCTEST_FAST_CHECK_LT DOCTEST_CHECK_LT
+#define DOCTEST_FAST_REQUIRE_LT DOCTEST_REQUIRE_LT
+#define DOCTEST_FAST_WARN_GE DOCTEST_WARN_GE
+#define DOCTEST_FAST_CHECK_GE DOCTEST_CHECK_GE
+#define DOCTEST_FAST_REQUIRE_GE DOCTEST_REQUIRE_GE
+#define DOCTEST_FAST_WARN_LE DOCTEST_WARN_LE
+#define DOCTEST_FAST_CHECK_LE DOCTEST_CHECK_LE
+#define DOCTEST_FAST_REQUIRE_LE DOCTEST_REQUIRE_LE
+
+#define DOCTEST_FAST_WARN_UNARY DOCTEST_WARN_UNARY
+#define DOCTEST_FAST_CHECK_UNARY DOCTEST_CHECK_UNARY
+#define DOCTEST_FAST_REQUIRE_UNARY DOCTEST_REQUIRE_UNARY
+#define DOCTEST_FAST_WARN_UNARY_FALSE DOCTEST_WARN_UNARY_FALSE
+#define DOCTEST_FAST_CHECK_UNARY_FALSE DOCTEST_CHECK_UNARY_FALSE
+#define DOCTEST_FAST_REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE
+
+#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id,__VA_ARGS__)
+// clang-format on
+
+// BDD style macros
+// clang-format off
+#define DOCTEST_SCENARIO(name) DOCTEST_TEST_CASE(" Scenario: " name)
+#define DOCTEST_SCENARIO_CLASS(name) DOCTEST_TEST_CASE_CLASS(" Scenario: " name)
+#define DOCTEST_SCENARIO_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(" Scenario: " name, T, __VA_ARGS__)
+#define DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(" Scenario: " name, T, id)
+
+#define DOCTEST_GIVEN(name) DOCTEST_SUBCASE(" Given: " name)
+#define DOCTEST_WHEN(name) DOCTEST_SUBCASE(" When: " name)
+#define DOCTEST_AND_WHEN(name) DOCTEST_SUBCASE("And when: " name)
+#define DOCTEST_THEN(name) DOCTEST_SUBCASE(" Then: " name)
+#define DOCTEST_AND_THEN(name) DOCTEST_SUBCASE(" And: " name)
+// clang-format on
+
+// == SHORT VERSIONS OF THE MACROS
+#ifndef DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
+
+#define TEST_CASE(name) DOCTEST_TEST_CASE(name)
+#define TEST_CASE_CLASS(name) DOCTEST_TEST_CASE_CLASS(name)
+#define TEST_CASE_FIXTURE(x, name) DOCTEST_TEST_CASE_FIXTURE(x, name)
+#define TYPE_TO_STRING_AS(str, ...) DOCTEST_TYPE_TO_STRING_AS(str, __VA_ARGS__)
+#define TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING(__VA_ARGS__)
+#define TEST_CASE_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(name, T, __VA_ARGS__)
+#define TEST_CASE_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, T, id)
+#define TEST_CASE_TEMPLATE_INVOKE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, __VA_ARGS__)
+#define TEST_CASE_TEMPLATE_APPLY(id, ...) DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, __VA_ARGS__)
+#define SUBCASE(name) DOCTEST_SUBCASE(name)
+#define TEST_SUITE(decorators) DOCTEST_TEST_SUITE(decorators)
+#define TEST_SUITE_BEGIN(name) DOCTEST_TEST_SUITE_BEGIN(name)
+#define TEST_SUITE_END DOCTEST_TEST_SUITE_END
+#define REGISTER_EXCEPTION_TRANSLATOR(signature) DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)
+#define REGISTER_REPORTER(name, priority, reporter) DOCTEST_REGISTER_REPORTER(name, priority, reporter)
+#define REGISTER_LISTENER(name, priority, reporter) DOCTEST_REGISTER_LISTENER(name, priority, reporter)
+#define INFO(...) DOCTEST_INFO(__VA_ARGS__)
+#define CAPTURE(x) DOCTEST_CAPTURE(x)
+#define ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_MESSAGE_AT(file, line, __VA_ARGS__)
+#define ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_FAIL_CHECK_AT(file, line, __VA_ARGS__)
+#define ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_FAIL_AT(file, line, __VA_ARGS__)
+#define MESSAGE(...) DOCTEST_MESSAGE(__VA_ARGS__)
+#define FAIL_CHECK(...) DOCTEST_FAIL_CHECK(__VA_ARGS__)
+#define FAIL(...) DOCTEST_FAIL(__VA_ARGS__)
+#define TO_LVALUE(...) DOCTEST_TO_LVALUE(__VA_ARGS__)
+
+#define WARN(...) DOCTEST_WARN(__VA_ARGS__)
+#define WARN_FALSE(...) DOCTEST_WARN_FALSE(__VA_ARGS__)
+#define WARN_THROWS(...) DOCTEST_WARN_THROWS(__VA_ARGS__)
+#define WARN_THROWS_AS(expr, ...) DOCTEST_WARN_THROWS_AS(expr, __VA_ARGS__)
+#define WARN_THROWS_WITH(expr, ...) DOCTEST_WARN_THROWS_WITH(expr, __VA_ARGS__)
+#define WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_WARN_THROWS_WITH_AS(expr, with, __VA_ARGS__)
+#define WARN_NOTHROW(...) DOCTEST_WARN_NOTHROW(__VA_ARGS__)
+#define CHECK(...) DOCTEST_CHECK(__VA_ARGS__)
+#define CHECK_FALSE(...) DOCTEST_CHECK_FALSE(__VA_ARGS__)
+#define CHECK_THROWS(...) DOCTEST_CHECK_THROWS(__VA_ARGS__)
+#define CHECK_THROWS_AS(expr, ...) DOCTEST_CHECK_THROWS_AS(expr, __VA_ARGS__)
+#define CHECK_THROWS_WITH(expr, ...) DOCTEST_CHECK_THROWS_WITH(expr, __VA_ARGS__)
+#define CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_AS(expr, with, __VA_ARGS__)
+#define CHECK_NOTHROW(...) DOCTEST_CHECK_NOTHROW(__VA_ARGS__)
+#define REQUIRE(...) DOCTEST_REQUIRE(__VA_ARGS__)
+#define REQUIRE_FALSE(...) DOCTEST_REQUIRE_FALSE(__VA_ARGS__)
+#define REQUIRE_THROWS(...) DOCTEST_REQUIRE_THROWS(__VA_ARGS__)
+#define REQUIRE_THROWS_AS(expr, ...) DOCTEST_REQUIRE_THROWS_AS(expr, __VA_ARGS__)
+#define REQUIRE_THROWS_WITH(expr, ...) DOCTEST_REQUIRE_THROWS_WITH(expr, __VA_ARGS__)
+#define REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, __VA_ARGS__)
+#define REQUIRE_NOTHROW(...) DOCTEST_REQUIRE_NOTHROW(__VA_ARGS__)
+
+#define WARN_MESSAGE(cond, ...) DOCTEST_WARN_MESSAGE(cond, __VA_ARGS__)
+#define WARN_FALSE_MESSAGE(cond, ...) DOCTEST_WARN_FALSE_MESSAGE(cond, __VA_ARGS__)
+#define WARN_THROWS_MESSAGE(expr, ...) DOCTEST_WARN_THROWS_MESSAGE(expr, __VA_ARGS__)
+#define WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
+#define WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
+#define WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
+#define WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_WARN_NOTHROW_MESSAGE(expr, __VA_ARGS__)
+#define CHECK_MESSAGE(cond, ...) DOCTEST_CHECK_MESSAGE(cond, __VA_ARGS__)
+#define CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_CHECK_FALSE_MESSAGE(cond, __VA_ARGS__)
+#define CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_CHECK_THROWS_MESSAGE(expr, __VA_ARGS__)
+#define CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
+#define CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
+#define CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
+#define CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_CHECK_NOTHROW_MESSAGE(expr, __VA_ARGS__)
+#define REQUIRE_MESSAGE(cond, ...) DOCTEST_REQUIRE_MESSAGE(cond, __VA_ARGS__)
+#define REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_REQUIRE_FALSE_MESSAGE(cond, __VA_ARGS__)
+#define REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_REQUIRE_THROWS_MESSAGE(expr, __VA_ARGS__)
+#define REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
+#define REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
+#define REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
+#define REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, __VA_ARGS__)
+
+#define SCENARIO(name) DOCTEST_SCENARIO(name)
+#define SCENARIO_CLASS(name) DOCTEST_SCENARIO_CLASS(name)
+#define SCENARIO_TEMPLATE(name, T, ...) DOCTEST_SCENARIO_TEMPLATE(name, T, __VA_ARGS__)
+#define SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id)
+#define GIVEN(name) DOCTEST_GIVEN(name)
+#define WHEN(name) DOCTEST_WHEN(name)
+#define AND_WHEN(name) DOCTEST_AND_WHEN(name)
+#define THEN(name) DOCTEST_THEN(name)
+#define AND_THEN(name) DOCTEST_AND_THEN(name)
+
+#define WARN_EQ(...) DOCTEST_WARN_EQ(__VA_ARGS__)
+#define CHECK_EQ(...) DOCTEST_CHECK_EQ(__VA_ARGS__)
+#define REQUIRE_EQ(...) DOCTEST_REQUIRE_EQ(__VA_ARGS__)
+#define WARN_NE(...) DOCTEST_WARN_NE(__VA_ARGS__)
+#define CHECK_NE(...) DOCTEST_CHECK_NE(__VA_ARGS__)
+#define REQUIRE_NE(...) DOCTEST_REQUIRE_NE(__VA_ARGS__)
+#define WARN_GT(...) DOCTEST_WARN_GT(__VA_ARGS__)
+#define CHECK_GT(...) DOCTEST_CHECK_GT(__VA_ARGS__)
+#define REQUIRE_GT(...) DOCTEST_REQUIRE_GT(__VA_ARGS__)
+#define WARN_LT(...) DOCTEST_WARN_LT(__VA_ARGS__)
+#define CHECK_LT(...) DOCTEST_CHECK_LT(__VA_ARGS__)
+#define REQUIRE_LT(...) DOCTEST_REQUIRE_LT(__VA_ARGS__)
+#define WARN_GE(...) DOCTEST_WARN_GE(__VA_ARGS__)
+#define CHECK_GE(...) DOCTEST_CHECK_GE(__VA_ARGS__)
+#define REQUIRE_GE(...) DOCTEST_REQUIRE_GE(__VA_ARGS__)
+#define WARN_LE(...) DOCTEST_WARN_LE(__VA_ARGS__)
+#define CHECK_LE(...) DOCTEST_CHECK_LE(__VA_ARGS__)
+#define REQUIRE_LE(...) DOCTEST_REQUIRE_LE(__VA_ARGS__)
+#define WARN_UNARY(...) DOCTEST_WARN_UNARY(__VA_ARGS__)
+#define CHECK_UNARY(...) DOCTEST_CHECK_UNARY(__VA_ARGS__)
+#define REQUIRE_UNARY(...) DOCTEST_REQUIRE_UNARY(__VA_ARGS__)
+#define WARN_UNARY_FALSE(...) DOCTEST_WARN_UNARY_FALSE(__VA_ARGS__)
+#define CHECK_UNARY_FALSE(...) DOCTEST_CHECK_UNARY_FALSE(__VA_ARGS__)
+#define REQUIRE_UNARY_FALSE(...) DOCTEST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
+
+// KEPT FOR BACKWARDS COMPATIBILITY
+#define FAST_WARN_EQ(...) DOCTEST_FAST_WARN_EQ(__VA_ARGS__)
+#define FAST_CHECK_EQ(...) DOCTEST_FAST_CHECK_EQ(__VA_ARGS__)
+#define FAST_REQUIRE_EQ(...) DOCTEST_FAST_REQUIRE_EQ(__VA_ARGS__)
+#define FAST_WARN_NE(...) DOCTEST_FAST_WARN_NE(__VA_ARGS__)
+#define FAST_CHECK_NE(...) DOCTEST_FAST_CHECK_NE(__VA_ARGS__)
+#define FAST_REQUIRE_NE(...) DOCTEST_FAST_REQUIRE_NE(__VA_ARGS__)
+#define FAST_WARN_GT(...) DOCTEST_FAST_WARN_GT(__VA_ARGS__)
+#define FAST_CHECK_GT(...) DOCTEST_FAST_CHECK_GT(__VA_ARGS__)
+#define FAST_REQUIRE_GT(...) DOCTEST_FAST_REQUIRE_GT(__VA_ARGS__)
+#define FAST_WARN_LT(...) DOCTEST_FAST_WARN_LT(__VA_ARGS__)
+#define FAST_CHECK_LT(...) DOCTEST_FAST_CHECK_LT(__VA_ARGS__)
+#define FAST_REQUIRE_LT(...) DOCTEST_FAST_REQUIRE_LT(__VA_ARGS__)
+#define FAST_WARN_GE(...) DOCTEST_FAST_WARN_GE(__VA_ARGS__)
+#define FAST_CHECK_GE(...) DOCTEST_FAST_CHECK_GE(__VA_ARGS__)
+#define FAST_REQUIRE_GE(...) DOCTEST_FAST_REQUIRE_GE(__VA_ARGS__)
+#define FAST_WARN_LE(...) DOCTEST_FAST_WARN_LE(__VA_ARGS__)
+#define FAST_CHECK_LE(...) DOCTEST_FAST_CHECK_LE(__VA_ARGS__)
+#define FAST_REQUIRE_LE(...) DOCTEST_FAST_REQUIRE_LE(__VA_ARGS__)
+
+#define FAST_WARN_UNARY(...) DOCTEST_FAST_WARN_UNARY(__VA_ARGS__)
+#define FAST_CHECK_UNARY(...) DOCTEST_FAST_CHECK_UNARY(__VA_ARGS__)
+#define FAST_REQUIRE_UNARY(...) DOCTEST_FAST_REQUIRE_UNARY(__VA_ARGS__)
+#define FAST_WARN_UNARY_FALSE(...) DOCTEST_FAST_WARN_UNARY_FALSE(__VA_ARGS__)
+#define FAST_CHECK_UNARY_FALSE(...) DOCTEST_FAST_CHECK_UNARY_FALSE(__VA_ARGS__)
+#define FAST_REQUIRE_UNARY_FALSE(...) DOCTEST_FAST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
+
+#define TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, __VA_ARGS__)
+
+#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
+
+#ifndef DOCTEST_CONFIG_DISABLE
+
+// this is here to clear the 'current test suite' for the current translation unit - at the top
+DOCTEST_TEST_SUITE_END();
+
+#endif // DOCTEST_CONFIG_DISABLE
+
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+DOCTEST_GCC_SUPPRESS_WARNING_POP
+
+DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
+
+#endif // DOCTEST_LIBRARY_INCLUDED
+
+#ifndef DOCTEST_SINGLE_HEADER
+#define DOCTEST_SINGLE_HEADER
+#endif // DOCTEST_SINGLE_HEADER
+
+#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER)
+
+#ifndef DOCTEST_SINGLE_HEADER
+#include "doctest_fwd.h"
+#endif // DOCTEST_SINGLE_HEADER
+
+DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-macros")
+
+#ifndef DOCTEST_LIBRARY_IMPLEMENTATION
+#define DOCTEST_LIBRARY_IMPLEMENTATION
+
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
+
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wglobal-constructors")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wshorten-64-to-32")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-variable-declarations")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch-enum")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wcovered-switch-default")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-noreturn")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wdisabled-macro-expansion")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-braces")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-field-initializers")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wnonportable-system-include-path")
+
+DOCTEST_GCC_SUPPRESS_WARNING_PUSH
+DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-field-initializers")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-braces")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-enum")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-default")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wunsafe-loop-optimizations")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wold-style-cast")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-function")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wmultiple-inheritance")
+DOCTEST_GCC_SUPPRESS_WARNING("-Wsuggest-attribute")
+
+DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
+DOCTEST_MSVC_SUPPRESS_WARNING(4267) // 'var' : conversion from 'x' to 'y', possible loss of data
+DOCTEST_MSVC_SUPPRESS_WARNING(4530) // C++ exception handler used, but unwind semantics not enabled
+DOCTEST_MSVC_SUPPRESS_WARNING(4577) // 'noexcept' used with no exception handling mode specified
+DOCTEST_MSVC_SUPPRESS_WARNING(4774) // format string expected in argument is not a string literal
+DOCTEST_MSVC_SUPPRESS_WARNING(4365) // conversion from 'int' to 'unsigned', signed/unsigned mismatch
+DOCTEST_MSVC_SUPPRESS_WARNING(5039) // pointer to potentially throwing function passed to extern C
+DOCTEST_MSVC_SUPPRESS_WARNING(4800) // forcing value to bool 'true' or 'false' (performance warning)
+DOCTEST_MSVC_SUPPRESS_WARNING(5245) // unreferenced function with internal linkage has been removed
+
+DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
+
+// required includes - will go only in one translation unit!
+#include <ctime>
+#include <cmath>
+#include <climits>
+// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/doctest/doctest/pull/37
+#ifdef __BORLANDC__
+#include <math.h>
+#endif // __BORLANDC__
+#include <new>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <utility>
+#include <fstream>
+#include <sstream>
+#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+#include <iostream>
+#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+#include <algorithm>
+#include <iomanip>
+#include <vector>
+#ifndef DOCTEST_CONFIG_NO_MULTITHREADING
+#include <atomic>
+#include <mutex>
+#define DOCTEST_DECLARE_MUTEX(name) std::mutex name;
+#define DOCTEST_DECLARE_STATIC_MUTEX(name) static DOCTEST_DECLARE_MUTEX(name)
+#define DOCTEST_LOCK_MUTEX(name) std::lock_guard<std::mutex> DOCTEST_ANONYMOUS(DOCTEST_ANON_LOCK_)(name);
+#else // DOCTEST_CONFIG_NO_MULTITHREADING
+#define DOCTEST_DECLARE_MUTEX(name)
+#define DOCTEST_DECLARE_STATIC_MUTEX(name)
+#define DOCTEST_LOCK_MUTEX(name)
+#endif // DOCTEST_CONFIG_NO_MULTITHREADING
+#include <set>
+#include <map>
+#include <unordered_set>
+#include <exception>
+#include <stdexcept>
+#include <csignal>
+#include <cfloat>
+#include <cctype>
+#include <cstdint>
+#include <string>
+
+#ifdef DOCTEST_PLATFORM_MAC
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/sysctl.h>
+#endif // DOCTEST_PLATFORM_MAC
+
+#ifdef DOCTEST_PLATFORM_WINDOWS
+
+// defines for a leaner windows.h
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#define DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
+#endif // WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+#define NOMINMAX
+#define DOCTEST_UNDEF_NOMINMAX
+#endif // NOMINMAX
+
+// not sure what AfxWin.h is for - here I do what Catch does
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+#include <io.h>
+
+#else // DOCTEST_PLATFORM_WINDOWS
+
+#include <sys/time.h>
+#include <unistd.h>
+
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+// this is a fix for https://github.com/doctest/doctest/issues/348
+// https://mail.gnome.org/archives/xml/2012-January/msg00000.html
+#if !defined(HAVE_UNISTD_H) && !defined(STDOUT_FILENO)
+#define STDOUT_FILENO fileno(stdout)
+#endif // HAVE_UNISTD_H
+
+DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
+
+// counts the number of elements in a C array
+#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0]))
+
+#ifdef DOCTEST_CONFIG_DISABLE
+#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_disabled
+#else // DOCTEST_CONFIG_DISABLE
+#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_not_disabled
+#endif // DOCTEST_CONFIG_DISABLE
+
+#ifndef DOCTEST_CONFIG_OPTIONS_PREFIX
+#define DOCTEST_CONFIG_OPTIONS_PREFIX "dt-"
+#endif
+
+#ifndef DOCTEST_THREAD_LOCAL
+#if defined(DOCTEST_CONFIG_NO_MULTITHREADING) || DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
+#define DOCTEST_THREAD_LOCAL
+#else // DOCTEST_MSVC
+#define DOCTEST_THREAD_LOCAL thread_local
+#endif // DOCTEST_MSVC
+#endif // DOCTEST_THREAD_LOCAL
+
+#ifndef DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES
+#define DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES 32
+#endif
+
+#ifndef DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE
+#define DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE 64
+#endif
+
+#ifdef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
+#define DOCTEST_OPTIONS_PREFIX_DISPLAY DOCTEST_CONFIG_OPTIONS_PREFIX
+#else
+#define DOCTEST_OPTIONS_PREFIX_DISPLAY ""
+#endif
+
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
+#endif
+
+#ifndef DOCTEST_CDECL
+#define DOCTEST_CDECL __cdecl
+#endif
+
+namespace doctest {
+
+bool is_running_in_test = false;
+
+namespace {
+ using namespace detail;
+
+ template <typename Ex>
+ DOCTEST_NORETURN void throw_exception(Ex const& e) {
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ throw e;
+#else // DOCTEST_CONFIG_NO_EXCEPTIONS
+#ifdef DOCTEST_CONFIG_HANDLE_EXCEPTION
+ DOCTEST_CONFIG_HANDLE_EXCEPTION(e);
+#else // DOCTEST_CONFIG_HANDLE_EXCEPTION
+#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ std::cerr << "doctest will terminate because it needed to throw an exception.\n"
+ << "The message was: " << e.what() << '\n';
+#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+#endif // DOCTEST_CONFIG_HANDLE_EXCEPTION
+ std::terminate();
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+ }
+
+#ifndef DOCTEST_INTERNAL_ERROR
+#define DOCTEST_INTERNAL_ERROR(msg) \
+ throw_exception(std::logic_error( \
+ __FILE__ ":" DOCTEST_TOSTR(__LINE__) ": Internal doctest error: " msg))
+#endif // DOCTEST_INTERNAL_ERROR
+
+ // case insensitive strcmp
+ int stricmp(const char* a, const char* b) {
+ for(;; a++, b++) {
+ const int d = tolower(*a) - tolower(*b);
+ if(d != 0 || !*a)
+ return d;
+ }
+ }
+
+ struct Endianness
+ {
+ enum Arch
+ {
+ Big,
+ Little
+ };
+
+ static Arch which() {
+ int x = 1;
+ // casting any data pointer to char* is allowed
+ auto ptr = reinterpret_cast<char*>(&x);
+ if(*ptr)
+ return Little;
+ return Big;
+ }
+ };
+} // namespace
+
+namespace detail {
+ DOCTEST_THREAD_LOCAL class
+ {
+ std::vector<std::streampos> stack;
+ std::stringstream ss;
+
+ public:
+ std::ostream* push() {
+ stack.push_back(ss.tellp());
+ return &ss;
+ }
+
+ String pop() {
+ if (stack.empty())
+ DOCTEST_INTERNAL_ERROR("TLSS was empty when trying to pop!");
+
+ std::streampos pos = stack.back();
+ stack.pop_back();
+ unsigned sz = static_cast<unsigned>(ss.tellp() - pos);
+ ss.rdbuf()->pubseekpos(pos, std::ios::in | std::ios::out);
+ return String(ss, sz);
+ }
+ } g_oss;
+
+ std::ostream* tlssPush() {
+ return g_oss.push();
+ }
+
+ String tlssPop() {
+ return g_oss.pop();
+ }
+
+#ifndef DOCTEST_CONFIG_DISABLE
+
+namespace timer_large_integer
+{
+
+#if defined(DOCTEST_PLATFORM_WINDOWS)
+ using type = ULONGLONG;
+#else // DOCTEST_PLATFORM_WINDOWS
+ using type = std::uint64_t;
+#endif // DOCTEST_PLATFORM_WINDOWS
+}
+
+using ticks_t = timer_large_integer::type;
+
+#ifdef DOCTEST_CONFIG_GETCURRENTTICKS
+ ticks_t getCurrentTicks() { return DOCTEST_CONFIG_GETCURRENTTICKS(); }
+#elif defined(DOCTEST_PLATFORM_WINDOWS)
+ ticks_t getCurrentTicks() {
+ static LARGE_INTEGER hz = { {0} }, hzo = { {0} };
+ if(!hz.QuadPart) {
+ QueryPerformanceFrequency(&hz);
+ QueryPerformanceCounter(&hzo);
+ }
+ LARGE_INTEGER t;
+ QueryPerformanceCounter(&t);
+ return ((t.QuadPart - hzo.QuadPart) * LONGLONG(1000000)) / hz.QuadPart;
+ }
+#else // DOCTEST_PLATFORM_WINDOWS
+ ticks_t getCurrentTicks() {
+ timeval t;
+ gettimeofday(&t, nullptr);
+ return static_cast<ticks_t>(t.tv_sec) * 1000000 + static_cast<ticks_t>(t.tv_usec);
+ }
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+ struct Timer
+ {
+ void start() { m_ticks = getCurrentTicks(); }
+ unsigned int getElapsedMicroseconds() const {
+ return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+ }
+ //unsigned int getElapsedMilliseconds() const {
+ // return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
+ //}
+ double getElapsedSeconds() const { return static_cast<double>(getCurrentTicks() - m_ticks) / 1000000.0; }
+
+ private:
+ ticks_t m_ticks = 0;
+ };
+
+#ifdef DOCTEST_CONFIG_NO_MULTITHREADING
+ template <typename T>
+ using Atomic = T;
+#else // DOCTEST_CONFIG_NO_MULTITHREADING
+ template <typename T>
+ using Atomic = std::atomic<T>;
+#endif // DOCTEST_CONFIG_NO_MULTITHREADING
+
+#if defined(DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS) || defined(DOCTEST_CONFIG_NO_MULTITHREADING)
+ template <typename T>
+ using MultiLaneAtomic = Atomic<T>;
+#else // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
+ // Provides a multilane implementation of an atomic variable that supports add, sub, load,
+ // store. Instead of using a single atomic variable, this splits up into multiple ones,
+ // each sitting on a separate cache line. The goal is to provide a speedup when most
+ // operations are modifying. It achieves this with two properties:
+ //
+ // * Multiple atomics are used, so chance of congestion from the same atomic is reduced.
+ // * Each atomic sits on a separate cache line, so false sharing is reduced.
+ //
+ // The disadvantage is that there is a small overhead due to the use of TLS, and load/store
+ // is slower because all atomics have to be accessed.
+ template <typename T>
+ class MultiLaneAtomic
+ {
+ struct CacheLineAlignedAtomic
+ {
+ Atomic<T> atomic{};
+ char padding[DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE - sizeof(Atomic<T>)];
+ };
+ CacheLineAlignedAtomic m_atomics[DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES];
+
+ static_assert(sizeof(CacheLineAlignedAtomic) == DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE,
+ "guarantee one atomic takes exactly one cache line");
+
+ public:
+ T operator++() DOCTEST_NOEXCEPT { return fetch_add(1) + 1; }
+
+ T operator++(int) DOCTEST_NOEXCEPT { return fetch_add(1); }
+
+ T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
+ return myAtomic().fetch_add(arg, order);
+ }
+
+ T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
+ return myAtomic().fetch_sub(arg, order);
+ }
+
+ operator T() const DOCTEST_NOEXCEPT { return load(); }
+
+ T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT {
+ auto result = T();
+ for(auto const& c : m_atomics) {
+ result += c.atomic.load(order);
+ }
+ return result;
+ }
+
+ T operator=(T desired) DOCTEST_NOEXCEPT { // lgtm [cpp/assignment-does-not-return-this]
+ store(desired);
+ return desired;
+ }
+
+ void store(T desired, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
+ // first value becomes desired", all others become 0.
+ for(auto& c : m_atomics) {
+ c.atomic.store(desired, order);
+ desired = {};
+ }
+ }
+
+ private:
+ // Each thread has a different atomic that it operates on. If more than NumLanes threads
+ // use this, some will use the same atomic. So performance will degrade a bit, but still
+ // everything will work.
+ //
+ // The logic here is a bit tricky. The call should be as fast as possible, so that there
+ // is minimal to no overhead in determining the correct atomic for the current thread.
+ //
+ // 1. A global static counter laneCounter counts continuously up.
+ // 2. Each successive thread will use modulo operation of that counter so it gets an atomic
+ // assigned in a round-robin fashion.
+ // 3. This tlsLaneIdx is stored in the thread local data, so it is directly available with
+ // little overhead.
+ Atomic<T>& myAtomic() DOCTEST_NOEXCEPT {
+ static Atomic<size_t> laneCounter;
+ DOCTEST_THREAD_LOCAL size_t tlsLaneIdx =
+ laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES;
+
+ return m_atomics[tlsLaneIdx].atomic;
+ }
+ };
+#endif // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
+
+ // this holds both parameters from the command line and runtime data for tests
+ struct ContextState : ContextOptions, TestRunStats, CurrentTestCaseStats
+ {
+ MultiLaneAtomic<int> numAssertsCurrentTest_atomic;
+ MultiLaneAtomic<int> numAssertsFailedCurrentTest_atomic;
+
+ std::vector<std::vector<String>> filters = decltype(filters)(9); // 9 different filters
+
+ std::vector<IReporter*> reporters_currently_used;
+
+ assert_handler ah = nullptr;
+
+ Timer timer;
+
+ std::vector<String> stringifiedContexts; // logging from INFO() due to an exception
+
+ // stuff for subcases
+ bool reachedLeaf;
+ std::vector<SubcaseSignature> subcaseStack;
+ std::vector<SubcaseSignature> nextSubcaseStack;
+ std::unordered_set<unsigned long long> fullyTraversedSubcases;
+ size_t currentSubcaseDepth;
+ Atomic<bool> shouldLogCurrentException;
+
+ void resetRunData() {
+ numTestCases = 0;
+ numTestCasesPassingFilters = 0;
+ numTestSuitesPassingFilters = 0;
+ numTestCasesFailed = 0;
+ numAsserts = 0;
+ numAssertsFailed = 0;
+ numAssertsCurrentTest = 0;
+ numAssertsFailedCurrentTest = 0;
+ }
+
+ void finalizeTestCaseData() {
+ seconds = timer.getElapsedSeconds();
+
+ // update the non-atomic counters
+ numAsserts += numAssertsCurrentTest_atomic;
+ numAssertsFailed += numAssertsFailedCurrentTest_atomic;
+ numAssertsCurrentTest = numAssertsCurrentTest_atomic;
+ numAssertsFailedCurrentTest = numAssertsFailedCurrentTest_atomic;
+
+ if(numAssertsFailedCurrentTest)
+ failure_flags |= TestCaseFailureReason::AssertFailure;
+
+ if(Approx(currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 &&
+ Approx(seconds).epsilon(DBL_EPSILON) > currentTest->m_timeout)
+ failure_flags |= TestCaseFailureReason::Timeout;
+
+ if(currentTest->m_should_fail) {
+ if(failure_flags) {
+ failure_flags |= TestCaseFailureReason::ShouldHaveFailedAndDid;
+ } else {
+ failure_flags |= TestCaseFailureReason::ShouldHaveFailedButDidnt;
+ }
+ } else if(failure_flags && currentTest->m_may_fail) {
+ failure_flags |= TestCaseFailureReason::CouldHaveFailedAndDid;
+ } else if(currentTest->m_expected_failures > 0) {
+ if(numAssertsFailedCurrentTest == currentTest->m_expected_failures) {
+ failure_flags |= TestCaseFailureReason::FailedExactlyNumTimes;
+ } else {
+ failure_flags |= TestCaseFailureReason::DidntFailExactlyNumTimes;
+ }
+ }
+
+ bool ok_to_fail = (TestCaseFailureReason::ShouldHaveFailedAndDid & failure_flags) ||
+ (TestCaseFailureReason::CouldHaveFailedAndDid & failure_flags) ||
+ (TestCaseFailureReason::FailedExactlyNumTimes & failure_flags);
+
+ // if any subcase has failed - the whole test case has failed
+ testCaseSuccess = !(failure_flags && !ok_to_fail);
+ if(!testCaseSuccess)
+ numTestCasesFailed++;
+ }
+ };
+
+ ContextState* g_cs = nullptr;
+
+ // used to avoid locks for the debug output
+ // TODO: figure out if this is indeed necessary/correct - seems like either there still
+ // could be a race or that there wouldn't be a race even if using the context directly
+ DOCTEST_THREAD_LOCAL bool g_no_colors;
+
+#endif // DOCTEST_CONFIG_DISABLE
+} // namespace detail
+
+char* String::allocate(size_type sz) {
+ if (sz <= last) {
+ buf[sz] = '\0';
+ setLast(last - sz);
+ return buf;
+ } else {
+ setOnHeap();
+ data.size = sz;
+ data.capacity = data.size + 1;
+ data.ptr = new char[data.capacity];
+ data.ptr[sz] = '\0';
+ return data.ptr;
+ }
+}
+
+void String::setOnHeap() noexcept { *reinterpret_cast<unsigned char*>(&buf[last]) = 128; }
+void String::setLast(size_type in) noexcept { buf[last] = char(in); }
+void String::setSize(size_type sz) noexcept {
+ if (isOnStack()) { buf[sz] = '\0'; setLast(last - sz); }
+ else { data.ptr[sz] = '\0'; data.size = sz; }
+}
+
+void String::copy(const String& other) {
+ if(other.isOnStack()) {
+ memcpy(buf, other.buf, len);
+ } else {
+ memcpy(allocate(other.data.size), other.data.ptr, other.data.size);
+ }
+}
+
+String::String() noexcept {
+ buf[0] = '\0';
+ setLast();
+}
+
+String::~String() {
+ if(!isOnStack())
+ delete[] data.ptr;
+} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+
+String::String(const char* in)
+ : String(in, strlen(in)) {}
+
+String::String(const char* in, size_type in_size) {
+ memcpy(allocate(in_size), in, in_size);
+}
+
+String::String(std::istream& in, size_type in_size) {
+ in.read(allocate(in_size), in_size);
+}
+
+String::String(const String& other) { copy(other); }
+
+String& String::operator=(const String& other) {
+ if(this != &other) {
+ if(!isOnStack())
+ delete[] data.ptr;
+
+ copy(other);
+ }
+
+ return *this;
+}
+
+String& String::operator+=(const String& other) {
+ const size_type my_old_size = size();
+ const size_type other_size = other.size();
+ const size_type total_size = my_old_size + other_size;
+ if(isOnStack()) {
+ if(total_size < len) {
+ // append to the current stack space
+ memcpy(buf + my_old_size, other.c_str(), other_size + 1);
+ // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
+ setLast(last - total_size);
+ } else {
+ // alloc new chunk
+ char* temp = new char[total_size + 1];
+ // copy current data to new location before writing in the union
+ memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed
+ // update data in union
+ setOnHeap();
+ data.size = total_size;
+ data.capacity = data.size + 1;
+ data.ptr = temp;
+ // transfer the rest of the data
+ memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
+ }
+ } else {
+ if(data.capacity > total_size) {
+ // append to the current heap block
+ data.size = total_size;
+ memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
+ } else {
+ // resize
+ data.capacity *= 2;
+ if(data.capacity <= total_size)
+ data.capacity = total_size + 1;
+ // alloc new chunk
+ char* temp = new char[data.capacity];
+ // copy current data to new location before releasing it
+ memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed
+ // release old chunk
+ delete[] data.ptr;
+ // update the rest of the union members
+ data.size = total_size;
+ data.ptr = temp;
+ // transfer the rest of the data
+ memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
+ }
+ }
+
+ return *this;
+}
+
+String::String(String&& other) noexcept {
+ memcpy(buf, other.buf, len);
+ other.buf[0] = '\0';
+ other.setLast();
+}
+
+String& String::operator=(String&& other) noexcept {
+ if(this != &other) {
+ if(!isOnStack())
+ delete[] data.ptr;
+ memcpy(buf, other.buf, len);
+ other.buf[0] = '\0';
+ other.setLast();
+ }
+ return *this;
+}
+
+char String::operator[](size_type i) const {
+ return const_cast<String*>(this)->operator[](i);
+}
+
+char& String::operator[](size_type i) {
+ if(isOnStack())
+ return reinterpret_cast<char*>(buf)[i];
+ return data.ptr[i];
+}
+
+DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmaybe-uninitialized")
+String::size_type String::size() const {
+ if(isOnStack())
+ return last - (size_type(buf[last]) & 31); // using "last" would work only if "len" is 32
+ return data.size;
+}
+DOCTEST_GCC_SUPPRESS_WARNING_POP
+
+String::size_type String::capacity() const {
+ if(isOnStack())
+ return len;
+ return data.capacity;
+}
+
+String String::substr(size_type pos, size_type cnt) && {
+ cnt = std::min(cnt, size() - 1 - pos);
+ char* cptr = c_str();
+ memmove(cptr, cptr + pos, cnt);
+ setSize(cnt);
+ return std::move(*this);
+}
+
+String String::substr(size_type pos, size_type cnt) const & {
+ cnt = std::min(cnt, size() - 1 - pos);
+ return String{ c_str() + pos, cnt };
+}
+
+String::size_type String::find(char ch, size_type pos) const {
+ const char* begin = c_str();
+ const char* end = begin + size();
+ const char* it = begin + pos;
+ for (; it < end && *it != ch; it++);
+ if (it < end) { return static_cast<size_type>(it - begin); }
+ else { return npos; }
+}
+
+String::size_type String::rfind(char ch, size_type pos) const {
+ const char* begin = c_str();
+ const char* it = begin + std::min(pos, size() - 1);
+ for (; it >= begin && *it != ch; it--);
+ if (it >= begin) { return static_cast<size_type>(it - begin); }
+ else { return npos; }
+}
+
+int String::compare(const char* other, bool no_case) const {
+ if(no_case)
+ return doctest::stricmp(c_str(), other);
+ return std::strcmp(c_str(), other);
+}
+
+int String::compare(const String& other, bool no_case) const {
+ return compare(other.c_str(), no_case);
+}
+
+String operator+(const String& lhs, const String& rhs) { return String(lhs) += rhs; }
+
+bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; }
+bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; }
+bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
+bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
+bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; }
+bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; }
+
+std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); }
+
+Contains::Contains(const String& str) : string(str) { }
+
+bool Contains::checkWith(const String& other) const {
+ return strstr(other.c_str(), string.c_str()) != nullptr;
+}
+
+String toString(const Contains& in) {
+ return "Contains( " + in.string + " )";
+}
+
+bool operator==(const String& lhs, const Contains& rhs) { return rhs.checkWith(lhs); }
+bool operator==(const Contains& lhs, const String& rhs) { return lhs.checkWith(rhs); }
+bool operator!=(const String& lhs, const Contains& rhs) { return !rhs.checkWith(lhs); }
+bool operator!=(const Contains& lhs, const String& rhs) { return !lhs.checkWith(rhs); }
+
+namespace {
+ void color_to_stream(std::ostream&, Color::Enum) DOCTEST_BRANCH_ON_DISABLED({}, ;)
+} // namespace
+
+namespace Color {
+ std::ostream& operator<<(std::ostream& s, Color::Enum code) {
+ color_to_stream(s, code);
+ return s;
+ }
+} // namespace Color
+
+// clang-format off
+const char* assertString(assertType::Enum at) {
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4061) // enum 'x' in switch of enum 'y' is not explicitly handled
+ #define DOCTEST_GENERATE_ASSERT_TYPE_CASE(assert_type) case assertType::DT_ ## assert_type: return #assert_type
+ #define DOCTEST_GENERATE_ASSERT_TYPE_CASES(assert_type) \
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN_ ## assert_type); \
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK_ ## assert_type); \
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE_ ## assert_type)
+ switch(at) {
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(FALSE);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_AS);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH_AS);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(NOTHROW);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(EQ);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(NE);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(GT);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(LT);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(GE);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(LE);
+
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY);
+ DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY_FALSE);
+
+ default: DOCTEST_INTERNAL_ERROR("Tried stringifying invalid assert type!");
+ }
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+}
+// clang-format on
+
+const char* failureString(assertType::Enum at) {
+ if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
+ return "WARNING";
+ if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
+ return "ERROR";
+ if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
+ return "FATAL ERROR";
+ return "";
+}
+
+DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
+DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
+// depending on the current options this will remove the path of filenames
+const char* skipPathFromFilename(const char* file) {
+#ifndef DOCTEST_CONFIG_DISABLE
+ if(getContextOptions()->no_path_in_filenames) {
+ auto back = std::strrchr(file, '\\');
+ auto forward = std::strrchr(file, '/');
+ if(back || forward) {
+ if(back > forward)
+ forward = back;
+ return forward + 1;
+ }
+ }
+#endif // DOCTEST_CONFIG_DISABLE
+ return file;
+}
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+DOCTEST_GCC_SUPPRESS_WARNING_POP
+
+bool SubcaseSignature::operator==(const SubcaseSignature& other) const {
+ return m_line == other.m_line
+ && std::strcmp(m_file, other.m_file) == 0
+ && m_name == other.m_name;
+}
+
+bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
+ if(m_line != other.m_line)
+ return m_line < other.m_line;
+ if(std::strcmp(m_file, other.m_file) != 0)
+ return std::strcmp(m_file, other.m_file) < 0;
+ return m_name.compare(other.m_name) < 0;
+}
+
+DOCTEST_DEFINE_INTERFACE(IContextScope)
+
+namespace detail {
+ void filldata<const void*>::fill(std::ostream* stream, const void* in) {
+ if (in) { *stream << in; }
+ else { *stream << "nullptr"; }
+ }
+
+ template <typename T>
+ String toStreamLit(T t) {
+ std::ostream* os = tlssPush();
+ os->operator<<(t);
+ return tlssPop();
+ }
+}
+
+#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; }
+#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
+
+#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
+// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
+String toString(const std::string& in) { return in.c_str(); }
+#endif // VS 2019
+
+String toString(String in) { return in; }
+
+String toString(std::nullptr_t) { return "nullptr"; }
+
+String toString(bool in) { return in ? "true" : "false"; }
+
+String toString(float in) { return toStreamLit(in); }
+String toString(double in) { return toStreamLit(in); }
+String toString(double long in) { return toStreamLit(in); }
+
+String toString(char in) { return toStreamLit(static_cast<signed>(in)); }
+String toString(char signed in) { return toStreamLit(static_cast<signed>(in)); }
+String toString(char unsigned in) { return toStreamLit(static_cast<unsigned>(in)); }
+String toString(short in) { return toStreamLit(in); }
+String toString(short unsigned in) { return toStreamLit(in); }
+String toString(signed in) { return toStreamLit(in); }
+String toString(unsigned in) { return toStreamLit(in); }
+String toString(long in) { return toStreamLit(in); }
+String toString(long unsigned in) { return toStreamLit(in); }
+String toString(long long in) { return toStreamLit(in); }
+String toString(long long unsigned in) { return toStreamLit(in); }
+
+Approx::Approx(double value)
+ : m_epsilon(static_cast<double>(std::numeric_limits<float>::epsilon()) * 100)
+ , m_scale(1.0)
+ , m_value(value) {}
+
+Approx Approx::operator()(double value) const {
+ Approx approx(value);
+ approx.epsilon(m_epsilon);
+ approx.scale(m_scale);
+ return approx;
+}
+
+Approx& Approx::epsilon(double newEpsilon) {
+ m_epsilon = newEpsilon;
+ return *this;
+}
+Approx& Approx::scale(double newScale) {
+ m_scale = newScale;
+ return *this;
+}
+
+bool operator==(double lhs, const Approx& rhs) {
+ // Thanks to Richard Harris for his help refining this formula
+ return std::fabs(lhs - rhs.m_value) <
+ rhs.m_epsilon * (rhs.m_scale + std::max<double>(std::fabs(lhs), std::fabs(rhs.m_value)));
+}
+bool operator==(const Approx& lhs, double rhs) { return operator==(rhs, lhs); }
+bool operator!=(double lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
+bool operator!=(const Approx& lhs, double rhs) { return !operator==(rhs, lhs); }
+bool operator<=(double lhs, const Approx& rhs) { return lhs < rhs.m_value || lhs == rhs; }
+bool operator<=(const Approx& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; }
+bool operator>=(double lhs, const Approx& rhs) { return lhs > rhs.m_value || lhs == rhs; }
+bool operator>=(const Approx& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; }
+bool operator<(double lhs, const Approx& rhs) { return lhs < rhs.m_value && lhs != rhs; }
+bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; }
+bool operator>(double lhs, const Approx& rhs) { return lhs > rhs.m_value && lhs != rhs; }
+bool operator>(const Approx& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; }
+
+String toString(const Approx& in) {
+ return "Approx( " + doctest::toString(in.m_value) + " )";
+}
+const ContextOptions* getContextOptions() { return DOCTEST_BRANCH_ON_DISABLED(nullptr, g_cs); }
+
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4738)
+template <typename F>
+IsNaN<F>::operator bool() const {
+ return std::isnan(value) ^ flipped;
+}
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+template struct DOCTEST_INTERFACE_DEF IsNaN<float>;
+template struct DOCTEST_INTERFACE_DEF IsNaN<double>;
+template struct DOCTEST_INTERFACE_DEF IsNaN<long double>;
+template <typename F>
+String toString(IsNaN<F> in) { return String(in.flipped ? "! " : "") + "IsNaN( " + doctest::toString(in.value) + " )"; }
+String toString(IsNaN<float> in) { return toString<float>(in); }
+String toString(IsNaN<double> in) { return toString<double>(in); }
+String toString(IsNaN<double long> in) { return toString<double long>(in); }
+
+} // namespace doctest
+
+#ifdef DOCTEST_CONFIG_DISABLE
+namespace doctest {
+Context::Context(int, const char* const*) {}
+Context::~Context() = default;
+void Context::applyCommandLine(int, const char* const*) {}
+void Context::addFilter(const char*, const char*) {}
+void Context::clearFilters() {}
+void Context::setOption(const char*, bool) {}
+void Context::setOption(const char*, int) {}
+void Context::setOption(const char*, const char*) {}
+bool Context::shouldExit() { return false; }
+void Context::setAsDefaultForAssertsOutOfTestCases() {}
+void Context::setAssertHandler(detail::assert_handler) {}
+void Context::setCout(std::ostream*) {}
+int Context::run() { return 0; }
+
+int IReporter::get_num_active_contexts() { return 0; }
+const IContextScope* const* IReporter::get_active_contexts() { return nullptr; }
+int IReporter::get_num_stringified_contexts() { return 0; }
+const String* IReporter::get_stringified_contexts() { return nullptr; }
+
+int registerReporter(const char*, int, IReporter*) { return 0; }
+
+} // namespace doctest
+#else // DOCTEST_CONFIG_DISABLE
+
+#if !defined(DOCTEST_CONFIG_COLORS_NONE)
+#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI)
+#ifdef DOCTEST_PLATFORM_WINDOWS
+#define DOCTEST_CONFIG_COLORS_WINDOWS
+#else // linux
+#define DOCTEST_CONFIG_COLORS_ANSI
+#endif // platform
+#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI
+#endif // DOCTEST_CONFIG_COLORS_NONE
+
+namespace doctest_detail_test_suite_ns {
+// holds the current test suite
+doctest::detail::TestSuite& getCurrentTestSuite() {
+ static doctest::detail::TestSuite data{};
+ return data;
+}
+} // namespace doctest_detail_test_suite_ns
+
+namespace doctest {
+namespace {
+ // the int (priority) is part of the key for automatic sorting - sadly one can register a
+ // reporter with a duplicate name and a different priority but hopefully that won't happen often :|
+ using reporterMap = std::map<std::pair<int, String>, reporterCreatorFunc>;
+
+ reporterMap& getReporters() {
+ static reporterMap data;
+ return data;
+ }
+ reporterMap& getListeners() {
+ static reporterMap data;
+ return data;
+ }
+} // namespace
+namespace detail {
+#define DOCTEST_ITERATE_THROUGH_REPORTERS(function, ...) \
+ for(auto& curr_rep : g_cs->reporters_currently_used) \
+ curr_rep->function(__VA_ARGS__)
+
+ bool checkIfShouldThrow(assertType::Enum at) {
+ if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
+ return true;
+
+ if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
+ && getContextOptions()->abort_after > 0 &&
+ (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
+ getContextOptions()->abort_after)
+ return true;
+
+ return false;
+ }
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ DOCTEST_NORETURN void throwException() {
+ g_cs->shouldLogCurrentException = false;
+ throw TestFailureException(); // NOLINT(hicpp-exception-baseclass)
+ }
+#else // DOCTEST_CONFIG_NO_EXCEPTIONS
+ void throwException() {}
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+} // namespace detail
+
+namespace {
+ using namespace detail;
+ // matching of a string against a wildcard mask (case sensitivity configurable) taken from
+ // https://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing
+ int wildcmp(const char* str, const char* wild, bool caseSensitive) {
+ const char* cp = str;
+ const char* mp = wild;
+
+ while((*str) && (*wild != '*')) {
+ if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) &&
+ (*wild != '?')) {
+ return 0;
+ }
+ wild++;
+ str++;
+ }
+
+ while(*str) {
+ if(*wild == '*') {
+ if(!*++wild) {
+ return 1;
+ }
+ mp = wild;
+ cp = str + 1;
+ } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) ||
+ (*wild == '?')) {
+ wild++;
+ str++;
+ } else {
+ wild = mp; //!OCLINT parameter reassignment
+ str = cp++; //!OCLINT parameter reassignment
+ }
+ }
+
+ while(*wild == '*') {
+ wild++;
+ }
+ return !*wild;
+ }
+
+ // checks if the name matches any of the filters (and can be configured what to do when empty)
+ bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
+ bool caseSensitive) {
+ if (filters.empty() && matchEmpty)
+ return true;
+ for (auto& curr : filters)
+ if (wildcmp(name, curr.c_str(), caseSensitive))
+ return true;
+ return false;
+ }
+
+ DOCTEST_NO_SANITIZE_INTEGER
+ unsigned long long hash(unsigned long long a, unsigned long long b) {
+ return (a << 5) + b;
+ }
+
+ // C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html
+ DOCTEST_NO_SANITIZE_INTEGER
+ unsigned long long hash(const char* str) {
+ unsigned long long hash = 5381;
+ char c;
+ while ((c = *str++))
+ hash = ((hash << 5) + hash) + c; // hash * 33 + c
+ return hash;
+ }
+
+ unsigned long long hash(const SubcaseSignature& sig) {
+ return hash(hash(hash(sig.m_file), hash(sig.m_name.c_str())), sig.m_line);
+ }
+
+ unsigned long long hash(const std::vector<SubcaseSignature>& sigs, size_t count) {
+ unsigned long long running = 0;
+ auto end = sigs.begin() + count;
+ for (auto it = sigs.begin(); it != end; it++) {
+ running = hash(running, hash(*it));
+ }
+ return running;
+ }
+
+ unsigned long long hash(const std::vector<SubcaseSignature>& sigs) {
+ unsigned long long running = 0;
+ for (const SubcaseSignature& sig : sigs) {
+ running = hash(running, hash(sig));
+ }
+ return running;
+ }
+} // namespace
+namespace detail {
+ bool Subcase::checkFilters() {
+ if (g_cs->subcaseStack.size() < size_t(g_cs->subcase_filter_levels)) {
+ if (!matchesAny(m_signature.m_name.c_str(), g_cs->filters[6], true, g_cs->case_sensitive))
+ return true;
+ if (matchesAny(m_signature.m_name.c_str(), g_cs->filters[7], false, g_cs->case_sensitive))
+ return true;
+ }
+ return false;
+ }
+
+ Subcase::Subcase(const String& name, const char* file, int line)
+ : m_signature({name, file, line}) {
+ if (!g_cs->reachedLeaf) {
+ if (g_cs->nextSubcaseStack.size() <= g_cs->subcaseStack.size()
+ || g_cs->nextSubcaseStack[g_cs->subcaseStack.size()] == m_signature) {
+ // Going down.
+ if (checkFilters()) { return; }
+
+ g_cs->subcaseStack.push_back(m_signature);
+ g_cs->currentSubcaseDepth++;
+ m_entered = true;
+ DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
+ }
+ } else {
+ if (g_cs->subcaseStack[g_cs->currentSubcaseDepth] == m_signature) {
+ // This subcase is reentered via control flow.
+ g_cs->currentSubcaseDepth++;
+ m_entered = true;
+ DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
+ } else if (g_cs->nextSubcaseStack.size() <= g_cs->currentSubcaseDepth
+ && g_cs->fullyTraversedSubcases.find(hash(hash(g_cs->subcaseStack, g_cs->currentSubcaseDepth), hash(m_signature)))
+ == g_cs->fullyTraversedSubcases.end()) {
+ if (checkFilters()) { return; }
+ // This subcase is part of the one to be executed next.
+ g_cs->nextSubcaseStack.clear();
+ g_cs->nextSubcaseStack.insert(g_cs->nextSubcaseStack.end(),
+ g_cs->subcaseStack.begin(), g_cs->subcaseStack.begin() + g_cs->currentSubcaseDepth);
+ g_cs->nextSubcaseStack.push_back(m_signature);
+ }
+ }
+ }
+
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
+ DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
+
+ Subcase::~Subcase() {
+ if (m_entered) {
+ g_cs->currentSubcaseDepth--;
+
+ if (!g_cs->reachedLeaf) {
+ // Leaf.
+ g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
+ g_cs->nextSubcaseStack.clear();
+ g_cs->reachedLeaf = true;
+ } else if (g_cs->nextSubcaseStack.empty()) {
+ // All children are finished.
+ g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
+ }
+
+#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
+ if(std::uncaught_exceptions() > 0
+#else
+ if(std::uncaught_exception()
+#endif
+ && g_cs->shouldLogCurrentException) {
+ DOCTEST_ITERATE_THROUGH_REPORTERS(
+ test_case_exception, {"exception thrown in subcase - will translate later "
+ "when the whole test case has been exited (cannot "
+ "translate while there is an active exception)",
+ false});
+ g_cs->shouldLogCurrentException = false;
+ }
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
+ }
+ }
+
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+ DOCTEST_GCC_SUPPRESS_WARNING_POP
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+ Subcase::operator bool() const { return m_entered; }
+
+ Result::Result(bool passed, const String& decomposition)
+ : m_passed(passed)
+ , m_decomp(decomposition) {}
+
+ ExpressionDecomposer::ExpressionDecomposer(assertType::Enum at)
+ : m_at(at) {}
+
+ TestSuite& TestSuite::operator*(const char* in) {
+ m_test_suite = in;
+ return *this;
+ }
+
+ TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
+ const String& type, int template_id) {
+ m_file = file;
+ m_line = line;
+ m_name = nullptr; // will be later overridden in operator*
+ m_test_suite = test_suite.m_test_suite;
+ m_description = test_suite.m_description;
+ m_skip = test_suite.m_skip;
+ m_no_breaks = test_suite.m_no_breaks;
+ m_no_output = test_suite.m_no_output;
+ m_may_fail = test_suite.m_may_fail;
+ m_should_fail = test_suite.m_should_fail;
+ m_expected_failures = test_suite.m_expected_failures;
+ m_timeout = test_suite.m_timeout;
+
+ m_test = test;
+ m_type = type;
+ m_template_id = template_id;
+ }
+
+ TestCase::TestCase(const TestCase& other)
+ : TestCaseData() {
+ *this = other;
+ }
+
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
+ TestCase& TestCase::operator=(const TestCase& other) {
+ TestCaseData::operator=(other);
+ m_test = other.m_test;
+ m_type = other.m_type;
+ m_template_id = other.m_template_id;
+ m_full_name = other.m_full_name;
+
+ if(m_template_id != -1)
+ m_name = m_full_name.c_str();
+ return *this;
+ }
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+
+ TestCase& TestCase::operator*(const char* in) {
+ m_name = in;
+ // make a new name with an appended type for templated test case
+ if(m_template_id != -1) {
+ m_full_name = String(m_name) + "<" + m_type + ">";
+ // redirect the name to point to the newly constructed full name
+ m_name = m_full_name.c_str();
+ }
+ return *this;
+ }
+
+ bool TestCase::operator<(const TestCase& other) const {
+ // this will be used only to differentiate between test cases - not relevant for sorting
+ if(m_line != other.m_line)
+ return m_line < other.m_line;
+ const int name_cmp = strcmp(m_name, other.m_name);
+ if(name_cmp != 0)
+ return name_cmp < 0;
+ const int file_cmp = m_file.compare(other.m_file);
+ if(file_cmp != 0)
+ return file_cmp < 0;
+ return m_template_id < other.m_template_id;
+ }
+
+ // all the registered tests
+ std::set<TestCase>& getRegisteredTests() {
+ static std::set<TestCase> data;
+ return data;
+ }
+} // namespace detail
+namespace {
+ using namespace detail;
+ // for sorting tests by file/line
+ bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
+ // this is needed because MSVC gives different case for drive letters
+ // for __FILE__ when evaluated in a header and a source file
+ const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC));
+ if(res != 0)
+ return res < 0;
+ if(lhs->m_line != rhs->m_line)
+ return lhs->m_line < rhs->m_line;
+ return lhs->m_template_id < rhs->m_template_id;
+ }
+
+ // for sorting tests by suite/file/line
+ bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
+ const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
+ if(res != 0)
+ return res < 0;
+ return fileOrderComparator(lhs, rhs);
+ }
+
+ // for sorting tests by name/suite/file/line
+ bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
+ const int res = std::strcmp(lhs->m_name, rhs->m_name);
+ if(res != 0)
+ return res < 0;
+ return suiteOrderComparator(lhs, rhs);
+ }
+
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
+ void color_to_stream(std::ostream& s, Color::Enum code) {
+ static_cast<void>(s); // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS
+ static_cast<void>(code); // for DOCTEST_CONFIG_COLORS_NONE
+#ifdef DOCTEST_CONFIG_COLORS_ANSI
+ if(g_no_colors ||
+ (isatty(STDOUT_FILENO) == false && getContextOptions()->force_colors == false))
+ return;
+
+ auto col = "";
+ // clang-format off
+ switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement
+ case Color::Red: col = "[0;31m"; break;
+ case Color::Green: col = "[0;32m"; break;
+ case Color::Blue: col = "[0;34m"; break;
+ case Color::Cyan: col = "[0;36m"; break;
+ case Color::Yellow: col = "[0;33m"; break;
+ case Color::Grey: col = "[1;30m"; break;
+ case Color::LightGrey: col = "[0;37m"; break;
+ case Color::BrightRed: col = "[1;31m"; break;
+ case Color::BrightGreen: col = "[1;32m"; break;
+ case Color::BrightWhite: col = "[1;37m"; break;
+ case Color::Bright: // invalid
+ case Color::None:
+ case Color::White:
+ default: col = "[0m";
+ }
+ // clang-format on
+ s << "\033" << col;
+#endif // DOCTEST_CONFIG_COLORS_ANSI
+
+#ifdef DOCTEST_CONFIG_COLORS_WINDOWS
+ if(g_no_colors ||
+ (_isatty(_fileno(stdout)) == false && getContextOptions()->force_colors == false))
+ return;
+
+ static struct ConsoleHelper {
+ HANDLE stdoutHandle;
+ WORD origFgAttrs;
+ WORD origBgAttrs;
+
+ ConsoleHelper() {
+ stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+ CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+ GetConsoleScreenBufferInfo(stdoutHandle, &csbiInfo);
+ origFgAttrs = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED |
+ BACKGROUND_BLUE | BACKGROUND_INTENSITY);
+ origBgAttrs = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED |
+ FOREGROUND_BLUE | FOREGROUND_INTENSITY);
+ }
+ } ch;
+
+#define DOCTEST_SET_ATTR(x) SetConsoleTextAttribute(ch.stdoutHandle, x | ch.origBgAttrs)
+
+ // clang-format off
+ switch (code) {
+ case Color::White: DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
+ case Color::Red: DOCTEST_SET_ATTR(FOREGROUND_RED); break;
+ case Color::Green: DOCTEST_SET_ATTR(FOREGROUND_GREEN); break;
+ case Color::Blue: DOCTEST_SET_ATTR(FOREGROUND_BLUE); break;
+ case Color::Cyan: DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN); break;
+ case Color::Yellow: DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN); break;
+ case Color::Grey: DOCTEST_SET_ATTR(0); break;
+ case Color::LightGrey: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY); break;
+ case Color::BrightRed: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED); break;
+ case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN); break;
+ case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
+ case Color::None:
+ case Color::Bright: // invalid
+ default: DOCTEST_SET_ATTR(ch.origFgAttrs);
+ }
+ // clang-format on
+#endif // DOCTEST_CONFIG_COLORS_WINDOWS
+ }
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+
+ std::vector<const IExceptionTranslator*>& getExceptionTranslators() {
+ static std::vector<const IExceptionTranslator*> data;
+ return data;
+ }
+
+ String translateActiveException() {
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ String res;
+ auto& translators = getExceptionTranslators();
+ for(auto& curr : translators)
+ if(curr->translate(res))
+ return res;
+ // clang-format off
+ DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
+ try {
+ throw;
+ } catch(std::exception& ex) {
+ return ex.what();
+ } catch(std::string& msg) {
+ return msg.c_str();
+ } catch(const char* msg) {
+ return msg;
+ } catch(...) {
+ return "unknown exception";
+ }
+ DOCTEST_GCC_SUPPRESS_WARNING_POP
+// clang-format on
+#else // DOCTEST_CONFIG_NO_EXCEPTIONS
+ return "";
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+ }
+} // namespace
+
+namespace detail {
+ // used by the macros for registering tests
+ int regTest(const TestCase& tc) {
+ getRegisteredTests().insert(tc);
+ return 0;
+ }
+
+ // sets the current test suite
+ int setTestSuite(const TestSuite& ts) {
+ doctest_detail_test_suite_ns::getCurrentTestSuite() = ts;
+ return 0;
+ }
+
+#ifdef DOCTEST_IS_DEBUGGER_ACTIVE
+ bool isDebuggerActive() { return DOCTEST_IS_DEBUGGER_ACTIVE(); }
+#else // DOCTEST_IS_DEBUGGER_ACTIVE
+#ifdef DOCTEST_PLATFORM_LINUX
+ class ErrnoGuard {
+ public:
+ ErrnoGuard() : m_oldErrno(errno) {}
+ ~ErrnoGuard() { errno = m_oldErrno; }
+ private:
+ int m_oldErrno;
+ };
+ // See the comments in Catch2 for the reasoning behind this implementation:
+ // https://github.com/catchorg/Catch2/blob/v2.13.1/include/internal/catch_debugger.cpp#L79-L102
+ bool isDebuggerActive() {
+ 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) {
+ return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+ }
+ }
+ return false;
+ }
+#elif defined(DOCTEST_PLATFORM_MAC)
+ // 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];
+ kinfo_proc info;
+ 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, DOCTEST_COUNTOF(mib), &info, &size, 0, 0) != 0) {
+ std::cerr << "\nCall to sysctl failed - unable to determine if debugger is active **\n";
+ return false;
+ }
+ // We're being debugged if the P_TRACED flag is set.
+ return ((info.kp_proc.p_flag & P_TRACED) != 0);
+ }
+#elif DOCTEST_MSVC || defined(__MINGW32__) || defined(__MINGW64__)
+ bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; }
+#else
+ bool isDebuggerActive() { return false; }
+#endif // Platform
+#endif // DOCTEST_IS_DEBUGGER_ACTIVE
+
+ void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
+ if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
+ getExceptionTranslators().end())
+ getExceptionTranslators().push_back(et);
+ }
+
+ DOCTEST_THREAD_LOCAL std::vector<IContextScope*> g_infoContexts; // for logging with INFO()
+
+ ContextScopeBase::ContextScopeBase() {
+ g_infoContexts.push_back(this);
+ }
+
+ ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) noexcept {
+ if (other.need_to_destroy) {
+ other.destroy();
+ }
+ other.need_to_destroy = false;
+ g_infoContexts.push_back(this);
+ }
+
+ DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
+ DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
+ DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
+
+ // destroy cannot be inlined into the destructor because that would mean calling stringify after
+ // ContextScope has been destroyed (base class destructors run after derived class destructors).
+ // Instead, ContextScope calls this method directly from its destructor.
+ void ContextScopeBase::destroy() {
+#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
+ if(std::uncaught_exceptions() > 0) {
+#else
+ if(std::uncaught_exception()) {
+#endif
+ std::ostringstream s;
+ this->stringify(&s);
+ g_cs->stringifiedContexts.push_back(s.str().c_str());
+ }
+ g_infoContexts.pop_back();
+ }
+
+ DOCTEST_CLANG_SUPPRESS_WARNING_POP
+ DOCTEST_GCC_SUPPRESS_WARNING_POP
+ DOCTEST_MSVC_SUPPRESS_WARNING_POP
+} // namespace detail
+namespace {
+ using namespace detail;
+
+#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
+ struct FatalConditionHandler
+ {
+ static void reset() {}
+ static void allocateAltStackMem() {}
+ static void freeAltStackMem() {}
+ };
+#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
+
+ void reportFatal(const std::string&);
+
+#ifdef DOCTEST_PLATFORM_WINDOWS
+
+ 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.
+ SignalDefs signalDefs[] = {
+ {static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),
+ "SIGILL - Illegal instruction signal"},
+ {static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow"},
+ {static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION),
+ "SIGSEGV - Segmentation violation signal"},
+ {static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error"},
+ };
+
+ struct FatalConditionHandler
+ {
+ static LONG CALLBACK handleException(PEXCEPTION_POINTERS ExceptionInfo) {
+ // Multiple threads may enter this filter/handler at once. We want the error message to be printed on the
+ // console just once no matter how many threads have crashed.
+ DOCTEST_DECLARE_STATIC_MUTEX(mutex)
+ static bool execute = true;
+ {
+ DOCTEST_LOCK_MUTEX(mutex)
+ if(execute) {
+ bool reported = false;
+ for(size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
+ if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+ reportFatal(signalDefs[i].name);
+ reported = true;
+ break;
+ }
+ }
+ if(reported == false)
+ reportFatal("Unhandled SEH exception caught");
+ if(isDebuggerActive() && !g_cs->no_breaks)
+ DOCTEST_BREAK_INTO_DEBUGGER();
+ }
+ execute = false;
+ }
+ std::exit(EXIT_FAILURE);
+ }
+
+ static void allocateAltStackMem() {}
+ static void freeAltStackMem() {}
+
+ FatalConditionHandler() {
+ isSet = true;
+ // 32k seems enough for doctest to handle stack overflow,
+ // but the value was found experimentally, so there is no strong guarantee
+ guaranteeSize = 32 * 1024;
+ // Register an unhandled exception filter
+ previousTop = SetUnhandledExceptionFilter(handleException);
+ // Pass in guarantee size to be filled
+ SetThreadStackGuarantee(&guaranteeSize);
+
+ // On Windows uncaught exceptions from another thread, exceptions from
+ // destructors, or calls to std::terminate are not a SEH exception
+
+ // The terminal handler gets called when:
+ // - std::terminate is called FROM THE TEST RUNNER THREAD
+ // - an exception is thrown from a destructor FROM THE TEST RUNNER THREAD
+ original_terminate_handler = std::get_terminate();
+ std::set_terminate([]() DOCTEST_NOEXCEPT {
+ reportFatal("Terminate handler called");
+ if(isDebuggerActive() && !g_cs->no_breaks)
+ DOCTEST_BREAK_INTO_DEBUGGER();
+ std::exit(EXIT_FAILURE); // explicitly exit - otherwise the SIGABRT handler may be called as well
+ });
+
+ // SIGABRT is raised when:
+ // - std::terminate is called FROM A DIFFERENT THREAD
+ // - an exception is thrown from a destructor FROM A DIFFERENT THREAD
+ // - an uncaught exception is thrown FROM A DIFFERENT THREAD
+ prev_sigabrt_handler = std::signal(SIGABRT, [](int signal) DOCTEST_NOEXCEPT {
+ if(signal == SIGABRT) {
+ reportFatal("SIGABRT - Abort (abnormal termination) signal");
+ if(isDebuggerActive() && !g_cs->no_breaks)
+ DOCTEST_BREAK_INTO_DEBUGGER();
+ std::exit(EXIT_FAILURE);
+ }
+ });
+
+ // The following settings are taken from google test, and more
+ // specifically from UnitTest::Run() inside of gtest.cc
+
+ // the user does not want to see pop-up dialogs about crashes
+ prev_error_mode_1 = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+ SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+ // This forces the abort message to go to stderr in all circumstances.
+ prev_error_mode_2 = _set_error_mode(_OUT_TO_STDERR);
+ // In the debug version, Visual Studio pops up a separate dialog
+ // offering a choice to debug the aborted program - we want to disable that.
+ prev_abort_behavior = _set_abort_behavior(0x0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+ // In debug mode, the Windows CRT can crash with an assertion over invalid
+ // input (e.g. passing an invalid file descriptor). The default handling
+ // for these assertions is to pop up a dialog and wait for user input.
+ // Instead ask the CRT to dump such assertions to stderr non-interactively.
+ prev_report_mode = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+ prev_report_file = _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+ }
+
+ static void reset() {
+ if(isSet) {
+ // Unregister handler and restore the old guarantee
+ SetUnhandledExceptionFilter(previousTop);
+ SetThreadStackGuarantee(&guaranteeSize);
+ std::set_terminate(original_terminate_handler);
+ std::signal(SIGABRT, prev_sigabrt_handler);
+ SetErrorMode(prev_error_mode_1);
+ _set_error_mode(prev_error_mode_2);
+ _set_abort_behavior(prev_abort_behavior, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+ static_cast<void>(_CrtSetReportMode(_CRT_ASSERT, prev_report_mode));
+ static_cast<void>(_CrtSetReportFile(_CRT_ASSERT, prev_report_file));
+ isSet = false;
+ }
+ }
+
+ ~FatalConditionHandler() { reset(); }
+
+ private:
+ static UINT prev_error_mode_1;
+ static int prev_error_mode_2;
+ static unsigned int prev_abort_behavior;
+ static int prev_report_mode;
+ static _HFILE prev_report_file;
+ static void (DOCTEST_CDECL *prev_sigabrt_handler)(int);
+ static std::terminate_handler original_terminate_handler;
+ static bool isSet;
+ static ULONG guaranteeSize;
+ static LPTOP_LEVEL_EXCEPTION_FILTER previousTop;
+ };
+
+ UINT FatalConditionHandler::prev_error_mode_1;
+ int FatalConditionHandler::prev_error_mode_2;
+ unsigned int FatalConditionHandler::prev_abort_behavior;
+ int FatalConditionHandler::prev_report_mode;
+ _HFILE FatalConditionHandler::prev_report_file;
+ void (DOCTEST_CDECL *FatalConditionHandler::prev_sigabrt_handler)(int);
+ std::terminate_handler FatalConditionHandler::original_terminate_handler;
+ bool FatalConditionHandler::isSet = false;
+ ULONG FatalConditionHandler::guaranteeSize = 0;
+ LPTOP_LEVEL_EXCEPTION_FILTER FatalConditionHandler::previousTop = nullptr;
+
+#else // DOCTEST_PLATFORM_WINDOWS
+
+ struct SignalDefs
+ {
+ int id;
+ const char* name;
+ };
+ 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"}};
+
+ struct FatalConditionHandler
+ {
+ static bool isSet;
+ static struct sigaction oldSigActions[DOCTEST_COUNTOF(signalDefs)];
+ static stack_t oldSigStack;
+ static size_t altStackSize;
+ static char* altStackMem;
+
+ static void handleSignal(int sig) {
+ const char* name = "<unknown signal>";
+ for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
+ SignalDefs& def = signalDefs[i];
+ if(sig == def.id) {
+ name = def.name;
+ break;
+ }
+ }
+ reset();
+ reportFatal(name);
+ raise(sig);
+ }
+
+ static void allocateAltStackMem() {
+ altStackMem = new char[altStackSize];
+ }
+
+ static void freeAltStackMem() {
+ delete[] altStackMem;
+ }
+
+ FatalConditionHandler() {
+ isSet = true;
+ 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 < DOCTEST_COUNTOF(signalDefs); ++i) {
+ sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+ }
+ }
+
+ ~FatalConditionHandler() { reset(); }
+ static void reset() {
+ if(isSet) {
+ // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+ for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
+ sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+ }
+ // Return the old stack
+ sigaltstack(&oldSigStack, nullptr);
+ isSet = false;
+ }
+ }
+ };
+
+ bool FatalConditionHandler::isSet = false;
+ struct sigaction FatalConditionHandler::oldSigActions[DOCTEST_COUNTOF(signalDefs)] = {};
+ stack_t FatalConditionHandler::oldSigStack = {};
+ size_t FatalConditionHandler::altStackSize = 4 * SIGSTKSZ;
+ char* FatalConditionHandler::altStackMem = nullptr;
+
+#endif // DOCTEST_PLATFORM_WINDOWS
+#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
+
+} // namespace
+
+namespace {
+ using namespace detail;
+
+#ifdef DOCTEST_PLATFORM_WINDOWS
+#define DOCTEST_OUTPUT_DEBUG_STRING(text) ::OutputDebugStringA(text)
+#else
+ // TODO: integration with XCode and other IDEs
+#define DOCTEST_OUTPUT_DEBUG_STRING(text)
+#endif // Platform
+
+ void addAssert(assertType::Enum at) {
+ if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
+ g_cs->numAssertsCurrentTest_atomic++;
+ }
+
+ void addFailedAssert(assertType::Enum at) {
+ if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
+ g_cs->numAssertsFailedCurrentTest_atomic++;
+ }
+
+#if defined(DOCTEST_CONFIG_POSIX_SIGNALS) || defined(DOCTEST_CONFIG_WINDOWS_SEH)
+ void reportFatal(const std::string& message) {
+ g_cs->failure_flags |= TestCaseFailureReason::Crash;
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, {message.c_str(), true});
+
+ while (g_cs->subcaseStack.size()) {
+ g_cs->subcaseStack.pop_back();
+ DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
+ }
+
+ g_cs->finalizeTestCaseData();
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
+ }
+#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
+} // namespace
+
+AssertData::AssertData(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type, const StringContains& exception_string)
+ : m_test_case(g_cs->currentTest), m_at(at), m_file(file), m_line(line), m_expr(expr),
+ m_failed(true), m_threw(false), m_threw_as(false), m_exception_type(exception_type),
+ m_exception_string(exception_string) {
+#if DOCTEST_MSVC
+ if (m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
+ ++m_expr;
+#endif // MSVC
+}
+
+namespace detail {
+ ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type, const String& exception_string)
+ : AssertData(at, file, line, expr, exception_type, exception_string) { }
+
+ ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
+ const char* exception_type, const Contains& exception_string)
+ : AssertData(at, file, line, expr, exception_type, exception_string) { }
+
+ void ResultBuilder::setResult(const Result& res) {
+ m_decomp = res.m_decomp;
+ m_failed = !res.m_passed;
+ }
+
+ void ResultBuilder::translateException() {
+ m_threw = true;
+ m_exception = translateActiveException();
+ }
+
+ bool ResultBuilder::log() {
+ if(m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
+ m_failed = !m_threw;
+ } else if((m_at & assertType::is_throws_as) && (m_at & assertType::is_throws_with)) { //!OCLINT
+ m_failed = !m_threw_as || !m_exception_string.check(m_exception);
+ } else if(m_at & assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
+ m_failed = !m_threw_as;
+ } else if(m_at & assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
+ m_failed = !m_exception_string.check(m_exception);
+ } else if(m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
+ m_failed = m_threw;
+ }
+
+ if(m_exception.size())
+ m_exception = "\"" + m_exception + "\"";
+
+ if(is_running_in_test) {
+ addAssert(m_at);
+ DOCTEST_ITERATE_THROUGH_REPORTERS(log_assert, *this);
+
+ if(m_failed)
+ addFailedAssert(m_at);
+ } else if(m_failed) {
+ failed_out_of_a_testing_context(*this);
+ }
+
+ return m_failed && isDebuggerActive() && !getContextOptions()->no_breaks &&
+ (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
+ }
+
+ void ResultBuilder::react() const {
+ if(m_failed && checkIfShouldThrow(m_at))
+ throwException();
+ }
+
+ void failed_out_of_a_testing_context(const AssertData& ad) {
+ if(g_cs->ah)
+ g_cs->ah(ad);
+ else
+ std::abort();
+ }
+
+ bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
+ const Result& result) {
+ bool failed = !result.m_passed;
+
+ // ###################################################################################
+ // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
+ // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
+ // ###################################################################################
+ DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
+ DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
+ return !failed;
+ }
+
+ MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
+ m_stream = tlssPush();
+ m_file = file;
+ m_line = line;
+ m_severity = severity;
+ }
+
+ MessageBuilder::~MessageBuilder() {
+ if (!logged)
+ tlssPop();
+ }
+
+ DOCTEST_DEFINE_INTERFACE(IExceptionTranslator)
+
+ bool MessageBuilder::log() {
+ if (!logged) {
+ m_string = tlssPop();
+ logged = true;
+ }
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
+
+ const bool isWarn = m_severity & assertType::is_warn;
+
+ // warn is just a message in this context so we don't treat it as an assert
+ if(!isWarn) {
+ addAssert(m_severity);
+ addFailedAssert(m_severity);
+ }
+
+ return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
+ (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
+ }
+
+ void MessageBuilder::react() {
+ if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional
+ throwException();
+ }
+} // namespace detail
+namespace {
+ using namespace detail;
+
+ // clang-format off
+
+// =================================================================================================
+// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
+// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
+// =================================================================================================
+
+ class XmlEncode {
+ public:
+ enum ForWhat { ForTextNodes, ForAttributes };
+
+ XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+ void encodeTo( std::ostream& os ) const;
+
+ friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+ private:
+ std::string m_str;
+ ForWhat m_forWhat;
+ };
+
+ class XmlWriter {
+ public:
+
+ class ScopedElement {
+ public:
+ ScopedElement( XmlWriter* writer );
+
+ ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT;
+ ScopedElement& operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT;
+
+ ~ScopedElement();
+
+ ScopedElement& writeText( std::string const& text, bool indent = true );
+
+ template<typename T>
+ ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+ m_writer->writeAttribute( name, attribute );
+ return *this;
+ }
+
+ private:
+ mutable XmlWriter* m_writer = nullptr;
+ };
+
+#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ XmlWriter( std::ostream& os = std::cout );
+#else // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ XmlWriter( std::ostream& os );
+#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ ~XmlWriter();
+
+ XmlWriter( XmlWriter const& ) = delete;
+ XmlWriter& operator=( XmlWriter const& ) = delete;
+
+ XmlWriter& startElement( std::string const& name );
+
+ ScopedElement scopedElement( std::string const& name );
+
+ XmlWriter& endElement();
+
+ XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+ XmlWriter& writeAttribute( std::string const& name, const char* attribute );
+
+ XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+ template<typename T>
+ XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+ std::stringstream rss;
+ rss << attribute;
+ return writeAttribute( name, rss.str() );
+ }
+
+ XmlWriter& writeText( std::string const& text, bool indent = true );
+
+ //XmlWriter& writeComment( std::string const& text );
+
+ //void writeStylesheetRef( std::string const& url );
+
+ //XmlWriter& writeBlankLine();
+
+ void ensureTagClosed();
+
+ void writeDeclaration();
+
+ private:
+
+ void newlineIfNecessary();
+
+ bool m_tagIsOpen = false;
+ bool m_needsNewline = false;
+ std::vector<std::string> m_tags;
+ std::string m_indent;
+ std::ostream& m_os;
+ };
+
+// =================================================================================================
+// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
+// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
+// =================================================================================================
+
+using uchar = unsigned char;
+
+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;
+ }
+ DOCTEST_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;
+ }
+ DOCTEST_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);
+ }
+
+} // anonymous namespace
+
+ XmlEncode::XmlEncode( std::string const& 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: https://www.w3.org/TR/xml/#syntax)
+
+ for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+ uchar c = m_str[idx];
+ switch (c) {
+ case '<': os << "<"; break;
+ case '&': os << "&"; break;
+
+ case '>':
+ // See: https://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 https://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) {
+ uchar nc = 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) ||
+ ( value < 0x800 && encBytes > 2) || // removed "0x80 <= value &&" because redundant
+ (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 )
+ : m_writer( writer )
+ {}
+
+ XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT
+ : m_writer( other.m_writer ){
+ other.m_writer = nullptr;
+ }
+ XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT {
+ if ( m_writer ) {
+ m_writer->endElement();
+ }
+ m_writer = other.m_writer;
+ other.m_writer = nullptr;
+ return *this;
+ }
+
+
+ XmlWriter::ScopedElement::~ScopedElement() {
+ if( m_writer )
+ m_writer->endElement();
+ }
+
+ XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
+ m_writer->writeText( text, indent );
+ return *this;
+ }
+
+ XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+ {
+ // writeDeclaration(); // called explicitly by the reporters that use the writer class - see issue #627
+ }
+
+ XmlWriter::~XmlWriter() {
+ while( !m_tags.empty() )
+ endElement();
+ }
+
+ XmlWriter& XmlWriter::startElement( std::string const& name ) {
+ ensureTagClosed();
+ newlineIfNecessary();
+ m_os << m_indent << '<' << name;
+ m_tags.push_back( name );
+ m_indent += " ";
+ m_tagIsOpen = true;
+ return *this;
+ }
+
+ XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
+ ScopedElement scoped( this );
+ startElement( name );
+ return scoped;
+ }
+
+ XmlWriter& XmlWriter::endElement() {
+ newlineIfNecessary();
+ m_indent = m_indent.substr( 0, m_indent.size()-2 );
+ if( m_tagIsOpen ) {
+ m_os << "/>";
+ m_tagIsOpen = false;
+ }
+ else {
+ m_os << m_indent << "</" << m_tags.back() << ">";
+ }
+ m_os << std::endl;
+ m_tags.pop_back();
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+ if( !name.empty() && !attribute.empty() )
+ m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) {
+ if( !name.empty() && attribute && attribute[0] != '\0' )
+ m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+ m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
+ if( !text.empty() ){
+ bool tagWasOpen = m_tagIsOpen;
+ ensureTagClosed();
+ if( tagWasOpen && indent )
+ m_os << m_indent;
+ m_os << XmlEncode( text );
+ m_needsNewline = true;
+ }
+ return *this;
+ }
+
+ //XmlWriter& XmlWriter::writeComment( std::string const& text ) {
+ // ensureTagClosed();
+ // m_os << m_indent << "<!--" << text << "-->";
+ // m_needsNewline = true;
+ // return *this;
+ //}
+
+ //void XmlWriter::writeStylesheetRef( std::string const& url ) {
+ // m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+ //}
+
+ //XmlWriter& XmlWriter::writeBlankLine() {
+ // ensureTagClosed();
+ // m_os << '\n';
+ // return *this;
+ //}
+
+ void XmlWriter::ensureTagClosed() {
+ if( m_tagIsOpen ) {
+ m_os << ">" << std::endl;
+ m_tagIsOpen = false;
+ }
+ }
+
+ void XmlWriter::writeDeclaration() {
+ m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+ }
+
+ void XmlWriter::newlineIfNecessary() {
+ if( m_needsNewline ) {
+ m_os << std::endl;
+ m_needsNewline = false;
+ }
+ }
+
+// =================================================================================================
+// End of copy-pasted code from Catch
+// =================================================================================================
+
+ // clang-format on
+
+ struct XmlReporter : public IReporter
+ {
+ XmlWriter xml;
+ DOCTEST_DECLARE_MUTEX(mutex)
+
+ // caching pointers/references to objects of these types - safe to do
+ const ContextOptions& opt;
+ const TestCaseData* tc = nullptr;
+
+ XmlReporter(const ContextOptions& co)
+ : xml(*co.cout)
+ , opt(co) {}
+
+ void log_contexts() {
+ int num_contexts = get_num_active_contexts();
+ if(num_contexts) {
+ auto contexts = get_active_contexts();
+ std::stringstream ss;
+ for(int i = 0; i < num_contexts; ++i) {
+ contexts[i]->stringify(&ss);
+ xml.scopedElement("Info").writeText(ss.str());
+ ss.str("");
+ }
+ }
+ }
+
+ unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
+
+ void test_case_start_impl(const TestCaseData& in) {
+ bool open_ts_tag = false;
+ if(tc != nullptr) { // we have already opened a test suite
+ if(std::strcmp(tc->m_test_suite, in.m_test_suite) != 0) {
+ xml.endElement();
+ open_ts_tag = true;
+ }
+ }
+ else {
+ open_ts_tag = true; // first test case ==> first test suite
+ }
+
+ if(open_ts_tag) {
+ xml.startElement("TestSuite");
+ xml.writeAttribute("name", in.m_test_suite);
+ }
+
+ tc = ∈
+ xml.startElement("TestCase")
+ .writeAttribute("name", in.m_name)
+ .writeAttribute("filename", skipPathFromFilename(in.m_file.c_str()))
+ .writeAttribute("line", line(in.m_line))
+ .writeAttribute("description", in.m_description);
+
+ if(Approx(in.m_timeout) != 0)
+ xml.writeAttribute("timeout", in.m_timeout);
+ if(in.m_may_fail)
+ xml.writeAttribute("may_fail", true);
+ if(in.m_should_fail)
+ xml.writeAttribute("should_fail", true);
+ }
+
+ // =========================================================================================
+ // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
+ // =========================================================================================
+
+ void report_query(const QueryData& in) override {
+ test_run_start();
+ if(opt.list_reporters) {
+ for(auto& curr : getListeners())
+ xml.scopedElement("Listener")
+ .writeAttribute("priority", curr.first.first)
+ .writeAttribute("name", curr.first.second);
+ for(auto& curr : getReporters())
+ xml.scopedElement("Reporter")
+ .writeAttribute("priority", curr.first.first)
+ .writeAttribute("name", curr.first.second);
+ } else if(opt.count || opt.list_test_cases) {
+ for(unsigned i = 0; i < in.num_data; ++i) {
+ xml.scopedElement("TestCase").writeAttribute("name", in.data[i]->m_name)
+ .writeAttribute("testsuite", in.data[i]->m_test_suite)
+ .writeAttribute("filename", skipPathFromFilename(in.data[i]->m_file.c_str()))
+ .writeAttribute("line", line(in.data[i]->m_line))
+ .writeAttribute("skipped", in.data[i]->m_skip);
+ }
+ xml.scopedElement("OverallResultsTestCases")
+ .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
+ } else if(opt.list_test_suites) {
+ for(unsigned i = 0; i < in.num_data; ++i)
+ xml.scopedElement("TestSuite").writeAttribute("name", in.data[i]->m_test_suite);
+ xml.scopedElement("OverallResultsTestCases")
+ .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
+ xml.scopedElement("OverallResultsTestSuites")
+ .writeAttribute("unskipped", in.run_stats->numTestSuitesPassingFilters);
+ }
+ xml.endElement();
+ }
+
+ void test_run_start() override {
+ xml.writeDeclaration();
+
+ // remove .exe extension - mainly to have the same output on UNIX and Windows
+ std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
+#ifdef DOCTEST_PLATFORM_WINDOWS
+ if(binary_name.rfind(".exe") != std::string::npos)
+ binary_name = binary_name.substr(0, binary_name.length() - 4);
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+ xml.startElement("doctest").writeAttribute("binary", binary_name);
+ if(opt.no_version == false)
+ xml.writeAttribute("version", DOCTEST_VERSION_STR);
+
+ // only the consequential ones (TODO: filters)
+ xml.scopedElement("Options")
+ .writeAttribute("order_by", opt.order_by.c_str())
+ .writeAttribute("rand_seed", opt.rand_seed)
+ .writeAttribute("first", opt.first)
+ .writeAttribute("last", opt.last)
+ .writeAttribute("abort_after", opt.abort_after)
+ .writeAttribute("subcase_filter_levels", opt.subcase_filter_levels)
+ .writeAttribute("case_sensitive", opt.case_sensitive)
+ .writeAttribute("no_throw", opt.no_throw)
+ .writeAttribute("no_skip", opt.no_skip);
+ }
+
+ void test_run_end(const TestRunStats& p) override {
+ if(tc) // the TestSuite tag - only if there has been at least 1 test case
+ xml.endElement();
+
+ xml.scopedElement("OverallResultsAsserts")
+ .writeAttribute("successes", p.numAsserts - p.numAssertsFailed)
+ .writeAttribute("failures", p.numAssertsFailed);
+
+ xml.startElement("OverallResultsTestCases")
+ .writeAttribute("successes",
+ p.numTestCasesPassingFilters - p.numTestCasesFailed)
+ .writeAttribute("failures", p.numTestCasesFailed);
+ if(opt.no_skipped_summary == false)
+ xml.writeAttribute("skipped", p.numTestCases - p.numTestCasesPassingFilters);
+ xml.endElement();
+
+ xml.endElement();
+ }
+
+ void test_case_start(const TestCaseData& in) override {
+ test_case_start_impl(in);
+ xml.ensureTagClosed();
+ }
+
+ void test_case_reenter(const TestCaseData&) override {}
+
+ void test_case_end(const CurrentTestCaseStats& st) override {
+ xml.startElement("OverallResultsAsserts")
+ .writeAttribute("successes",
+ st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
+ .writeAttribute("failures", st.numAssertsFailedCurrentTest)
+ .writeAttribute("test_case_success", st.testCaseSuccess);
+ if(opt.duration)
+ xml.writeAttribute("duration", st.seconds);
+ if(tc->m_expected_failures)
+ xml.writeAttribute("expected_failures", tc->m_expected_failures);
+ xml.endElement();
+
+ xml.endElement();
+ }
+
+ void test_case_exception(const TestCaseException& e) override {
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ xml.scopedElement("Exception")
+ .writeAttribute("crash", e.is_crash)
+ .writeText(e.error_string.c_str());
+ }
+
+ void subcase_start(const SubcaseSignature& in) override {
+ xml.startElement("SubCase")
+ .writeAttribute("name", in.m_name)
+ .writeAttribute("filename", skipPathFromFilename(in.m_file))
+ .writeAttribute("line", line(in.m_line));
+ xml.ensureTagClosed();
+ }
+
+ void subcase_end() override { xml.endElement(); }
+
+ void log_assert(const AssertData& rb) override {
+ if(!rb.m_failed && !opt.success)
+ return;
+
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ xml.startElement("Expression")
+ .writeAttribute("success", !rb.m_failed)
+ .writeAttribute("type", assertString(rb.m_at))
+ .writeAttribute("filename", skipPathFromFilename(rb.m_file))
+ .writeAttribute("line", line(rb.m_line));
+
+ xml.scopedElement("Original").writeText(rb.m_expr);
+
+ if(rb.m_threw)
+ xml.scopedElement("Exception").writeText(rb.m_exception.c_str());
+
+ if(rb.m_at & assertType::is_throws_as)
+ xml.scopedElement("ExpectedException").writeText(rb.m_exception_type);
+ if(rb.m_at & assertType::is_throws_with)
+ xml.scopedElement("ExpectedExceptionString").writeText(rb.m_exception_string.c_str());
+ if((rb.m_at & assertType::is_normal) && !rb.m_threw)
+ xml.scopedElement("Expanded").writeText(rb.m_decomp.c_str());
+
+ log_contexts();
+
+ xml.endElement();
+ }
+
+ void log_message(const MessageData& mb) override {
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ xml.startElement("Message")
+ .writeAttribute("type", failureString(mb.m_severity))
+ .writeAttribute("filename", skipPathFromFilename(mb.m_file))
+ .writeAttribute("line", line(mb.m_line));
+
+ xml.scopedElement("Text").writeText(mb.m_string.c_str());
+
+ log_contexts();
+
+ xml.endElement();
+ }
+
+ void test_case_skipped(const TestCaseData& in) override {
+ if(opt.no_skipped_summary == false) {
+ test_case_start_impl(in);
+ xml.writeAttribute("skipped", "true");
+ xml.endElement();
+ }
+ }
+ };
+
+ DOCTEST_REGISTER_REPORTER("xml", 0, XmlReporter);
+
+ void fulltext_log_assert_to_stream(std::ostream& s, const AssertData& rb) {
+ if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) ==
+ 0) //!OCLINT bitwise operator in conditional
+ s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) "
+ << Color::None;
+
+ if(rb.m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
+ s << (rb.m_threw ? "threw as expected!" : "did NOT throw at all!") << "\n";
+ } else if((rb.m_at & assertType::is_throws_as) &&
+ (rb.m_at & assertType::is_throws_with)) { //!OCLINT
+ s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
+ << rb.m_exception_string.c_str()
+ << "\", " << rb.m_exception_type << " ) " << Color::None;
+ if(rb.m_threw) {
+ if(!rb.m_failed) {
+ s << "threw as expected!\n";
+ } else {
+ s << "threw a DIFFERENT exception! (contents: " << rb.m_exception << ")\n";
+ }
+ } else {
+ s << "did NOT throw at all!\n";
+ }
+ } else if(rb.m_at &
+ assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
+ s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", "
+ << rb.m_exception_type << " ) " << Color::None
+ << (rb.m_threw ? (rb.m_threw_as ? "threw as expected!" :
+ "threw a DIFFERENT exception: ") :
+ "did NOT throw at all!")
+ << Color::Cyan << rb.m_exception << "\n";
+ } else if(rb.m_at &
+ assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
+ s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
+ << rb.m_exception_string.c_str()
+ << "\" ) " << Color::None
+ << (rb.m_threw ? (!rb.m_failed ? "threw as expected!" :
+ "threw a DIFFERENT exception: ") :
+ "did NOT throw at all!")
+ << Color::Cyan << rb.m_exception << "\n";
+ } else if(rb.m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
+ s << (rb.m_threw ? "THREW exception: " : "didn't throw!") << Color::Cyan
+ << rb.m_exception << "\n";
+ } else {
+ s << (rb.m_threw ? "THREW exception: " :
+ (!rb.m_failed ? "is correct!\n" : "is NOT correct!\n"));
+ if(rb.m_threw)
+ s << rb.m_exception << "\n";
+ else
+ s << " values: " << assertString(rb.m_at) << "( " << rb.m_decomp << " )\n";
+ }
+ }
+
+ // TODO:
+ // - log_message()
+ // - respond to queries
+ // - honor remaining options
+ // - more attributes in tags
+ struct JUnitReporter : public IReporter
+ {
+ XmlWriter xml;
+ DOCTEST_DECLARE_MUTEX(mutex)
+ Timer timer;
+ std::vector<String> deepestSubcaseStackNames;
+
+ struct JUnitTestCaseData
+ {
+ static std::string getCurrentTimestamp() {
+ // Beware, this is not reentrant because of backward compatibility issues
+ // Also, UTC only, again because of backward compatibility (%z is C++11)
+ time_t rawtime;
+ std::time(&rawtime);
+ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+ std::tm timeInfo;
+#ifdef DOCTEST_PLATFORM_WINDOWS
+ gmtime_s(&timeInfo, &rawtime);
+#else // DOCTEST_PLATFORM_WINDOWS
+ gmtime_r(&rawtime, &timeInfo);
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+ char timeStamp[timeStampSize];
+ const char* const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+ return std::string(timeStamp);
+ }
+
+ struct JUnitTestMessage
+ {
+ JUnitTestMessage(const std::string& _message, const std::string& _type, const std::string& _details)
+ : message(_message), type(_type), details(_details) {}
+
+ JUnitTestMessage(const std::string& _message, const std::string& _details)
+ : message(_message), type(), details(_details) {}
+
+ std::string message, type, details;
+ };
+
+ struct JUnitTestCase
+ {
+ JUnitTestCase(const std::string& _classname, const std::string& _name)
+ : classname(_classname), name(_name), time(0), failures() {}
+
+ std::string classname, name;
+ double time;
+ std::vector<JUnitTestMessage> failures, errors;
+ };
+
+ void add(const std::string& classname, const std::string& name) {
+ testcases.emplace_back(classname, name);
+ }
+
+ void appendSubcaseNamesToLastTestcase(std::vector<String> nameStack) {
+ for(auto& curr: nameStack)
+ if(curr.size())
+ testcases.back().name += std::string("/") + curr.c_str();
+ }
+
+ void addTime(double time) {
+ if(time < 1e-4)
+ time = 0;
+ testcases.back().time = time;
+ totalSeconds += time;
+ }
+
+ void addFailure(const std::string& message, const std::string& type, const std::string& details) {
+ testcases.back().failures.emplace_back(message, type, details);
+ ++totalFailures;
+ }
+
+ void addError(const std::string& message, const std::string& details) {
+ testcases.back().errors.emplace_back(message, details);
+ ++totalErrors;
+ }
+
+ std::vector<JUnitTestCase> testcases;
+ double totalSeconds = 0;
+ int totalErrors = 0, totalFailures = 0;
+ };
+
+ JUnitTestCaseData testCaseData;
+
+ // caching pointers/references to objects of these types - safe to do
+ const ContextOptions& opt;
+ const TestCaseData* tc = nullptr;
+
+ JUnitReporter(const ContextOptions& co)
+ : xml(*co.cout)
+ , opt(co) {}
+
+ unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
+
+ // =========================================================================================
+ // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
+ // =========================================================================================
+
+ void report_query(const QueryData&) override {
+ xml.writeDeclaration();
+ }
+
+ void test_run_start() override {
+ xml.writeDeclaration();
+ }
+
+ void test_run_end(const TestRunStats& p) override {
+ // remove .exe extension - mainly to have the same output on UNIX and Windows
+ std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
+#ifdef DOCTEST_PLATFORM_WINDOWS
+ if(binary_name.rfind(".exe") != std::string::npos)
+ binary_name = binary_name.substr(0, binary_name.length() - 4);
+#endif // DOCTEST_PLATFORM_WINDOWS
+ xml.startElement("testsuites");
+ xml.startElement("testsuite").writeAttribute("name", binary_name)
+ .writeAttribute("errors", testCaseData.totalErrors)
+ .writeAttribute("failures", testCaseData.totalFailures)
+ .writeAttribute("tests", p.numAsserts);
+ if(opt.no_time_in_output == false) {
+ xml.writeAttribute("time", testCaseData.totalSeconds);
+ xml.writeAttribute("timestamp", JUnitTestCaseData::getCurrentTimestamp());
+ }
+ if(opt.no_version == false)
+ xml.writeAttribute("doctest_version", DOCTEST_VERSION_STR);
+
+ for(const auto& testCase : testCaseData.testcases) {
+ xml.startElement("testcase")
+ .writeAttribute("classname", testCase.classname)
+ .writeAttribute("name", testCase.name);
+ if(opt.no_time_in_output == false)
+ xml.writeAttribute("time", testCase.time);
+ // This is not ideal, but it should be enough to mimic gtest's junit output.
+ xml.writeAttribute("status", "run");
+
+ for(const auto& failure : testCase.failures) {
+ xml.scopedElement("failure")
+ .writeAttribute("message", failure.message)
+ .writeAttribute("type", failure.type)
+ .writeText(failure.details, false);
+ }
+
+ for(const auto& error : testCase.errors) {
+ xml.scopedElement("error")
+ .writeAttribute("message", error.message)
+ .writeText(error.details);
+ }
+
+ xml.endElement();
+ }
+ xml.endElement();
+ xml.endElement();
+ }
+
+ void test_case_start(const TestCaseData& in) override {
+ testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
+ timer.start();
+ }
+
+ void test_case_reenter(const TestCaseData& in) override {
+ testCaseData.addTime(timer.getElapsedSeconds());
+ testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
+ deepestSubcaseStackNames.clear();
+
+ timer.start();
+ testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
+ }
+
+ void test_case_end(const CurrentTestCaseStats&) override {
+ testCaseData.addTime(timer.getElapsedSeconds());
+ testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
+ deepestSubcaseStackNames.clear();
+ }
+
+ void test_case_exception(const TestCaseException& e) override {
+ DOCTEST_LOCK_MUTEX(mutex)
+ testCaseData.addError("exception", e.error_string.c_str());
+ }
+
+ void subcase_start(const SubcaseSignature& in) override {
+ deepestSubcaseStackNames.push_back(in.m_name);
+ }
+
+ void subcase_end() override {}
+
+ void log_assert(const AssertData& rb) override {
+ if(!rb.m_failed) // report only failures & ignore the `success` option
+ return;
+
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ std::ostringstream os;
+ os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ":" : "(")
+ << line(rb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl;
+
+ fulltext_log_assert_to_stream(os, rb);
+ log_contexts(os);
+ testCaseData.addFailure(rb.m_decomp.c_str(), assertString(rb.m_at), os.str());
+ }
+
+ void log_message(const MessageData& mb) override {
+ if(mb.m_severity & assertType::is_warn) // report only failures
+ return;
+
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ std::ostringstream os;
+ os << skipPathFromFilename(mb.m_file) << (opt.gnu_file_line ? ":" : "(")
+ << line(mb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl;
+
+ os << mb.m_string.c_str() << "\n";
+ log_contexts(os);
+
+ testCaseData.addFailure(mb.m_string.c_str(),
+ mb.m_severity & assertType::is_check ? "FAIL_CHECK" : "FAIL", os.str());
+ }
+
+ void test_case_skipped(const TestCaseData&) override {}
+
+ void log_contexts(std::ostringstream& s) {
+ int num_contexts = get_num_active_contexts();
+ if(num_contexts) {
+ auto contexts = get_active_contexts();
+
+ s << " logged: ";
+ for(int i = 0; i < num_contexts; ++i) {
+ s << (i == 0 ? "" : " ");
+ contexts[i]->stringify(&s);
+ s << std::endl;
+ }
+ }
+ }
+ };
+
+ DOCTEST_REGISTER_REPORTER("junit", 0, JUnitReporter);
+
+ struct Whitespace
+ {
+ int nrSpaces;
+ explicit Whitespace(int nr)
+ : nrSpaces(nr) {}
+ };
+
+ std::ostream& operator<<(std::ostream& out, const Whitespace& ws) {
+ if(ws.nrSpaces != 0)
+ out << std::setw(ws.nrSpaces) << ' ';
+ return out;
+ }
+
+ struct ConsoleReporter : public IReporter
+ {
+ std::ostream& s;
+ bool hasLoggedCurrentTestStart;
+ std::vector<SubcaseSignature> subcasesStack;
+ size_t currentSubcaseLevel;
+ DOCTEST_DECLARE_MUTEX(mutex)
+
+ // caching pointers/references to objects of these types - safe to do
+ const ContextOptions& opt;
+ const TestCaseData* tc;
+
+ ConsoleReporter(const ContextOptions& co)
+ : s(*co.cout)
+ , opt(co) {}
+
+ ConsoleReporter(const ContextOptions& co, std::ostream& ostr)
+ : s(ostr)
+ , opt(co) {}
+
+ // =========================================================================================
+ // WHAT FOLLOWS ARE HELPERS USED BY THE OVERRIDES OF THE VIRTUAL METHODS OF THE INTERFACE
+ // =========================================================================================
+
+ void separator_to_stream() {
+ s << Color::Yellow
+ << "==============================================================================="
+ "\n";
+ }
+
+ const char* getSuccessOrFailString(bool success, assertType::Enum at,
+ const char* success_str) {
+ if(success)
+ return success_str;
+ return failureString(at);
+ }
+
+ Color::Enum getSuccessOrFailColor(bool success, assertType::Enum at) {
+ return success ? Color::BrightGreen :
+ (at & assertType::is_warn) ? Color::Yellow : Color::Red;
+ }
+
+ void successOrFailColoredStringToStream(bool success, assertType::Enum at,
+ const char* success_str = "SUCCESS") {
+ s << getSuccessOrFailColor(success, at)
+ << getSuccessOrFailString(success, at, success_str) << ": ";
+ }
+
+ void log_contexts() {
+ int num_contexts = get_num_active_contexts();
+ if(num_contexts) {
+ auto contexts = get_active_contexts();
+
+ s << Color::None << " logged: ";
+ for(int i = 0; i < num_contexts; ++i) {
+ s << (i == 0 ? "" : " ");
+ contexts[i]->stringify(&s);
+ s << "\n";
+ }
+ }
+
+ s << "\n";
+ }
+
+ // this was requested to be made virtual so users could override it
+ virtual void file_line_to_stream(const char* file, int line,
+ const char* tail = "") {
+ s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
+ << (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
+ << (opt.gnu_file_line ? ":" : "):") << tail;
+ }
+
+ void logTestStart() {
+ if(hasLoggedCurrentTestStart)
+ return;
+
+ separator_to_stream();
+ file_line_to_stream(tc->m_file.c_str(), tc->m_line, "\n");
+ if(tc->m_description)
+ s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description << "\n";
+ if(tc->m_test_suite && tc->m_test_suite[0] != '\0')
+ s << Color::Yellow << "TEST SUITE: " << Color::None << tc->m_test_suite << "\n";
+ if(strncmp(tc->m_name, " Scenario:", 11) != 0)
+ s << Color::Yellow << "TEST CASE: ";
+ s << Color::None << tc->m_name << "\n";
+
+ for(size_t i = 0; i < currentSubcaseLevel; ++i) {
+ if(subcasesStack[i].m_name[0] != '\0')
+ s << " " << subcasesStack[i].m_name << "\n";
+ }
+
+ if(currentSubcaseLevel != subcasesStack.size()) {
+ s << Color::Yellow << "\nDEEPEST SUBCASE STACK REACHED (DIFFERENT FROM THE CURRENT ONE):\n" << Color::None;
+ for(size_t i = 0; i < subcasesStack.size(); ++i) {
+ if(subcasesStack[i].m_name[0] != '\0')
+ s << " " << subcasesStack[i].m_name << "\n";
+ }
+ }
+
+ s << "\n";
+
+ hasLoggedCurrentTestStart = true;
+ }
+
+ void printVersion() {
+ if(opt.no_version == false)
+ s << Color::Cyan << "[doctest] " << Color::None << "doctest version is \""
+ << DOCTEST_VERSION_STR << "\"\n";
+ }
+
+ void printIntro() {
+ if(opt.no_intro == false) {
+ printVersion();
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n";
+ }
+ }
+
+ void printHelp() {
+ int sizePrefixDisplay = static_cast<int>(strlen(DOCTEST_OPTIONS_PREFIX_DISPLAY));
+ printVersion();
+ // clang-format off
+ s << Color::Cyan << "[doctest]\n" << Color::None;
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n";
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "filter values: \"str1,str2,str3\" (comma separated strings)\n";
+ s << Color::Cyan << "[doctest]\n" << Color::None;
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "filters use wildcards for matching strings\n";
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "something passes a filter if any of the strings in a filter matches\n";
+#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
+ s << Color::Cyan << "[doctest]\n" << Color::None;
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"" DOCTEST_CONFIG_OPTIONS_PREFIX "\" PREFIX!!!\n";
+#endif
+ s << Color::Cyan << "[doctest]\n" << Color::None;
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "Query flags - the program quits after them. Available:\n\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "?, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "help, -" DOCTEST_OPTIONS_PREFIX_DISPLAY "h "
+ << Whitespace(sizePrefixDisplay*0) << "prints this message\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "v, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "version "
+ << Whitespace(sizePrefixDisplay*1) << "prints the version\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "c, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "count "
+ << Whitespace(sizePrefixDisplay*1) << "prints the number of matching tests\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ltc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-cases "
+ << Whitespace(sizePrefixDisplay*1) << "lists all matching tests by name\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-suites "
+ << Whitespace(sizePrefixDisplay*1) << "lists all matching test suites\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lr, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-reporters "
+ << Whitespace(sizePrefixDisplay*1) << "lists all registered reporters\n\n";
+ // ================================================================================== << 79
+ s << Color::Cyan << "[doctest] " << Color::None;
+ s << "The available <int>/<string> options/filters are:\n\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters tests by their name\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case-exclude=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their name\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters tests by their file\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sfe, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file-exclude=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their file\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters tests by their test suite\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tse, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite-exclude=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their test suite\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters subcases by their name\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-exclude=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "filters OUT subcases by their name\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "r, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "reporters=<filters> "
+ << Whitespace(sizePrefixDisplay*1) << "reporters to use (console is default)\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "o, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "out=<string> "
+ << Whitespace(sizePrefixDisplay*1) << "output filename\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ob, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "order-by=<string> "
+ << Whitespace(sizePrefixDisplay*1) << "how the tests should be ordered\n";
+ s << Whitespace(sizePrefixDisplay*3) << " <string> - [file/suite/name/rand/none]\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "rs, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "rand-seed=<int> "
+ << Whitespace(sizePrefixDisplay*1) << "seed for random ordering\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "f, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "first=<int> "
+ << Whitespace(sizePrefixDisplay*1) << "the first test passing the filters to\n";
+ s << Whitespace(sizePrefixDisplay*3) << " execute - for range-based execution\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "l, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "last=<int> "
+ << Whitespace(sizePrefixDisplay*1) << "the last test passing the filters to\n";
+ s << Whitespace(sizePrefixDisplay*3) << " execute - for range-based execution\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "aa, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "abort-after=<int> "
+ << Whitespace(sizePrefixDisplay*1) << "stop after <int> failed assertions\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "scfl,--" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-filter-levels=<int> "
+ << Whitespace(sizePrefixDisplay*1) << "apply filters for the first <int> levels\n";
+ s << Color::Cyan << "\n[doctest] " << Color::None;
+ s << "Bool options - can be used like flags and true is assumed. Available:\n\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "s, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "success=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "include successful assertions in output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "cs, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "case-sensitive=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "filters being treated as case sensitive\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "e, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "exit=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "exits after the tests finish\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "d, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "duration=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "prints the time duration of each test\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "m, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "minimal=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "minimal console output (only failures)\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "q, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "quiet=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "no console output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nt, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-throw=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "skips exceptions-related assert checks\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ne, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-exitcode=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "returns (or exits) always with success\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nr, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-run=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "skips all runtime doctest operations\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ni, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-intro=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "omit the framework intro in the output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nv, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-version=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "omit the framework version in the output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-colors=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "disables colors in output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "fc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "force-colors=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "use colors even when not in a tty\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nb, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-breaks=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "disables breakpoints in debuggers\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ns, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-skip=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "don't skip test cases marked as skip\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "gfl, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "gnu-file-line=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << ":n: vs (n): for line numbers in output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "npf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-path-filenames=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "only filenames and no paths in output\n";
+ s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nln, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-line-numbers=<bool> "
+ << Whitespace(sizePrefixDisplay*1) << "0 instead of real line numbers in output\n";
+ // ================================================================================== << 79
+ // clang-format on
+
+ s << Color::Cyan << "\n[doctest] " << Color::None;
+ s << "for more information visit the project documentation\n\n";
+ }
+
+ void printRegisteredReporters() {
+ printVersion();
+ auto printReporters = [this] (const reporterMap& reporters, const char* type) {
+ if(reporters.size()) {
+ s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n";
+ for(auto& curr : reporters)
+ s << "priority: " << std::setw(5) << curr.first.first
+ << " name: " << curr.first.second << "\n";
+ }
+ };
+ printReporters(getListeners(), "listeners");
+ printReporters(getReporters(), "reporters");
+ }
+
+ // =========================================================================================
+ // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
+ // =========================================================================================
+
+ void report_query(const QueryData& in) override {
+ if(opt.version) {
+ printVersion();
+ } else if(opt.help) {
+ printHelp();
+ } else if(opt.list_reporters) {
+ printRegisteredReporters();
+ } else if(opt.count || opt.list_test_cases) {
+ if(opt.list_test_cases) {
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "listing all test case names\n";
+ separator_to_stream();
+ }
+
+ for(unsigned i = 0; i < in.num_data; ++i)
+ s << Color::None << in.data[i]->m_name << "\n";
+
+ separator_to_stream();
+
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "unskipped test cases passing the current filters: "
+ << g_cs->numTestCasesPassingFilters << "\n";
+
+ } else if(opt.list_test_suites) {
+ s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n";
+ separator_to_stream();
+
+ for(unsigned i = 0; i < in.num_data; ++i)
+ s << Color::None << in.data[i]->m_test_suite << "\n";
+
+ separator_to_stream();
+
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "unskipped test cases passing the current filters: "
+ << g_cs->numTestCasesPassingFilters << "\n";
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "test suites with unskipped test cases passing the current filters: "
+ << g_cs->numTestSuitesPassingFilters << "\n";
+ }
+ }
+
+ void test_run_start() override {
+ if(!opt.minimal)
+ printIntro();
+ }
+
+ void test_run_end(const TestRunStats& p) override {
+ if(opt.minimal && p.numTestCasesFailed == 0)
+ return;
+
+ separator_to_stream();
+ s << std::dec;
+
+ auto totwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts))) + 1)));
+ auto passwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesPassingFilters - p.numTestCasesFailed, static_cast<unsigned>(p.numAsserts - p.numAssertsFailed))) + 1)));
+ auto failwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesFailed, static_cast<unsigned>(p.numAssertsFailed))) + 1)));
+ const bool anythingFailed = p.numTestCasesFailed > 0 || p.numAssertsFailed > 0;
+ s << Color::Cyan << "[doctest] " << Color::None << "test cases: " << std::setw(totwidth)
+ << p.numTestCasesPassingFilters << " | "
+ << ((p.numTestCasesPassingFilters == 0 || anythingFailed) ? Color::None :
+ Color::Green)
+ << std::setw(passwidth) << p.numTestCasesPassingFilters - p.numTestCasesFailed << " passed"
+ << Color::None << " | " << (p.numTestCasesFailed > 0 ? Color::Red : Color::None)
+ << std::setw(failwidth) << p.numTestCasesFailed << " failed" << Color::None << " |";
+ if(opt.no_skipped_summary == false) {
+ const int numSkipped = p.numTestCases - p.numTestCasesPassingFilters;
+ s << " " << (numSkipped == 0 ? Color::None : Color::Yellow) << numSkipped
+ << " skipped" << Color::None;
+ }
+ s << "\n";
+ s << Color::Cyan << "[doctest] " << Color::None << "assertions: " << std::setw(totwidth)
+ << p.numAsserts << " | "
+ << ((p.numAsserts == 0 || anythingFailed) ? Color::None : Color::Green)
+ << std::setw(passwidth) << (p.numAsserts - p.numAssertsFailed) << " passed" << Color::None
+ << " | " << (p.numAssertsFailed > 0 ? Color::Red : Color::None) << std::setw(failwidth)
+ << p.numAssertsFailed << " failed" << Color::None << " |\n";
+ s << Color::Cyan << "[doctest] " << Color::None
+ << "Status: " << (p.numTestCasesFailed > 0 ? Color::Red : Color::Green)
+ << ((p.numTestCasesFailed > 0) ? "FAILURE!" : "SUCCESS!") << Color::None << std::endl;
+ }
+
+ void test_case_start(const TestCaseData& in) override {
+ hasLoggedCurrentTestStart = false;
+ tc = ∈
+ subcasesStack.clear();
+ currentSubcaseLevel = 0;
+ }
+
+ void test_case_reenter(const TestCaseData&) override {
+ subcasesStack.clear();
+ }
+
+ void test_case_end(const CurrentTestCaseStats& st) override {
+ if(tc->m_no_output)
+ return;
+
+ // log the preamble of the test case only if there is something
+ // else to print - something other than that an assert has failed
+ if(opt.duration ||
+ (st.failure_flags && st.failure_flags != static_cast<int>(TestCaseFailureReason::AssertFailure)))
+ logTestStart();
+
+ if(opt.duration)
+ s << Color::None << std::setprecision(6) << std::fixed << st.seconds
+ << " s: " << tc->m_name << "\n";
+
+ if(st.failure_flags & TestCaseFailureReason::Timeout)
+ s << Color::Red << "Test case exceeded time limit of " << std::setprecision(6)
+ << std::fixed << tc->m_timeout << "!\n";
+
+ if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedButDidnt) {
+ s << Color::Red << "Should have failed but didn't! Marking it as failed!\n";
+ } else if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedAndDid) {
+ s << Color::Yellow << "Failed as expected so marking it as not failed\n";
+ } else if(st.failure_flags & TestCaseFailureReason::CouldHaveFailedAndDid) {
+ s << Color::Yellow << "Allowed to fail so marking it as not failed\n";
+ } else if(st.failure_flags & TestCaseFailureReason::DidntFailExactlyNumTimes) {
+ s << Color::Red << "Didn't fail exactly " << tc->m_expected_failures
+ << " times so marking it as failed!\n";
+ } else if(st.failure_flags & TestCaseFailureReason::FailedExactlyNumTimes) {
+ s << Color::Yellow << "Failed exactly " << tc->m_expected_failures
+ << " times as expected so marking it as not failed!\n";
+ }
+ if(st.failure_flags & TestCaseFailureReason::TooManyFailedAsserts) {
+ s << Color::Red << "Aborting - too many failed asserts!\n";
+ }
+ s << Color::None; // lgtm [cpp/useless-expression]
+ }
+
+ void test_case_exception(const TestCaseException& e) override {
+ DOCTEST_LOCK_MUTEX(mutex)
+ if(tc->m_no_output)
+ return;
+
+ logTestStart();
+
+ file_line_to_stream(tc->m_file.c_str(), tc->m_line, " ");
+ successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require :
+ assertType::is_check);
+ s << Color::Red << (e.is_crash ? "test case CRASHED: " : "test case THREW exception: ")
+ << Color::Cyan << e.error_string << "\n";
+
+ int num_stringified_contexts = get_num_stringified_contexts();
+ if(num_stringified_contexts) {
+ auto stringified_contexts = get_stringified_contexts();
+ s << Color::None << " logged: ";
+ for(int i = num_stringified_contexts; i > 0; --i) {
+ s << (i == num_stringified_contexts ? "" : " ")
+ << stringified_contexts[i - 1] << "\n";
+ }
+ }
+ s << "\n" << Color::None;
+ }
+
+ void subcase_start(const SubcaseSignature& subc) override {
+ subcasesStack.push_back(subc);
+ ++currentSubcaseLevel;
+ hasLoggedCurrentTestStart = false;
+ }
+
+ void subcase_end() override {
+ --currentSubcaseLevel;
+ hasLoggedCurrentTestStart = false;
+ }
+
+ void log_assert(const AssertData& rb) override {
+ if((!rb.m_failed && !opt.success) || tc->m_no_output)
+ return;
+
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ logTestStart();
+
+ file_line_to_stream(rb.m_file, rb.m_line, " ");
+ successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);
+
+ fulltext_log_assert_to_stream(s, rb);
+
+ log_contexts();
+ }
+
+ void log_message(const MessageData& mb) override {
+ if(tc->m_no_output)
+ return;
+
+ DOCTEST_LOCK_MUTEX(mutex)
+
+ logTestStart();
+
+ file_line_to_stream(mb.m_file, mb.m_line, " ");
+ s << getSuccessOrFailColor(false, mb.m_severity)
+ << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
+ "MESSAGE") << ": ";
+ s << Color::None << mb.m_string << "\n";
+ log_contexts();
+ }
+
+ void test_case_skipped(const TestCaseData&) override {}
+ };
+
+ DOCTEST_REGISTER_REPORTER("console", 0, ConsoleReporter);
+
+#ifdef DOCTEST_PLATFORM_WINDOWS
+ struct DebugOutputWindowReporter : public ConsoleReporter
+ {
+ DOCTEST_THREAD_LOCAL static std::ostringstream oss;
+
+ DebugOutputWindowReporter(const ContextOptions& co)
+ : ConsoleReporter(co, oss) {}
+
+#define DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(func, type, arg) \
+ void func(type arg) override { \
+ bool with_col = g_no_colors; \
+ g_no_colors = false; \
+ ConsoleReporter::func(arg); \
+ if(oss.tellp() != std::streampos{}) { \
+ DOCTEST_OUTPUT_DEBUG_STRING(oss.str().c_str()); \
+ oss.str(""); \
+ } \
+ g_no_colors = with_col; \
+ }
+
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_start, DOCTEST_EMPTY, DOCTEST_EMPTY)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_end, const TestRunStats&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_start, const TestCaseData&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_reenter, const TestCaseData&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_end, const CurrentTestCaseStats&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_exception, const TestCaseException&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_start, const SubcaseSignature&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_end, DOCTEST_EMPTY, DOCTEST_EMPTY)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_assert, const AssertData&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_message, const MessageData&, in)
+ DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_skipped, const TestCaseData&, in)
+ };
+
+ DOCTEST_THREAD_LOCAL std::ostringstream DebugOutputWindowReporter::oss;
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+ // the implementation of parseOption()
+ bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
+ // going from the end to the beginning and stopping on the first occurrence from the end
+ for(int i = argc; i > 0; --i) {
+ auto index = i - 1;
+ auto temp = std::strstr(argv[index], pattern);
+ if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
+ // eliminate matches in which the chars before the option are not '-'
+ bool noBadCharsFound = true;
+ auto curr = argv[index];
+ while(curr != temp) {
+ if(*curr++ != '-') {
+ noBadCharsFound = false;
+ break;
+ }
+ }
+ if(noBadCharsFound && argv[index][0] == '-') {
+ if(value) {
+ // parsing the value of an option
+ temp += strlen(pattern);
+ const unsigned len = strlen(temp);
+ if(len) {
+ *value = temp;
+ return true;
+ }
+ } else {
+ // just a flag - no value
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ // parses an option and returns the string after the '=' character
+ bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
+ const String& defaultVal = String()) {
+ if(value)
+ *value = defaultVal;
+#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
+ // offset (normally 3 for "dt-") to skip prefix
+ if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
+ return true;
+#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
+ return parseOptionImpl(argc, argv, pattern, value);
+ }
+
+ // locates a flag on the command line
+ bool parseFlag(int argc, const char* const* argv, const char* pattern) {
+ return parseOption(argc, argv, pattern);
+ }
+
+ // parses a comma separated list of words after a pattern in one of the arguments in argv
+ bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern,
+ std::vector<String>& res) {
+ String filtersString;
+ if(parseOption(argc, argv, pattern, &filtersString)) {
+ // tokenize with "," as a separator, unless escaped with backslash
+ std::ostringstream s;
+ auto flush = [&s, &res]() {
+ auto string = s.str();
+ if(string.size() > 0) {
+ res.push_back(string.c_str());
+ }
+ s.str("");
+ };
+
+ bool seenBackslash = false;
+ const char* current = filtersString.c_str();
+ const char* end = current + strlen(current);
+ while(current != end) {
+ char character = *current++;
+ if(seenBackslash) {
+ seenBackslash = false;
+ if(character == ',' || character == '\\') {
+ s.put(character);
+ continue;
+ }
+ s.put('\\');
+ }
+ if(character == '\\') {
+ seenBackslash = true;
+ } else if(character == ',') {
+ flush();
+ } else {
+ s.put(character);
+ }
+ }
+
+ if(seenBackslash) {
+ s.put('\\');
+ }
+ flush();
+ return true;
+ }
+ return false;
+ }
+
+ enum optionType
+ {
+ option_bool,
+ option_int
+ };
+
+ // parses an int/bool option from the command line
+ bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
+ int& res) {
+ String parsedValue;
+ if(!parseOption(argc, argv, pattern, &parsedValue))
+ return false;
+
+ if(type) {
+ // integer
+ // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
+ int theInt = std::atoi(parsedValue.c_str());
+ if (theInt != 0) {
+ res = theInt; //!OCLINT parameter reassignment
+ return true;
+ }
+ } else {
+ // boolean
+ const char positive[][5] = { "1", "true", "on", "yes" }; // 5 - strlen("true") + 1
+ const char negative[][6] = { "0", "false", "off", "no" }; // 6 - strlen("false") + 1
+
+ // if the value matches any of the positive/negative possibilities
+ for (unsigned i = 0; i < 4; i++) {
+ if (parsedValue.compare(positive[i], true) == 0) {
+ res = 1; //!OCLINT parameter reassignment
+ return true;
+ }
+ if (parsedValue.compare(negative[i], true) == 0) {
+ res = 0; //!OCLINT parameter reassignment
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+} // namespace
+
+Context::Context(int argc, const char* const* argv)
+ : p(new detail::ContextState) {
+ parseArgs(argc, argv, true);
+ if(argc)
+ p->binary_name = argv[0];
+}
+
+Context::~Context() {
+ if(g_cs == p)
+ g_cs = nullptr;
+ delete p;
+}
+
+void Context::applyCommandLine(int argc, const char* const* argv) {
+ parseArgs(argc, argv);
+ if(argc)
+ p->binary_name = argv[0];
+}
+
+// parses args
+void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) {
+ using namespace detail;
+
+ // clang-format off
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=", p->filters[0]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=", p->filters[0]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=", p->filters[1]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=", p->filters[2]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=", p->filters[2]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=", p->filters[3]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=", p->filters[4]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=", p->filters[4]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=", p->filters[5]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=", p->filters[5]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=", p->filters[6]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=", p->filters[6]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=", p->filters[7]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=", p->filters[7]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=", p->filters[8]);
+ parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=", p->filters[8]);
+ // clang-format on
+
+ int intRes = 0;
+ String strRes;
+
+#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default) \
+ if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) || \
+ parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes)) \
+ p->var = static_cast<bool>(intRes); \
+ else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) || \
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname)) \
+ p->var = true; \
+ else if(withDefaults) \
+ p->var = default
+
+#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default) \
+ if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) || \
+ parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes)) \
+ p->var = intRes; \
+ else if(withDefaults) \
+ p->var = default
+
+#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default) \
+ if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) || \
+ parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) || \
+ withDefaults) \
+ p->var = strRes
+
+ // clang-format off
+ DOCTEST_PARSE_STR_OPTION("out", "o", out, "");
+ DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file");
+ DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0);
+
+ DOCTEST_PARSE_INT_OPTION("first", "f", first, 0);
+ DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX);
+
+ DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0);
+ DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX);
+
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("minimal", "m", minimal, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("quiet", "q", quiet, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-intro", "ni", no_intro, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC));
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-debug-output", "ndo", no_debug_output, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false);
+ DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-time-in-output", "ntio", no_time_in_output, false);
+ // clang-format on
+
+ if(withDefaults) {
+ p->help = false;
+ p->version = false;
+ p->count = false;
+ p->list_test_cases = false;
+ p->list_test_suites = false;
+ p->list_reporters = false;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) {
+ p->help = true;
+ p->exit = true;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) {
+ p->version = true;
+ p->exit = true;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) {
+ p->count = true;
+ p->exit = true;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) {
+ p->list_test_cases = true;
+ p->exit = true;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) {
+ p->list_test_suites = true;
+ p->exit = true;
+ }
+ if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") ||
+ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) {
+ p->list_reporters = true;
+ p->exit = true;
+ }
+}
+
+// allows the user to add procedurally to the filters from the command line
+void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); }
+
+// allows the user to clear all filters from the command line
+void Context::clearFilters() {
+ for(auto& curr : p->filters)
+ curr.clear();
+}
+
+// allows the user to override procedurally the bool options from the command line
+void Context::setOption(const char* option, bool value) {
+ setOption(option, value ? "true" : "false");
+}
+
+// allows the user to override procedurally the int options from the command line
+void Context::setOption(const char* option, int value) {
+ setOption(option, toString(value).c_str());
+}
+
+// allows the user to override procedurally the string options from the command line
+void Context::setOption(const char* option, const char* value) {
+ auto argv = String("-") + option + "=" + value;
+ auto lvalue = argv.c_str();
+ parseArgs(1, &lvalue);
+}
+
+// users should query this in their main() and exit the program if true
+bool Context::shouldExit() { return p->exit; }
+
+void Context::setAsDefaultForAssertsOutOfTestCases() { g_cs = p; }
+
+void Context::setAssertHandler(detail::assert_handler ah) { p->ah = ah; }
+
+void Context::setCout(std::ostream* out) { p->cout = out; }
+
+static class DiscardOStream : public std::ostream
+{
+private:
+ class : public std::streambuf
+ {
+ private:
+ // allowing some buffering decreases the amount of calls to overflow
+ char buf[1024];
+
+ protected:
+ std::streamsize xsputn(const char_type*, std::streamsize count) override { return count; }
+
+ int_type overflow(int_type ch) override {
+ setp(std::begin(buf), std::end(buf));
+ return traits_type::not_eof(ch);
+ }
+ } discardBuf;
+
+public:
+ DiscardOStream()
+ : std::ostream(&discardBuf) {}
+} discardOut;
+
+// the main function that does all the filtering and test running
+int Context::run() {
+ using namespace detail;
+
+ // save the old context state in case such was setup - for using asserts out of a testing context
+ auto old_cs = g_cs;
+ // this is the current contest
+ g_cs = p;
+ is_running_in_test = true;
+
+ g_no_colors = p->no_colors;
+ p->resetRunData();
+
+ std::fstream fstr;
+ if(p->cout == nullptr) {
+ if(p->quiet) {
+ p->cout = &discardOut;
+ } else if(p->out.size()) {
+ // to a file if specified
+ fstr.open(p->out.c_str(), std::fstream::out);
+ p->cout = &fstr;
+ } else {
+#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ // stdout by default
+ p->cout = &std::cout;
+#else // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ return EXIT_FAILURE;
+#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
+ }
+ }
+
+ FatalConditionHandler::allocateAltStackMem();
+
+ auto cleanup_and_return = [&]() {
+ FatalConditionHandler::freeAltStackMem();
+
+ if(fstr.is_open())
+ fstr.close();
+
+ // restore context
+ g_cs = old_cs;
+ is_running_in_test = false;
+
+ // we have to free the reporters which were allocated when the run started
+ for(auto& curr : p->reporters_currently_used)
+ delete curr;
+ p->reporters_currently_used.clear();
+
+ if(p->numTestCasesFailed && !p->no_exitcode)
+ return EXIT_FAILURE;
+ return EXIT_SUCCESS;
+ };
+
+ // setup default reporter if none is given through the command line
+ if(p->filters[8].empty())
+ p->filters[8].push_back("console");
+
+ // check to see if any of the registered reporters has been selected
+ for(auto& curr : getReporters()) {
+ if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive))
+ p->reporters_currently_used.push_back(curr.second(*g_cs));
+ }
+
+ // TODO: check if there is nothing in reporters_currently_used
+
+ // prepend all listeners
+ for(auto& curr : getListeners())
+ p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs));
+
+#ifdef DOCTEST_PLATFORM_WINDOWS
+ if(isDebuggerActive() && p->no_debug_output == false)
+ p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs));
+#endif // DOCTEST_PLATFORM_WINDOWS
+
+ // handle version, help and no_run
+ if(p->no_run || p->version || p->help || p->list_reporters) {
+ DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData());
+
+ return cleanup_and_return();
+ }
+
+ std::vector<const TestCase*> testArray;
+ for(auto& curr : getRegisteredTests())
+ testArray.push_back(&curr);
+ p->numTestCases = testArray.size();
+
+ // sort the collected records
+ if(!testArray.empty()) {
+ if(p->order_by.compare("file", true) == 0) {
+ std::sort(testArray.begin(), testArray.end(), fileOrderComparator);
+ } else if(p->order_by.compare("suite", true) == 0) {
+ std::sort(testArray.begin(), testArray.end(), suiteOrderComparator);
+ } else if(p->order_by.compare("name", true) == 0) {
+ std::sort(testArray.begin(), testArray.end(), nameOrderComparator);
+ } else if(p->order_by.compare("rand", true) == 0) {
+ std::srand(p->rand_seed);
+
+ // random_shuffle implementation
+ const auto first = &testArray[0];
+ for(size_t i = testArray.size() - 1; i > 0; --i) {
+ int idxToSwap = std::rand() % (i + 1);
+
+ const auto temp = first[i];
+
+ first[i] = first[idxToSwap];
+ first[idxToSwap] = temp;
+ }
+ } else if(p->order_by.compare("none", true) == 0) {
+ // means no sorting - beneficial for death tests which call into the executable
+ // with a specific test case in mind - we don't want to slow down the startup times
+ }
+ }
+
+ std::set<String> testSuitesPassingFilt;
+
+ bool query_mode = p->count || p->list_test_cases || p->list_test_suites;
+ std::vector<const TestCaseData*> queryResults;
+
+ if(!query_mode)
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY);
+
+ // invoke the registered functions if they match the filter criteria (or just count them)
+ for(auto& curr : testArray) {
+ const auto& tc = *curr;
+
+ bool skip_me = false;
+ if(tc.m_skip && !p->no_skip)
+ skip_me = true;
+
+ if(!matchesAny(tc.m_file.c_str(), p->filters[0], true, p->case_sensitive))
+ skip_me = true;
+ if(matchesAny(tc.m_file.c_str(), p->filters[1], false, p->case_sensitive))
+ skip_me = true;
+ if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive))
+ skip_me = true;
+ if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive))
+ skip_me = true;
+ if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive))
+ skip_me = true;
+ if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive))
+ skip_me = true;
+
+ if(!skip_me)
+ p->numTestCasesPassingFilters++;
+
+ // skip the test if it is not in the execution range
+ if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) ||
+ (p->first > p->numTestCasesPassingFilters))
+ skip_me = true;
+
+ if(skip_me) {
+ if(!query_mode)
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc);
+ continue;
+ }
+
+ // do not execute the test if we are to only count the number of filter passing tests
+ if(p->count)
+ continue;
+
+ // print the name of the test and don't execute it
+ if(p->list_test_cases) {
+ queryResults.push_back(&tc);
+ continue;
+ }
+
+ // print the name of the test suite if not done already and don't execute it
+ if(p->list_test_suites) {
+ if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') {
+ queryResults.push_back(&tc);
+ testSuitesPassingFilt.insert(tc.m_test_suite);
+ p->numTestSuitesPassingFilters++;
+ }
+ continue;
+ }
+
+ // execute the test if it passes all the filtering
+ {
+ p->currentTest = &tc;
+
+ p->failure_flags = TestCaseFailureReason::None;
+ p->seconds = 0;
+
+ // reset atomic counters
+ p->numAssertsFailedCurrentTest_atomic = 0;
+ p->numAssertsCurrentTest_atomic = 0;
+
+ p->fullyTraversedSubcases.clear();
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc);
+
+ p->timer.start();
+
+ bool run_test = true;
+
+ do {
+ // reset some of the fields for subcases (except for the set of fully passed ones)
+ p->reachedLeaf = false;
+ // May not be empty if previous subcase exited via exception.
+ p->subcaseStack.clear();
+ p->currentSubcaseDepth = 0;
+
+ p->shouldLogCurrentException = true;
+
+ // reset stuff for logging with INFO()
+ p->stringifiedContexts.clear();
+
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ try {
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+// MSVC 2015 diagnoses fatalConditionHandler as unused (because reset() is a static method)
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4101) // unreferenced local variable
+ FatalConditionHandler fatalConditionHandler; // Handle signals
+ // execute the test
+ tc.m_test();
+ fatalConditionHandler.reset();
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
+ } catch(const TestFailureException&) {
+ p->failure_flags |= TestCaseFailureReason::AssertFailure;
+ } catch(...) {
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception,
+ {translateActiveException(), false});
+ p->failure_flags |= TestCaseFailureReason::Exception;
+ }
+#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
+
+ // exit this loop if enough assertions have failed - even if there are more subcases
+ if(p->abort_after > 0 &&
+ p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) {
+ run_test = false;
+ p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts;
+ }
+
+ if(!p->nextSubcaseStack.empty() && run_test)
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc);
+ if(p->nextSubcaseStack.empty())
+ run_test = false;
+ } while(run_test);
+
+ p->finalizeTestCaseData();
+
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
+
+ p->currentTest = nullptr;
+
+ // stop executing tests if enough assertions have failed
+ if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after)
+ break;
+ }
+ }
+
+ if(!query_mode) {
+ DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
+ } else {
+ QueryData qdata;
+ qdata.run_stats = g_cs;
+ qdata.data = queryResults.data();
+ qdata.num_data = unsigned(queryResults.size());
+ DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata);
+ }
+
+ return cleanup_and_return();
+}
+
+DOCTEST_DEFINE_INTERFACE(IReporter)
+
+int IReporter::get_num_active_contexts() { return detail::g_infoContexts.size(); }
+const IContextScope* const* IReporter::get_active_contexts() {
+ return get_num_active_contexts() ? &detail::g_infoContexts[0] : nullptr;
+}
+
+int IReporter::get_num_stringified_contexts() { return detail::g_cs->stringifiedContexts.size(); }
+const String* IReporter::get_stringified_contexts() {
+ return get_num_stringified_contexts() ? &detail::g_cs->stringifiedContexts[0] : nullptr;
+}
+
+namespace detail {
+ void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
+ if(isReporter)
+ getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
+ else
+ getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
+ }
+} // namespace detail
+
+} // namespace doctest
+
+#endif // DOCTEST_CONFIG_DISABLE
+
+#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) // 'function' : must be 'attribute' - see issue #182
+int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); }
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+
+DOCTEST_CLANG_SUPPRESS_WARNING_POP
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
+DOCTEST_GCC_SUPPRESS_WARNING_POP
+
+DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
+
+#endif // DOCTEST_LIBRARY_IMPLEMENTATION
+#endif // DOCTEST_CONFIG_IMPLEMENT
+
+#ifdef DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#undef DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
+#endif // DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
+
+#ifdef DOCTEST_UNDEF_NOMINMAX
+#undef NOMINMAX
+#undef DOCTEST_UNDEF_NOMINMAX
+#endif // DOCTEST_UNDEF_NOMINMAX
diff --git a/tdd/main.cpp b/tdd/main.cpp
new file mode 100644
index 0000000..a3f832e
--- /dev/null
+++ b/tdd/main.cpp
@@ -0,0 +1,2 @@
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include "doctest.h"
diff --git a/tdd/obras-test.cpp b/tdd/obras-test.cpp
new file mode 100644
index 0000000..40cb268
--- /dev/null
+++ b/tdd/obras-test.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include "doctest.h"
+#include "../sources/ControladorObras.hpp"
+#include "../sources/Livro.hpp"
+#include "../sources/Periodico.hpp"
+
+TEST_CASE("Adicionar Periodico") {
+ cout << "==================> Adicionar Periodico <==================" << endl;
+ cout << "> Instanciando o Controlador de Obras" << endl;
+ ControladorObras contObras;
+
+ cout << "=> Instanciando um Periodico: " << endl;
+ Periodico p("Revista de Ciência", 2023, 5, 3);
+ p.mostrarDetalhes();
+ cout << endl;
+ CHECK ("Revista de Ciência" == p.getTitulo());
+ CHECK (2023 == p.getAnoPublicacao());
+ CHECK (5 == p.getVolume());
+ CHECK (3 == p.getMes());
+
+ cout << "==> Adicionando a obra" << endl;
+ contObras.adicionarObra(p);
+ contObras.mostrarDetalhes();
+ cout << endl;
+
+ auto [total, disponiveis] = contObras.pesquisarObra(p);
+ CHECK (1 == total);
+ CHECK (1 == disponiveis);
+ cout << "======================================================" << endl;
+
+ //adicionar um que ja existe, incrementar
+}
+
+//cadastrar periodico
+ // cout << "==> Instanciando um Livro: " << endl;
+ // Livro l("C++ Programming", 2022, "John Doe", "Tech Books");
+ // l.mostrarDetalhes();
+ // contObras.adicionarObra("livro", l);
+ // cout << endl;
+
--
GitLab