iutest  1.17.1.0
iutest_printers.hpp
[詳解]
1 //======================================================================
2 //-----------------------------------------------------------------------
13 //-----------------------------------------------------------------------
14 //======================================================================
15 #ifndef INCG_IRIS_IUTEST_PRINTERS_HPP_A6A321C9_9279_4336_8167_058C59EC0FD0_
16 #define INCG_IRIS_IUTEST_PRINTERS_HPP_A6A321C9_9279_4336_8167_058C59EC0FD0_
17 
18 //======================================================================
19 // include
20 #include "iutest_defs.hpp"
21 #include "internal/iutest_string_stream.hpp"
22 #include "internal/iutest_string_view.hpp"
23 
24 namespace iutest
25 {
26 
27 //======================================================================
28 // declare
29 template<typename T>
30 std::string PrintToString(const T& v);
31 
32 namespace detail
33 {
34 
35 inline void PrintBytesInObjectTo(const unsigned char* buf, size_t size, iu_ostream* os)
36 {
37 IUTEST_PRAGMA_CONSTEXPR_CALLED_AT_RUNTIME_WARN_DISABLE_BEGIN()
38  const size_t kMaxCount = detail::kValues::MaxPrintContainerCount;
39  *os << size << "-Byte object < ";
40  if( buf != IUTEST_NULLPTR && size > 0 )
41  {
42  for( size_t i=0; i < size; ++i )
43  {
44  if( i == kMaxCount )
45  {
46  *os << "... ";
47  break;
48  }
49 #ifdef __clang_analyzer__
50  const unsigned char n = 0; // suppress
51 #else
52  const unsigned char n = buf[i];
53 #endif
54  *os << ToHex((n>>4)&0xF) << ToHex(n&0xF) << " ";
55  }
56  }
57  *os << ">";
58 IUTEST_PRAGMA_CONSTEXPR_CALLED_AT_RUNTIME_WARN_DISABLE_END()
59 }
60 
61 namespace printer_internal
62 {
63 
64 namespace formatter
65 {
66 
68 template<bool convertible>
69 struct Printer
70 {
71  template<typename T>
72  static void Print(const T& value, iu_ostream* os)
73  {
74  const unsigned char* ptr = const_cast<const unsigned char*>(
75  reinterpret_cast<const volatile unsigned char*>(&value));
76  const size_t size = sizeof(T);
77  PrintBytesInObjectTo(ptr, size, os);
78  }
79 };
80 
81 template<>
82 struct Printer<true>
83 {
84  template<typename T>
85  static void Print(const T& value, iu_ostream* os)
86  {
87 #if IUTEST_HAS_BIGGESTINT_OSTREAM
88  const BiggestInt v = value;
89 #else
90  const Int32 v = value;
91 #endif
92  *os << v;
93  }
94 };
95 
96 } // end of namespace formatter
97 
99 class TypeWithoutFormatter
100 {
101 public:
102  template<typename T>
103  static void PrintValue(const T& value, iu_ostream* os)
104  {
105  formatter::Printer<
106  iutest_type_traits::is_convertible<const T&, BiggestInt>::value>::Print(value, os);
107  }
108 };
109 
110 #if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
111 
112 #if IUTEST_HAS_STRINGSTREAM || IUTEST_HAS_STRSTREAM
113 template<typename Elem, typename Traits, typename T>
114 ::std::basic_ostream<Elem, Traits>& operator << (::std::basic_ostream<Elem, Traits>& os, const T& value)
115 {
116  TypeWithoutFormatter::PrintValue(value, &os);
117  return os;
118 }
119 #else
120 template<typename Elem, typename Traits, typename T>
121 detail::iu_basic_ostream<Elem, Traits>& operator << (detail::iu_basic_ostream<Elem, Traits>& os, const T& value)
122 {
123  TypeWithoutFormatter::PrintValue(value, &os);
124  return os;
125 }
126 #endif
127 
128 #endif
129 
130 } // end of namespace printer_internal
131 
132 namespace printer_internal2
133 {
134 
135 // 解決順序
136 // foo::operator <<
137 // ::operator <<
138 // ::iutest::detail::printer_internal::operator <<
139 template<typename T>
140 void DefaultPrintNonContainerTo(const T& value, iu_ostream* os)
141 {
142  using namespace ::iutest::detail::printer_internal; // NOLINT
143  *os << value;
144 }
145 
146 } // end of namespace printer_internal2
147 
148 //======================================================================
149 // declare
150 template<typename T>
151 void UniversalPrint(const T& value, iu_ostream* os);
152 
153 //======================================================================
154 // function
158 template<typename T>
159 inline void DefaultPrintTo(IsContainerHelper::yes_t
160  , iutest_type_traits::false_type
161  , const T& container, iu_ostream* os)
162 {
163  const size_t kMaxCount = kValues::MaxPrintContainerCount;
164  size_t count = 0;
165  *os << "{";
166  for( typename T::const_iterator it=container.begin(), end=container.end(); it != end; ++it, ++count)
167  {
168  if( count > 0 )
169  {
170  *os << ",";
171  if( count == kMaxCount )
172  {
173  *os << " ...";
174  break;
175  }
176  }
177  *os << " ";
178  UniversalPrint(*it, os);
179  }
180  if( count > 0 )
181  {
182  *os << " ";
183  }
184  *os << "}";
185 }
186 
187 template<typename T>
188 inline void DefaultPrintNonContainerTo(const T& value, iu_ostream* os)
189 {
190 #if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
191  printer_internal2::DefaultPrintNonContainerTo(value, os);
192 #else
193  printer_internal::formatter::Printer<false>::Print(value, os);
194 #endif
195 }
197 template<typename T>
198 inline void DefaultPrintTo(IsContainerHelper::no_t
199  , iutest_type_traits::false_type
200  , const T& value, iu_ostream* os)
201 {
202  DefaultPrintNonContainerTo(value, os);
203 }
204 
205 #if !defined(IUTEST_NO_SFINAE) && !defined(IUTEST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
206 
207 template<typename T>
208 inline void DefaultPtrPrintTo(T* ptr, iu_ostream* os
209  , typename iutest_type_traits::enable_if_t< iutest_type_traits::is_convertible<T*, const void*> >::type*& = iutest_type_traits::enabler::value)
210 {
211  *os << reinterpret_cast<iu_uintptr_t>(ptr);
212 }
213 template<typename T>
214 inline void DefaultPtrPrintTo(T* ptr, iu_ostream* os
215  , typename iutest_type_traits::disable_if_t< iutest_type_traits::is_convertible<T*, const void*> >::type*& = iutest_type_traits::enabler::value)
216 {
217  *os << reinterpret_cast<const void*>(reinterpret_cast<type_least_t<8>::UInt>(ptr));
218 }
219 
220 #else
221 
222 template<typename T>
223 inline void DefaultPtrPrintTo(T* ptr, iu_ostream* os)
224 {
225  *os << reinterpret_cast<const void*>(reinterpret_cast<type_least_t<8>::UInt>(ptr));
226 }
227 
228 #endif
229 
230 template<typename T>
231 inline void DefaultPrintTo(IsContainerHelper::no_t
232  , iutest_type_traits::true_type
233  , T* ptr, iu_ostream* os)
234 {
235  if( ptr == IUTEST_NULLPTR )
236  {
237  *os << kStrings::Null;
238  }
239  else
240  {
241  DefaultPtrPrintTo<T>(ptr, os);
242  }
243 }
244 
245 
247 template<typename T>
248 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const T& value, iu_ostream* os)
249 {
250  UniversalPrint(value, os);
251 }
252 
253 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char* str, iu_ostream* os)
254 {
255  if( str == IUTEST_NULLPTR )
256  {
257  *os << kStrings::Null;
258  }
259  else
260  {
261  UniversalPrint(::std::string(str), os);
262  }
263 }
264 template<size_t N>
265 void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char(&str)[N], iu_ostream* os)
266 {
267  return UniversalTersePrint(static_cast<const char*>(str), os);
268 }
269 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const wchar_t* str, iu_ostream* os)
270 {
271  UniversalPrint(detail::ShowAnyCString(str), os);
272 }
273 template<size_t N>
274 void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const wchar_t(&str)[N], iu_ostream* os)
275 {
276  UniversalPrint(detail::ShowAnyCString(str), os);
277 }
278 #if IUTEST_HAS_CHAR16_T
279 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char16_t* str, iu_ostream* os)
280 {
281  UniversalPrint(detail::ShowAnyCString(str), os);
282 }
283 template<size_t N>
284 void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char16_t(&str)[N], iu_ostream* os)
285 {
286  UniversalPrint(detail::ShowAnyCString(str), os);
287 }
288 #endif
289 #if IUTEST_HAS_CHAR32_T && (IUTEST_HAS_CXX_HDR_CUCHAR || IUTEST_HAS_CXX_HDR_CODECVT)
290 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char32_t* str, iu_ostream* os)
291 {
292  UniversalPrint(detail::ShowAnyCString(str), os);
293 }
294 template<size_t N>
295 void IUTEST_ATTRIBUTE_UNUSED_ UniversalTersePrint(const char32_t(&str)[N], iu_ostream* os)
296 {
297  UniversalPrint(detail::ShowAnyCString(str), os);
298 }
299 #endif
300 
304 template<typename T>
305 inline void PrintTo(const T& value, iu_ostream* os) {
306  DefaultPrintTo(
307 #if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
308  IsContainerHelper::IsContainer<T>(0)
309 #else
310  IsContainerHelper::IsContainer(0, detail::explicit_type<T>())
311 #endif
312  , iutest_type_traits::is_pointer<T>(), value, os);
313 }
314 inline void PrintTo(bool b, iu_ostream* os) { *os << (b ? "true" : "false"); }
315 inline void PrintTo(const char* c, iu_ostream* os) { *os << c; }
316 #if defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
317 inline void PrintTo(int v, iu_ostream* os) { *os << v; }
318 #endif
319 inline void PrintTo(const ::std::string& str, iu_ostream* os) { *os << str.c_str(); }
320 template<typename CharT, typename Traits, typename Alloc>
321 inline void PrintTo(const ::std::basic_string<CharT, Traits, Alloc>& str, iu_ostream* os) { UniversalTersePrint(str.c_str(), os); }
322 #if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
323 template<typename T>
324 inline void PrintTo(const floating_point<T>& f, iu_ostream* os)
325 {
326 #if IUTEST_HAS_IOMANIP
327  iu_stringstream ss;
328  ss << ::std::setprecision(::std::numeric_limits<T>::digits10 + 2) << f.raw();
329  *os << ss.str() << "(0x" << ToHexString(f.bits()) << ")";
330 #else
331  *os << f.raw() << "(0x" << ToHexString(f.bits()) << ")";
332 #endif
333 }
334 template<typename T1, typename T2>
335 inline void PrintTo(const ::std::pair<T1, T2>& value, iu_ostream* os)
336 {
337  *os << "(";
338  UniversalPrint(value.first, os);
339  *os << ", ";
340  UniversalPrint(value.second, os);
341  *os << ")";
342 }
343 #endif
344 
345 template<typename T>
346 void PrintToChar(const T value, iu_ostream* os)
347 {
348  // char or unsigned char の時に、 0 が NULL 文字にならないように修正
349  if( value == 0 )
350  {
351  *os << "\\0";
352  }
353  else if( value < 0x20 )
354  {
355  *os << static_cast<int>(value);
356  }
357  else
358  {
359  const T str[2] = { value, 0 };
360  *os << "\'" << detail::ShowAnyCString(str) << "\'";
361  }
362 }
363 inline void PrintTo(const char value, iu_ostream* os)
364 {
365  PrintToChar(value, os);
366 }
367 inline void PrintTo(const wchar_t value, iu_ostream* os)
368 {
369  PrintToChar(value, os);
370 }
371 #if IUTEST_HAS_CHAR16_T
372 inline void PrintTo(const char16_t value, iu_ostream* os)
373 {
374  PrintToChar(value, os);
375 }
376 #endif
377 #if IUTEST_HAS_CHAR32_T
378 inline void PrintTo(const char32_t value, iu_ostream* os)
379 {
380  PrintToChar(value, os);
381 }
382 #endif
383 inline void PrintTo(const unsigned char value, iu_ostream* os)
384 {
385  *os << static_cast<unsigned int>(value);
386 }
387 #if IUTEST_HAS_CXX_HDR_STRING_VIEW
388 template<typename CharT, typename Traits>
389 inline void PrintTo(const ::std::basic_string_view<CharT, Traits>& value, iu_ostream* os)
390 {
391  const ::std::basic_string<CharT, Traits> str{ value };
392  UniversalTersePrint(str.c_str(), os);
393 }
394 #endif
395 
396 #if IUTEST_HAS_CXX_HDR_OPTIONAL
397 template<typename T>
398 inline void PrintTo(const ::std::optional<T>& value, iu_ostream* os)
399 {
400  if (value)
401  {
402  UniversalPrint(value.value(), os);
403  }
404  else
405  {
406  *os << "nullopt";
407  }
408 }
409 #endif
410 
411 #if IUTEST_HAS_CXX_HDR_VARIANT
412 template<typename... Types>
413 inline void PrintTo(const ::std::variant<Types...>& value, iu_ostream* os)
414 {
415  if (value.valueless_by_exception())
416  {
417  *os << "valueless_by_exception";
418  }
419  else
420  {
421  std::visit([&os](const auto& v) { UniversalPrint(v, os); }, value);
422  }
423 }
424 inline void PrintTo(const ::std::monostate&, iu_ostream* os)
425 {
426  *os << "monostate";
427 }
428 #endif
429 
430 #if IUTEST_HAS_CXX_HDR_ANY
431 inline void PrintTo(const ::std::any& value, iu_ostream* os)
432 {
433  *os << "-Any type-name: " << value.type().name();
434  DefaultPrintNonContainerTo(value, os);
435 }
436 #endif
437 
438 #if IUTEST_HAS_STD_FILESYSTEM
439 inline ::std::string FileSystemFileTypeToString(const ::std::filesystem::file_type& value)
440 {
441  switch(value)
442  {
443  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, none);
444  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, not_found);
445  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, regular);
446  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, directory);
447  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, symlink);
448  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, block);
449  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, character);
450  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, fifo);
451  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, socket);
452  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, unknown);
453 #if defined(IUTEST_OS_WINDOWS) && !defined(IUTEST_OS_WINDOWS_MINGW)
454  IUTEST_PP_NAMESPACE_ENUM_CASE_RETURN_STRING(::std::filesystem::file_type, junction);
455 #endif
456  default:
457  break;
458  }
459  return PrintToString(static_cast<int>(value));
460 }
461 template<>
462 inline void PrintTo<::std::filesystem::path>(const ::std::filesystem::path& value, iu_ostream* os)
463 {
464  *os << value.generic_string();
465 }
466 inline void PrintTo(const ::std::filesystem::file_type& value, iu_ostream* os)
467 {
468  *os << FileSystemFileTypeToString(value);
469 }
470 inline void PrintTo(const ::std::filesystem::perms& value, iu_ostream* os)
471 {
472  *os << ToOctString(static_cast<UInt16>(value));
473 }
474 inline void PrintTo(const ::std::filesystem::file_status& value, iu_ostream* os)
475 {
476  *os << FileSystemFileTypeToString(value.type()) << ": ";
477  PrintTo(value.permissions(), os);
478 }
479 inline void PrintTo(const ::std::filesystem::space_info& value, iu_ostream* os)
480 {
481  *os << "cpacity: " << detail::FormatSizeByte(value.capacity)
482  << ", free: " << detail::FormatSizeByte(value.free)
483  << ", available: " << detail::FormatSizeByte(value.available);
484 }
485 inline void PrintTo(const ::std::filesystem::directory_entry& value, iu_ostream* os)
486 {
487  PrintTo(value.path(), os);
488 }
489 inline void PrintTo(const ::std::filesystem::directory_iterator& value, iu_ostream* os)
490 {
491  PrintTo(*value, os);
492 }
493 #endif
494 
495 #if IUTEST_HAS_NULLPTR
496 inline void PrintTo(const ::std::nullptr_t&, iu_ostream* os) { *os << "nullptr"; }
497 #endif
498 
499 #if IUTEST_HAS_TUPLE
500 
501 template<typename T, int I, int SIZE>
502 inline void PrintTupleElemTo(const T& t, iu_ostream* os
503  , typename iutest_type_traits::enable_if<I == 0, void>::type*& = iutest_type_traits::enabler::value)
504 {
505  IUTEST_UNUSED_VAR(t);
506  IUTEST_UNUSED_VAR(os);
507 }
508 template<typename T, int I, int SIZE>
509 inline void PrintTupleElemTo(const T& t, iu_ostream* os
510  , typename iutest_type_traits::enable_if<I == 1, void>::type*& = iutest_type_traits::enabler::value)
511 {
512  PrintTo(tuples::get<SIZE-I>(t), os);
513 }
514 template<typename T, int I, int SIZE>
515 inline void PrintTupleElemTo(const T& t, iu_ostream* os
516  , typename iutest_type_traits::enable_if<(I&(~1)) != 0, void>::type*& = iutest_type_traits::enabler::value)
517 {
518  PrintTo(tuples::get<SIZE-I>(t), os);
519  *os << ", ";
520  PrintTupleElemTo<T, I-1, SIZE>(t, os);
521 }
522 
523 template<typename T>
524 inline void PrintTupleTo(const T& t, iu_ostream* os)
525 {
526  *os << "(";
527  PrintTupleElemTo<T, tuples::tuple_size<T>::value, tuples::tuple_size<T>::value>(t, os);
528  *os << ")";
529 }
530 
531 #if IUTEST_HAS_VARIADIC_TEMPLATES && IUTEST_HAS_TUPLE
532 
533 template<typename ...Args>
534 inline void PrintTo(const tuples::tuple<Args...>& t, iu_ostream* os)
535 {
536  PrintTupleTo(t, os);
537 }
538 
539 #else
540 
541 #define IIUT_DECL_TUPLE_PRINTTO(n) \
542  template<IUTEST_PP_ENUM_PARAMS(n, typename A)>inline void PrintTo( \
543  const tuples::tuple<IUTEST_PP_ENUM_PARAMS(n, A)>& t, iu_ostream* os) { \
544  PrintTupleTo(t, os); }
545 
546 inline void PrintTo(const tuples::tuple<>& t, iu_ostream* os) { PrintTupleTo(t, os); }
547 
548 IIUT_DECL_TUPLE_PRINTTO(1)
549 IIUT_DECL_TUPLE_PRINTTO(2)
550 IIUT_DECL_TUPLE_PRINTTO(3)
551 IIUT_DECL_TUPLE_PRINTTO(4)
552 IIUT_DECL_TUPLE_PRINTTO(5)
553 IIUT_DECL_TUPLE_PRINTTO(6)
554 IIUT_DECL_TUPLE_PRINTTO(7)
555 IIUT_DECL_TUPLE_PRINTTO(8)
556 IIUT_DECL_TUPLE_PRINTTO(9)
557 
558 #undef IIUT_DECL_TUPLE_PRINTTO
559 
560 #endif
561 
562 #endif
563 
567 template<typename T>
568 inline void PrintRawArrayTo(const T* a, size_t cnt, iu_ostream* os)
569 {
570  UniversalPrint<T>(a[0], os);
571  for( size_t i=1; i < cnt; ++i )
572  {
573  *os << ", ";
574  UniversalPrint<T>(a[i], os);
575  }
576 }
577 
581 template<typename T>
582 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalPrintArray(const T* begin, size_t N, iu_ostream* os)
583 {
584  if( N == 0 )
585  {
586  *os << "{}";
587  }
588  else
589  {
590  *os << "{ ";
591  const size_t kThreshold = kValues::PrintArrayThreshold;
592  const size_t kChunksize = kValues::PrintArrayChunksize;
593  if( N <= kThreshold )
594  {
595  PrintRawArrayTo(begin, N, os);
596  }
597  else
598  {
599  PrintRawArrayTo(begin, kChunksize, os);
600  *os << ", ..., ";
601  PrintRawArrayTo(begin + N - kChunksize, kChunksize, os);
602  }
603  *os << " }";
604  }
605 }
609 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalPrintArray(const char* begin, size_t N, iu_ostream* os)
610 {
611  IUTEST_UNUSED_VAR(N);
612  UniversalTersePrint(begin, os);
613 }
614 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalPrintArray(const wchar_t* begin, size_t N, iu_ostream* os)
615 {
616  IUTEST_UNUSED_VAR(N);
617  UniversalTersePrint(begin, os);
618 }
619 
621 template<typename T>
622 inline void IUTEST_ATTRIBUTE_UNUSED_ UniversalPrintTo(const T& value, iu_ostream* os)
623 {
624  PrintTo(value, os);
625 }
626 
627 //======================================================================
628 // class
630 template<typename T>
631 class iuUniversalPrinter
632 {
633 public:
634  static void Print(const T& value, iu_ostream* os)
635  {
636  UniversalPrintTo(value, os);
637  }
638 };
639 
640 #if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
641 
643 template<typename T, size_t SIZE>
644 class iuUniversalPrinter<T[SIZE]>
645 {
646 public:
647  static void Print(const T(&a)[SIZE], iu_ostream* os)
648  {
649  UniversalPrintArray(a, SIZE, os);
650  }
651 };
652 
653 #endif
654 
655 //======================================================================
656 // function
658 template<typename T>
659 inline void UniversalPrint(const T& value, iu_ostream* os)
660 {
661 #if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
662  iuUniversalPrinter<T>::Print(value, os);
663 #else
664  UniversalPrintTo(value, os);
665 #endif
666 }
667 
668 } // end of namespace detail
669 
670 //======================================================================
671 // function
672 
676 template<typename T>
677 inline ::std::string PrintToString(const T& v)
678 {
679  iu_global_format_stringstream strm;
680  detail::UniversalTersePrint(v, &strm);
681  return strm.str();
682 }
683 
684 #if IUTEST_HAS_VARIADIC_TEMPLATES
685 
688 template<typename T>
689 inline ::std::string PrintToStrings(const char* separate, const T& v)
690 {
691  IUTEST_UNUSED_VAR(separate);
692  return PrintToString(v);
693 }
697 template<typename T, typename ...Args>
698 inline ::std::string PrintToStrings(const char* separate, const T& v, Args... args)
699 {
700  ::std::string str = PrintToString(v);
701  str += separate;
702  str += PrintToStrings(separate, args...);
703  return str;
704 }
705 #endif
706 
707 } // end of namespace iutest
708 
709 #endif // INCG_IRIS_IUTEST_PRINTERS_HPP_A6A321C9_9279_4336_8167_058C59EC0FD0_
iutest_config.hpp
iris unit test config
iutest::PrintToString
std::string PrintToString(const T &v)
文字列化
Definition: iutest_printers.hpp:678
iutest_defs.hpp
iris unit test definition
iutest
iutest root namespace
Definition: iutest_charcode.hpp:31
iutest_string_stream.hpp
iris unit test iu_basic_ostream implimentaion
iutest::iu_global_format_stringstream
ostream_formatter オプションが適用されてた stringstream
Definition: iutest_env.hpp:809
iutest::PrintToStrings
inline ::std::string PrintToStrings(const char *separate, const T &v)
文字列化
Definition: iutest_printers.hpp:690
iutest::Int32
detail::type_fit_t< 4 >::Int Int32
32 bit 符号付き整数型
Definition: iutest_defs.hpp:423
iutest_string_view.hpp
string_view
iutest::BiggestInt
detail::type_least_t< 8 >::Int BiggestInt
Biggest Int
Definition: iutest_defs.hpp:446
2020年07月26日(日) 09時00分10秒作成 - iutest / 構成:   doxygen 1.8.17