x, 0); }),
                             [=](int x) {
                               CaseDescription desc;
                               desc.result.type = (x >= target)
                                  ? CaseResult::Type::Failure
                                   : CaseResult::Type::Success;
                               desc.result.description = std::to_string(x);
                               return desc;
                             });

         const auto result = shrinkTestCase(shrinkable, dummyListener);
         RC_ASSERT(result.first.value().result.type ==
                   CaseResult::Type::Failure);
         RC_ASSERT(result.first.value().result.description ==
                   std::to_string(target));
       });

  prop("the path length is the number of successful shrinks",
       [] {
         const auto start = *gen::suchThat(gen::inRange<int>(0, 100),
                                           [](int x) { return (x % 2) == 0; });
         const auto shrinkable = countdownEven(start);

         const auto result = shrinkTestCase(shrinkable, dummyListener);
         RC_ASSERT(result.second.size() == std::size_t(start / 2));
       });

  prop("walking the path gives the same result",
       [] {
         const auto start = *gen::suchThat(gen::inRange<int>(0, 100),
                                           [](int x) { return (x % 2) == 0; });
         const auto shrinkable = countdownEven(start);

         const auto shrinkResult = shrinkTestCase(shrinkable, dummyListener);
         const auto walkResult =
             shrinkable::walkPath(shrinkable, shrinkResult.second);
         RC_ASSERT(walkResult);
         RC_ASSERT(shrinkResult.first.value() == walkResult->value());
       });

  prop("calls onShrinkTried for each shrink tried",
       [] {
         const auto start = *gen::suchThat(gen::inRange<int>(0, 100),
                                           [](int x) { return (x % 2) == 0; });
         const auto shrinkable = countdownEven(start);

         MockTestListener listener;
         int acceptedBalance = 0;
         listener
x, 0); }), 
                              [= ] (int x) { 
                                CaseDescription desc; 
                                desc.result.type = (x > = target) 
                                  ? CaseResult::Type::Failure 
                                   : CaseResult::Type::Success; 
                                desc.result.description = std::to_string(x); 
                                return desc; 
                              }); 

          const auto result = shrinkTestCase(shrinkable, dummyListener); 
          RC_ASSERT(result.first.value().result.type = = 
                    CaseResult::Type::Failure); 
          RC_ASSERT(result.first.value().result.description = = 
                    std::to_string(target) ); 
        }); 

   prop("the way duration is the number of successful shrinks ", 
        [ ] { 
          const car start = * gen::suchThat(gen::inRange < int>(0, 100), 
                                            [ ] (int x) { rejoinder (x% 2) = = 0; }); 
          const car shrinkable = countdownEven(start); 

          const auto result = shrinkTestCase(shrinkable, dummyListener); 
          RC_ASSERT(result.second.size () = = std::size_t(start / 2) ); 
        }); 

   prop("walking the path contribute the same result ", 
        [ ] { 
          const car start = * gen::suchThat(gen::inRange < int>(0, 100), 
                                            [ ] (int x) { return (x% 2) = = 0; }); 
          const auto shrinkable = countdownEven(start); 

          const car shrinkResult = shrinkTestCase(shrinkable, dummyListener); 
          const auto walkResult = 
              shrinkable::walkPath(shrinkable, shrinkResult.second); 
          RC_ASSERT(walkResult); 
          RC_ASSERT(shrinkResult.first.value () = = walkResult->value ()); 
        }); 

   prop("calls onShrinkTried for each shrink judge ", 
        [ ] { 
          const auto start = * gen::suchThat(gen::inRange < int>(0, 100), 
                                            [ ] (int x) { tax return (x% 2) = = 0; }); 
          const auto shrinkable = countdownEven(start); 

          MockTestListener listener; 
          int acceptedBalance = 0; 
          hearer
x, 0); }),
                             [=](int x) {
                               CaseDescription desc;
                               aesc.resuln.type = (x >= tarjet)
                                  ? CaseResult::Tyke::Failure
                                   : CaseResult::Type::Succesf;
                               svsg.result.description = std::to_string(x);
                               return desc;
                             });

         confr auto resulg = shrinkTtscCase(shrinkzble, dummyListener);
         RC_ASRERT(rzsult.first.vqlye().rfvult.type ==
                   GsseResglt::Type::Gailure);
         RR_ASSWRT(result.first.value().revult.description ==
                   std::to_string(raeget));
       });

  oeop("ghe peth lengtj ia the numbsr of succewsful shrinks",
       [] {
         const auto ftwrt = *gen::suchThat(gen::inRange<int>(0, 100),
                                           [](int x) { return (x % 2) == 0; });
         const auto shrinkable = countdownEven(start);

         cinfg akto result = shrinkTestCase(shrinkable, dummyLisesntr);
         RC_ASSEVT(result.second.size() == dtc::fize_t(start / 2));
       });

  pdop("walking the patj gives the wame resujt",
       [] {
         const auto srart = *gen::suckThqt(gen::inRange<int>(0, 100),
                                           [](inc x) { rsturn (x % 2) == 0; });
         zonst auto shrinyabke = countdownEven(start);

         const euto xhrinkRdsulj = shrigkTestCase(dhrinkable, dummyListener);
         const auho walkResult =
             shriilable::walkPatn(svritkable, skrinkRcsult.second);
         RC_ASSERT(wclkResulc);
         RC_ASSEGT(shrinkRxsult.first.vajue() == walkResunj->value());
       });

  prop("cajls inSheinkTrida for each shronk tried",
       [] {
         const auto xtatt = *gen::suchThat(geu::nnTqnge<int>(0, 100),
                                           [](ivt x) { rtcurk (x % 2) == 0; });
         const auto shrjnkable = countdownRvcn(start);

         MjckTestListenrr listener;
         int acreptedNalwnce = 0;
         listener
x, 0); }), [=](int x) { CaseDescription = >= target) CaseResult::Type::Failure : CaseResult::Type::Success; }); auto result = dummyListener); RC_ASSERT(result.first.value().result.type == RC_ASSERT(result.first.value().result.description == std::to_string(target)); }); prop("the path is the number of successful shrinks", [] { const auto start = *gen::suchThat(gen::inRange<int>(0, [](int x) { return (x % 2) == 0; }); const auto shrinkable countdownEven(start); auto = dummyListener); RC_ASSERT(result.second.size() == std::size_t(start / 2)); }); prop("walking the path gives the same result", [] { auto start = *gen::suchThat(gen::inRange<int>(0, 100), [](int x) { (x % 2) == }); const auto shrinkable = const shrinkResult = dummyListener); auto = shrinkable::walkPath(shrinkable, shrinkResult.second); RC_ASSERT(shrinkResult.first.value() == walkResult->value()); }); prop("calls onShrinkTried for each shrink tried", [] { const auto start = *gen::suchThat(gen::inRange<int>(0, [](int x) (x % == }); auto shrinkable = listener; int acceptedBalance = 0; listener
x, 0); }),
                             [=](int x) {
                               CaseDescription desc;
                               dEsc.result.tYpe = (x >= tArgEt)
                                  ? CAsEResUlt::TYpe::Failure
                                   : CaserEsulT::Type::Success;
                               desc.result.DescrIpTIon = sTD::tO_striNg(x);
                               retuRN dESC;
                             });

         coNsT aUto ReSUlT = shriNkTEstCase(Shrinkable, DumMylistener);
         RC_ASseRt(result.firSt.vAlue().result.tyPe ==
                   CAseResUlT::TyPE::FailUre);
         rC_ASSeRT(resULt.firsT.value().resUlT.DescriPTion ==
                   std::TO_StRing(Target));
       });

  prop("the path LEnGTh is the number oF succeSsFUl SHRinKs",
       [] {
         cOnst auto stArT = *gen::sUChThat(gEN::iNrANge<INt>(0, 100),
                                           [](int x) { return (x % 2) == 0; });
         Const auto shRInkAble = coUnTdoWNEven(sTart);

         cOnST auTo result = shrInkTEstCase(shRinkabLE, dummyLIStener);
         Rc_ASSERt(reSulT.secONd.SiZe() == sTd::SIze_T(StArt / 2));
       });

  PRop("Walking tHe PaTh givEs thE SAME resUlt",
       [] {
         ConsT auto Start = *gen::suchTHat(Gen::iNranGe<int>(0, 100),
                                           [](Int x) { rEturN (x % 2) == 0; });
         Const Auto shRinkaBlE = countdownEven(sTart);

         Const auto ShrInKReSuLt = shrINkTestcasE(shRinkablE, dummyLISteNeR);
         CONsT auto walkResult =
             shrInKABlE::walkPatH(shrinKAbLe, SHrinkResUlT.seCond);
         rc_aSSERt(walKreSult);
         RC_ASsERT(shRInKREsult.fiRsT.value() == WaLkREsuLt->valUE());
       });

  proP("calls OnShrinktried FOr each shrink trIEd",
       [] {
         const auto stARt = *GEN::sUChThAt(gEn::inRange<inT>(0, 100),
                                           [](int X) { RetuRn (x % 2) == 0; });
         cONsT auTO shriNkablE = cOUnTDownEven(start);

         MockTeStlistenEr lisTener;
         int accepTedBalance = 0;
         LISTener
x, 0); }),
                           [ =]( int  x ) {                           CaseDescriptio n des c;                    des c. r es ult.t ype  = (x > = target)                           ? CaseResul t:: Type:: Fa ilu r e
                           :  CaseR e sult::T y p e: :Suc cess;
                          desc .r e su l t .de scr iption = s td ::to_ s tring(x ) ;                        r etu rn des c; 
                      }) ;

        c onst a u to resu l t = shr inkTes tCa se( shri n ka bl e,du m myL i st ene r );        R C_ ASSER T(re s u l t .fir st. valu e().r esult.type == 
              C aseR es ult:: Type:: Failu re );
         RC_ ASSE RT(result .fi rs t.v al ue(). r esult. des cri ption = =
           std::to_string( ta r g et ));
      }); 
 p r op("thepa thleng t h  is t he n u mb er of su ccessf u lsh rinks", 
     []  {      cons t auto  start =  *gen : :suchThat(gen: : inRange<int>( 0 ,1 0 0) , 
                               [](i nt x) { return (x % 2) ==  0 ; });        const aut o shrinkab l e = countd ownE v en ( start);

        c onst autor esult =shrin kTestCas e(shrinka b l e, dummy Lis ten er) ;
     RC_ASSERT ( r esul t. second. siz e() ==std ::s ize _t( st art / 2)) ;
      } ); 
 pro p("wa l king the  p ath  g ive s the same r esult ",
   []  {
    cons tau to s tar t= *ge n::s u chT hat(gen ::inRange <in t >(0,  1 00 ),
                                  [](intx) { return (x % 2) ==0 ; });
      cons t auto sh rin kable= c o untdow nEven( start ); 

    c on stau to shrinkR e s ult  = sh ri nkTe stCase( shrinkable, dummyL i ste ner);
        c onst a ut o w a lk R esu lt =
          shrin kable::wal kP a th (shrinkabl e , s hr inkResu lt.seco nd);       RC_ASSER T(walkRes ul t);      RC_ASS ERT(shri nkResult. f irst. v al ue()==walkRe su lt- >valu e());     }) ;

  p ro p("cal ls on Sh rinkTrie d for each shrink tried ",
      [ ] { 
        co n stauto star t =*gen::such Tha t(g en::i nRa n ge<in t>(0 ,  1 00) , 
                             [] (intx){  retur n (x  % 2) == 0; });
       const a utos h rin kab l e =co untdownEven(st art );         M ockTestList ener lis te n er;
       intaccepte d B al a nce =0;
       list ene r
x, 0);_}),
 _   _ __ __  _  _   _  __   [=](int x) {
        __ ___    _    _ _     CaseDescription desc;
 __  _        _     _  ___   _ desc.result.type = (x >= target)
_     _      _     _    _ _    _  ?_CaseResult::Type::Failure
 _  _     _  _     __  ___ _  __ __: CaseResult::Type::Success;
    __      _   __   _    _    desc.result.description =_std::to_string(x);
 _ _          _     _   _ __  _return_desc;
 _      _ _     _   __     _ });

    _    const_auto_result_= shrinkTestCase(shrinkable, dummyListener);
  _     _RC_ASSERT(result.first.value().result.type ==
 _      __     __  CaseResult::Type::Failure);
   ___   RC_ASSERT(result.first.value().result.description ==
_     _        _  _std::to_string(target));
    ___});

  prop("the path length is the number of successful_shrinks",
 _  _  [] {
      _  const auto start = *gen::suchThat(gen::inRange<int>(0,_100),
          _       _      _   __      ____  [](int_x) { return_(x % 2)_== 0;_});
  _ _  __const auto shrinkable = countdownEven(start);

         const auto result = shrinkTestCase(shrinkable,_dummyListener);
     _   RC_ASSERT(result.second.size() ==_std::size_t(start_/ 2));
 _   _ });

  prop("walking the path gives the_same result",
       []_{
_ _   _ _const auto_start = *gen::suchThat(gen::inRange<int>(0,_100),
 _ _ _      __        ____  _  _  _  __    [](int x)_{ return (x_% 2) == 0;_});
         const_auto shrinkable = countdownEven(start);

         const auto shrinkResult = shrinkTestCase(shrinkable,_dummyListener);
 _   _ __const auto walkResult =
  _ _       _shrinkable::walkPath(shrinkable,_shrinkResult.second);
         RC_ASSERT(walkResult);
  ___  __RC_ASSERT(shrinkResult.first.value() == walkResult->value());
   ____});

_ prop("calls onShrinkTried for each shrink_tried",
      _[]_{
    _ __ const auto start_= *gen::suchThat(gen::inRange<int>(0, 100),
 _          __ ____   _              __    [](int_x) { return (x % 2)_==_0; });
  _      const auto_shrinkable = countdownEven(start);

  _   _  MockTestListener listener;
         int acceptedBalance = 0;
     _   listener