thetic / mutiny / 24573089316

coverage: 97.192% (-1.4%) from 98.629%
24573089316

Pull #59

github

web-flow 
Merge 7426fcdfb into e0583988c
Pull Request #59: Disunity

1 of 3 new or added lines in 2 files covered. (33.33%)

74 existing lines in 7 files now uncovered.

4984 of 5128 relevant lines covered (97.19%)

3235.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.45
/src/mock/NamedValue.cpp
1 
#include "mutiny/mock/NamedValue.hpp"
2 









3



#include "mutiny/mock/NamedValueComparatorsAndCopiersRepository.hpp"










4












5



#include "mutiny/test/Shell.hpp"










6












7



namespace mu {










8



namespace tiny {










9



namespace mock {










10












11



NamedValueComparatorsAndCopiersRepository* NamedValue::default_repository_ =










12



    nullptr;










13



const double NamedValue::default_double_tolerance = 0.005;










14












15



void NamedValue::set_default_comparators_and_copiers_repository(




2,156✔





16



    NamedValueComparatorsAndCopiersRepository* repository










17



)










18



{










19



  default_repository_ = repository;




2,156✔





20



}




2,156✔





21













UNCOV

22



NamedValueComparatorsAndCopiersRepository* NamedValue::




×







23



    get_default_comparators_and_copiers_repository()










24



{











UNCOV

25



  return default_repository_;




×







26



}










27












28



NamedValue::NamedValue(const String& name)




1,136✔





29



  : name_(name)




1,136✔





30



  , type_("int")




1,136✔





31












32



{










33



  value_.int_value = 0;




1,136✔





34



}




1,136✔





35












36



NamedValue::NamedValue(NamedValue&& other) noexcept




923✔





37



  : name_(static_cast<String&&>(other.name_))




923✔





38



  , type_(static_cast<String&&>(other.type_))




923✔





39



  , is_const_object_(other.is_const_object_)




923✔





40



  , value_(other.value_)




923✔





41



  , size_(other.size_)




923✔





42



  , comparator_(other.comparator_)




923✔





43



  , copier_(other.copier_)




923✔





44



{










45



}




923✔





46












47



template<>










48



void NamedValue::set_value<bool>(bool value)




23✔





49



{










50



  type_ = "bool";




23✔





51



  value_.bool_value = value;




23✔





52



}




23✔





53












54



template<>










55



void NamedValue::set_value<int>(int value)




199✔





56



{










57



  type_ = "int";




199✔





58



  value_.int_value = value;




199✔





59



}




199✔





60












61



template<>










62



void NamedValue::set_value<unsigned int>(unsigned int value)




54✔





63



{










64



  type_ = "unsigned int";




54✔





65



  value_.unsigned_int_value = value;




54✔





66



}




54✔





67












68



template<>










69



void NamedValue::set_value<long int>(long int value)




39✔





70



{










71



  type_ = "long int";




39✔





72



  value_.long_int_value = value;




39✔





73



}




39✔





74












75



template<>










76



void NamedValue::set_value<unsigned long int>(unsigned long int value)




39✔





77



{










78



  type_ = "unsigned long int";




39✔





79



  value_.unsigned_long_int_value = value;




39✔





80



}




39✔





81












82



template<>










83



void NamedValue::set_value<long long>(long long value)




32✔





84



{










85



  type_ = "long long int";




32✔





86



  value_.long_long_int_value = value;




32✔





87



}




32✔





88












89



template<>










90



void NamedValue::set_value<unsigned long long>(unsigned long long value)




31✔





91



{










92



  type_ = "unsigned long long int";




31✔





93



  value_.unsigned_long_long_int_value = value;




31✔





94



}




31✔





95












96



template<>










97



void NamedValue::set_value<double>(double value)




39✔





98



{










99



  set_value(value, default_double_tolerance);




39✔





100



}




39✔





101












102



void NamedValue::set_value(double value, double tolerance)




47✔





103



{










104



  type_ = "double";




47✔





105



  value_.double_value.value = value;




47✔





106



  value_.double_value.tolerance = tolerance;




47✔





107



}




47✔





108












109



template<>










110



void NamedValue::set_value<void*>(void* value)




46✔





111



{










112



  type_ = "void*";




46✔





113



  value_.pointer_value = value;




46✔





114



}




46✔





115












116



template<>










117



void NamedValue::set_value<const void*>(const void* value)




50✔





118



{










119



  type_ = "const void*";




50✔





120



  value_.const_pointer_value = value;




50✔





121



}




50✔





122












123



template<>










124



void NamedValue::set_value<NamedValue::FunctionPointerValue>(




20✔





125



    NamedValue::FunctionPointerValue value










126



)










127



{










128



  type_ = "void (*)()";




20✔





129



  value_.function_pointer_value = value;




20✔





130



}




20✔





131












132



template<>










133



void NamedValue::set_value<const char*>(const char* value)




33✔





134



{










135



  type_ = "const char*";




33✔





136



  value_.string_value = value;




33✔





137



}




33✔





138












139



void NamedValue::set_memory_buffer(const unsigned char* value, size_t size)




15✔





140



{










141



  type_ = "const unsigned char*";




15✔





142



  value_.memory_buffer_value = value;




15✔





143



  size_ = size;




15✔





144



}




15✔





145












146



void NamedValue::set_const_object_pointer(




83✔





147



    const String& type,










148



    const void* object_ptr










149



)










150



{










151



  type_ = type;




83✔





152



  is_const_object_ = true;




83✔





153



  value_.const_object_pointer_value = object_ptr;




83✔





154



  if (default_repository_) {




83✔





155



    comparator_ = default_repository_->get_comparator_for_type(type);




83✔





156



    copier_ = default_repository_->get_copier_for_type(type);




83✔





157



  }










158



}




83✔





159












160



void NamedValue::set_object_pointer(const String& type, void* object_ptr)




40✔





161



{










162



  type_ = type;




40✔





163



  is_const_object_ = false;




40✔





164



  value_.object_pointer_value = object_ptr;




40✔





165



  if (default_repository_) {




40✔





166



    comparator_ = default_repository_->get_comparator_for_type(type);




40✔





167



    copier_ = default_repository_->get_copier_for_type(type);




40✔





168



  }










169



}




40✔





170












171



void NamedValue::set_size(size_t size)




31✔





172



{










173



  size_ = size;




31✔





174



}




31✔





175












176



void NamedValue::set_name(const char* name)




×







177



{










178



  name_ = name;




×







179



}




×







180












181



String NamedValue::get_name() const




2,577✔





182



{










183



  return name_;




2,577✔





184



}










185












186



String NamedValue::get_type() const




972✔





187



{










188



  return type_;




972✔





189



}










190












191



template<>










192



bool NamedValue::get_value<bool>() const




24✔





193



{










194



  STRCMP_EQUAL("bool", type_.c_str());




24✔





195



  return value_.bool_value;




24✔





196



}










197












198



template<>










199



int NamedValue::get_value<int>() const




53✔





200



{










201



  STRCMP_EQUAL("int", type_.c_str());




53✔





202



  return value_.int_value;




53✔





203



}










204












205



template<>










206



unsigned int NamedValue::get_value<unsigned int>() const




28✔





207



{










208



  if (type_ == "int" && value_.int_value >= 0)




28✔





209



    return static_cast<unsigned int>(value_.int_value);




1✔





210



  STRCMP_EQUAL("unsigned int", type_.c_str());




27✔





211



  return value_.unsigned_int_value;




27✔





212



}










213












214



template<>










215



long int NamedValue::get_value<long int>() const




31✔





216



{










217



  if (type_ == "int")




31✔





218



    return value_.int_value;




1✔





219



  else if (type_ == "unsigned int")




30✔





220



    return static_cast<long int>(value_.unsigned_int_value);




1✔





221



  STRCMP_EQUAL("long int", type_.c_str());




29✔





222



  return value_.long_int_value;




29✔





223



}










224












225



template<>










226



unsigned long int NamedValue::get_value<unsigned long int>() const




31✔





227



{










228



  if (type_ == "unsigned int")




31✔





229



    return value_.unsigned_int_value;




1✔





230



  else if (type_ == "int" && value_.int_value >= 0)




30✔





231



    return static_cast<unsigned long int>(value_.int_value);




1✔





232



  else if (type_ == "long int" && value_.long_int_value >= 0)




29✔





233



    return static_cast<unsigned long int>(value_.long_int_value);




1✔





234



  STRCMP_EQUAL("unsigned long int", type_.c_str());




28✔





235



  return value_.unsigned_long_int_value;




28✔





236



}










237












238



template<>










239



long long NamedValue::get_value<long long>() const




28✔





240



{










241



  if (type_ == "int")




28✔





242



    return value_.int_value;




1✔





243



  else if (type_ == "unsigned int")




27✔





244



    return static_cast<long long int>(value_.unsigned_int_value);




1✔





245



  else if (type_ == "long int")




26✔





246



    return value_.long_int_value;




1✔





247



  else if (type_ == "unsigned long int")




25✔





248



    return static_cast<long long int>(value_.unsigned_long_int_value);




1✔





249



  STRCMP_EQUAL("long long int", type_.c_str());




24✔





250



  return value_.long_long_int_value;




24✔





251



}










252












253



template<>










254



unsigned long long NamedValue::get_value<unsigned long long>() const




29✔





255



{










256



  if (type_ == "unsigned int")




29✔





257



    return value_.unsigned_int_value;




1✔





258



  else if (type_ == "int" && value_.int_value >= 0)




28✔





259



    return static_cast<unsigned long long int>(value_.int_value);




1✔





260



  else if (type_ == "long int" && value_.long_int_value >= 0)




27✔





261



    return static_cast<unsigned long long int>(value_.long_int_value);




1✔





262



  else if (type_ == "unsigned long int")




26✔





263



    return value_.unsigned_long_int_value;




1✔





264



  else if (type_ == "long long int" && value_.long_long_int_value >= 0)




25✔





265



    return static_cast<unsigned long long int>(value_.long_long_int_value);




1✔





266



  STRCMP_EQUAL("unsigned long long int", type_.c_str());




24✔





267



  return value_.unsigned_long_long_int_value;




24✔





268



}










269












270



template<>










271



double NamedValue::get_value<double>() const




16✔





272



{










273



  STRCMP_EQUAL("double", type_.c_str());




16✔





274



  return value_.double_value.value;




16✔





275



}










276












277



double NamedValue::get_double_tolerance() const




2✔





278



{










279



  STRCMP_EQUAL("double", type_.c_str());




2✔





280



  return value_.double_value.tolerance;




2✔





281



}










282












283



template<>










284



const char* NamedValue::get_value<const char*>() const




15✔





285



{










286



  STRCMP_EQUAL("const char*", type_.c_str());




15✔





287



  return value_.string_value;




15✔





288



}










289












290



template<>










291



void* NamedValue::get_value<void*>() const




16✔





292



{










293



  STRCMP_EQUAL("void*", type_.c_str());




16✔





294



  return value_.pointer_value;




16✔





295



}










296












297



template<>










298



const void* NamedValue::get_value<const void*>() const




40✔





299



{










300



  STRCMP_EQUAL("const void*", type_.c_str());




40✔





301



  return value_.const_pointer_value;




40✔





302



}










303












304



template<>










305



NamedValue::FunctionPointerValue NamedValue::get_value<




15✔





306



    NamedValue::FunctionPointerValue>() const










307



{










308



  STRCMP_EQUAL("void (*)()", type_.c_str());




15✔





309



  return value_.function_pointer_value;




15✔





310



}










311












312



const unsigned char* NamedValue::get_memory_buffer() const




2✔





313



{










314



  STRCMP_EQUAL("const unsigned char*", type_.c_str());




2✔





315



  return value_.memory_buffer_value;




2✔





316



}










317












318



const void* NamedValue::get_const_object_pointer() const




19✔





319



{










320



  return value_.const_object_pointer_value;




19✔





321



}










322












323



void* NamedValue::get_object_pointer() const




417✔





324



{










325



  return value_.object_pointer_value;




417✔





326



}










327












328



bool NamedValue::is_const_object() const




5✔





329



{










330



  return is_const_object_;




5✔





331



}










332












333



size_t NamedValue::get_size() const




26✔





334



{










335



  return size_;




26✔





336



}










337












338



NamedValueComparator* NamedValue::get_comparator() const




19✔





339



{










340



  return comparator_;




19✔





341



}










342












343



NamedValueCopier* NamedValue::get_copier() const




47✔





344



{










345



  return copier_;




47✔





346



}










347












348



bool NamedValue::equals(const NamedValue& p) const




189✔





349



{










350



  if ((type_ == "long int") && (p.type_ == "int"))




189✔





351



    return value_.long_int_value == p.value_.int_value;




1✔





352



  else if ((type_ == "int") && (p.type_ == "long int"))




188✔





353



    return value_.int_value == p.value_.long_int_value;




1✔





354



  else if ((type_ == "unsigned int") && (p.type_ == "int"))




187✔





355



    return (p.value_.int_value >= 0) &&




2✔





356



           (value_.unsigned_int_value ==




1✔





357



            static_cast<unsigned int>(p.value_.int_value));




2✔





358



  else if ((type_ == "int") && (p.type_ == "unsigned int"))




186✔





359



    return (value_.int_value >= 0) &&




2✔





360



           (static_cast<unsigned int>(value_.int_value) ==




1✔





361



            p.value_.unsigned_int_value);




2✔





362



  else if ((type_ == "unsigned long int") && (p.type_ == "int"))




185✔





363



    return (p.value_.int_value >= 0) &&




2✔





364



           (value_.unsigned_long_int_value ==




1✔





365



            static_cast<unsigned long>(p.value_.int_value));




2✔





366



  else if ((type_ == "int") && (p.type_ == "unsigned long int"))




184✔





367



    return (value_.int_value >= 0) &&




2✔





368



           (static_cast<unsigned long>(value_.int_value) ==




1✔





369



            p.value_.unsigned_long_int_value);




2✔





370



  else if ((type_ == "unsigned int") && (p.type_ == "long int"))




183✔





371



    return (p.value_.long_int_value >= 0) &&




2✔





372



           (value_.unsigned_int_value ==




1✔





373



            static_cast<unsigned long>(p.value_.long_int_value));




2✔





374



  else if ((type_ == "long int") && (p.type_ == "unsigned int"))




182✔





375



    return (value_.long_int_value >= 0) &&




2✔





376



           (static_cast<unsigned long>(value_.long_int_value) ==




1✔





377



            p.value_.unsigned_int_value);




2✔





378



  else if ((type_ == "unsigned int") && (p.type_ == "unsigned long int"))




181✔





379



    return value_.unsigned_int_value == p.value_.unsigned_long_int_value;




1✔





380



  else if ((type_ == "unsigned long int") && (p.type_ == "unsigned int"))




180✔





381



    return value_.unsigned_long_int_value == p.value_.unsigned_int_value;




1✔





382



  else if ((type_ == "long int") && (p.type_ == "unsigned long int"))




179✔





383



    return (value_.long_int_value >= 0) &&




3✔





384



           (static_cast<unsigned long>(value_.long_int_value) ==




1✔





385



            p.value_.unsigned_long_int_value);




3✔





386



  else if ((type_ == "unsigned long int") && (p.type_ == "long int"))




177✔





387



    return (p.value_.long_int_value >= 0) &&




3✔





388



           (value_.unsigned_long_int_value ==




1✔





389



            static_cast<unsigned long>(p.value_.long_int_value));




3✔





390



  else if ((type_ == "long long int") && (p.type_ == "int"))




175✔





391



    return value_.long_long_int_value == p.value_.int_value;




1✔





392



  else if ((type_ == "int") && (p.type_ == "long long int"))




174✔





393



    return value_.int_value == p.value_.long_long_int_value;




1✔





394



  else if ((type_ == "long long int") && (p.type_ == "long int"))




173✔





395



    return value_.long_long_int_value == p.value_.long_int_value;




1✔





396



  else if ((type_ == "long int") && (p.type_ == "long long int"))




172✔





397



    return value_.long_int_value == p.value_.long_long_int_value;




1✔





398



  else if ((type_ == "long long int") && (p.type_ == "unsigned int"))




171✔





399



    return (value_.long_long_int_value >= 0) &&




2✔





400



           (static_cast<unsigned long long>(value_.long_long_int_value) ==




1✔





401



            p.value_.unsigned_int_value);




2✔





402



  else if ((type_ == "unsigned int") && (p.type_ == "long long int"))




170✔





403



    return (p.value_.long_long_int_value >= 0) &&




2✔





404



           (value_.unsigned_int_value ==




1✔





405



            static_cast<unsigned long long>(p.value_.long_long_int_value));




2✔





406



  else if ((type_ == "long long int") && (p.type_ == "unsigned long int"))




169✔





407



    return (value_.long_long_int_value >= 0) &&




2✔





408



           (static_cast<unsigned long long>(value_.long_long_int_value) ==




1✔





409



            p.value_.unsigned_long_int_value);




2✔





410



  else if ((type_ == "unsigned long int") && (p.type_ == "long long int"))




168✔





411



    return (p.value_.long_long_int_value >= 0) &&




2✔





412



           (value_.unsigned_long_int_value ==




1✔





413



            static_cast<unsigned long long>(p.value_.long_long_int_value));




2✔





414



  else if ((type_ == "long long int") && (p.type_ == "unsigned long long int"))




167✔





415



    return (value_.long_long_int_value >= 0) &&




2✔





416



           (static_cast<unsigned long long>(value_.long_long_int_value) ==




1✔





417



            p.value_.unsigned_long_long_int_value);




2✔





418



  else if ((type_ == "unsigned long long int") && (p.type_ == "long long int"))




166✔





419



    return (p.value_.long_long_int_value >= 0) &&




2✔





420



           (value_.unsigned_long_long_int_value ==




1✔





421



            static_cast<unsigned long long>(p.value_.long_long_int_value));




2✔





422



  else if ((type_ == "unsigned long long int") && (p.type_ == "int"))




165✔





423



    return (p.value_.int_value >= 0) &&




2✔





424



           (value_.unsigned_long_long_int_value ==




1✔





425



            static_cast<unsigned long long>(p.value_.int_value));




2✔





426



  else if ((type_ == "int") && (p.type_ == "unsigned long long int"))




164✔





427



    return (value_.int_value >= 0) &&




2✔





428



           (static_cast<unsigned long long>(value_.int_value) ==




1✔





429



            p.value_.unsigned_long_long_int_value);




2✔





430



  else if ((type_ == "unsigned long long int") && (p.type_ == "unsigned int"))




163✔





431



    return value_.unsigned_long_long_int_value == p.value_.unsigned_int_value;




1✔





432



  else if ((type_ == "unsigned int") && (p.type_ == "unsigned long long int"))




162✔





433



    return value_.unsigned_int_value == p.value_.unsigned_long_long_int_value;




1✔





434



  else if ((type_ == "unsigned long long int") && (p.type_ == "long int"))




161✔





435



    return (p.value_.long_int_value >= 0) &&




2✔





436



           (value_.unsigned_long_long_int_value ==




1✔





437



            static_cast<unsigned long long>(p.value_.long_int_value));




2✔





438



  else if ((type_ == "long int") && (p.type_ == "unsigned long long int"))




160✔





439



    return (value_.long_int_value >= 0) &&




2✔





440



           (static_cast<unsigned long long>(value_.long_int_value) ==




1✔





441



            p.value_.unsigned_long_long_int_value);




2✔





442



  else if (




159✔





443



      (type_ == "unsigned long long int") && (p.type_ == "unsigned long int")




159✔





444



  )










445



    return value_.unsigned_long_long_int_value ==




1✔





446



           p.value_.unsigned_long_int_value;




1✔





447



  else if (




158✔





448



      (type_ == "unsigned long int") && (p.type_ == "unsigned long long int")




158✔





449



  )










450



    return value_.unsigned_long_int_value ==




1✔





451



           p.value_.unsigned_long_long_int_value;




1✔





452












453



  if (type_ != p.type_)




157✔





454



    return false;




2✔





455












456



  if (type_ == "bool")




155✔





457



    return value_.bool_value == p.value_.bool_value;




4✔





458



  else if (type_ == "int")




151✔





459



    return value_.int_value == p.value_.int_value;




73✔





460



  else if (type_ == "unsigned int")




78✔





461



    return value_.unsigned_int_value == p.value_.unsigned_int_value;




10✔





462



  else if (type_ == "long int")




68✔





463



    return value_.long_int_value == p.value_.long_int_value;




2✔





464



  else if (type_ == "unsigned long int")




66✔





465



    return value_.unsigned_long_int_value == p.value_.unsigned_long_int_value;




3✔





466



  else if (type_ == "long long int")




63✔





467



    return value_.long_long_int_value == p.value_.long_long_int_value;




3✔





468



  else if (type_ == "unsigned long long int")




60✔





469



    return value_.unsigned_long_long_int_value ==




3✔





470



           p.value_.unsigned_long_long_int_value;




3✔





471



  else if (type_ == "const char*")




57✔





472



    return String(value_.string_value) == String(p.value_.string_value);




7✔





473



  else if (type_ == "void*")




50✔





474



    return value_.pointer_value == p.value_.pointer_value;




4✔





475



  else if (type_ == "const void*")




46✔





476



    return value_.const_pointer_value == p.value_.const_pointer_value;




3✔





477



  else if (type_ == "void (*)()")




43✔





478



    return value_.function_pointer_value == p.value_.function_pointer_value;




4✔





479



  else if (type_ == "double")




39✔





480



    return (test::approx_equal(




36✔





481



        value_.double_value.value,




18✔





482



        p.value_.double_value.value,




18✔





483



        value_.double_value.tolerance




18✔





484



    ));




18✔





485



  else if (type_ == "const unsigned char*") {




21✔





486



    if (size_ != p.size_) {




6✔





487



      return false;




1✔





488



    }










489



    return memcmp(




10✔





490



               value_.memory_buffer_value, p.value_.memory_buffer_value, size_




5✔





491



           ) == 0;




5✔





492



  }










493












494



  if (comparator_)




15✔





495



    return comparator_->is_equal(




30✔





496



        value_.const_object_pointer_value, p.value_.const_object_pointer_value




15✔





497



    );




15✔





498













UNCOV

499



  return false;




×







500



}










501












502



bool NamedValue::compatible_for_copying(const NamedValue& p) const




50✔





503



{










504



  if (type_ == p.type_)




50✔





505



    return true;




21✔





506












507



  if ((type_ == "const void*") && (p.type_ == "void*"))




29✔





508



    return true;




28✔





509












510



  return false;




1✔





511



}










512












513



String NamedValue::to_string() const




64✔





514



{










515



  if (type_ == "bool")




64✔






UNCOV

516



    return string_from(value_.bool_value);




×







517



  else if (type_ == "int")




64✔





518



    return string_from(value_.int_value) + " " +




56✔





519



           brackets_formatted_hex_string_from(value_.int_value);




84✔





520



  else if (type_ == "unsigned int")




36✔





521



    return string_from(value_.unsigned_int_value) + " " +




10✔





522



           brackets_formatted_hex_string_from(value_.unsigned_int_value);




15✔





523



  else if (type_ == "long int")




31✔





524



    return string_from(value_.long_int_value) + " " +




6✔





525



           brackets_formatted_hex_string_from(value_.long_int_value);




9✔





526



  else if (type_ == "unsigned long int")




28✔





527



    return string_from(value_.unsigned_long_int_value) + " " +




6✔





528



           brackets_formatted_hex_string_from(value_.unsigned_long_int_value);




9✔





529



  else if (type_ == "long long int")




25✔






UNCOV

530



    return string_from(value_.long_long_int_value) + " " +




×








UNCOV

531



           brackets_formatted_hex_string_from(value_.long_long_int_value);




×







532



  else if (type_ == "unsigned long long int")




25✔






UNCOV

533



    return string_from(value_.unsigned_long_long_int_value) + " " +




×








UNCOV

534



           brackets_formatted_hex_string_from(




×








UNCOV

535



               value_.unsigned_long_long_int_value




×








UNCOV

536



           );




×







537



  else if (type_ == "const char*")




25✔





538



    return value_.string_value;




7✔





539



  else if (type_ == "void*")




18✔






UNCOV

540



    return string_from(value_.pointer_value);




×







541



  else if (type_ == "void (*)()")




18✔






UNCOV

542



    return string_from(value_.function_pointer_value);




×







543



  else if (type_ == "const void*")




18✔






UNCOV

544



    return string_from(value_.const_pointer_value);




×







545



  else if (type_ == "double")




18✔





546



    return string_from(value_.double_value.value);




5✔





547



  else if (type_ == "const unsigned char*")




13✔





548



    return string_from_binary_with_size_or_null(










549



        value_.memory_buffer_value, size_




9✔





550



    );




9✔





551












552



  if (comparator_)




4✔





553



    return comparator_->value_to_string(value_.const_object_pointer_value);




4✔





554












555



  return string_from_format(










556



      "No comparator found for type: \"%s\"", type_.c_str()











UNCOV

557



  );




×







558



}










559












560



} // namespace mock










561



} // namespace tiny










562



} // namespace mu
























    

  • 

    •