Lines Matching refs:format
62 #include "fmt/format.h"
74 using fmt::format;
523 EXPECT_EQ("{", format("{{"));
524 EXPECT_EQ("before {", format("before {{"));
525 EXPECT_EQ("{ after", format("{{ after"));
526 EXPECT_EQ("before { after", format("before {{ after"));
528 EXPECT_EQ("}", format("}}"));
529 EXPECT_EQ("before }", format("before }}"));
530 EXPECT_EQ("} after", format("}} after"));
531 EXPECT_EQ("before } after", format("before }} after"));
533 EXPECT_EQ("{}", format("{{}}"));
534 EXPECT_EQ("{42}", format("{{{0}}}", 42));
538 EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string");
539 EXPECT_THROW_MSG(format("}"), FormatError, "unmatched '}' in format string");
540 EXPECT_THROW_MSG(format("{0{}"), FormatError, "invalid format string");
544 EXPECT_EQ("test", format("test"));
548 EXPECT_EQ("42", format("{0}", 42));
549 EXPECT_EQ("before 42", format("before {0}", 42));
550 EXPECT_EQ("42 after", format("{0} after", 42));
551 EXPECT_EQ("before 42 after", format("before {0} after", 42));
552 EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42));
553 EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42));
554 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
558 EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string");
559 EXPECT_THROW_MSG(format("{?}"), FormatError, "invalid format string");
560 EXPECT_THROW_MSG(format("{0"), FormatError, "invalid format string");
561 EXPECT_THROW_MSG(format("{0}"), FormatError, "argument index out of range");
565 EXPECT_THROW_MSG(format(format_str), FormatError, "invalid format string");
567 EXPECT_THROW_MSG(format(format_str), FormatError,
571 EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big");
573 EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big");
580 static std::string format(fmt::CStringRef format_str, const Args & ... args) {
581 return TestFormat<N - 1>::format(format_str, N - 1, args...);
588 static std::string format(fmt::CStringRef format_str, const Args & ... args) {
589 return fmt::format(format_str, args...);
594 EXPECT_EQ("19", TestFormat<20>::format("{19}"));
595 EXPECT_THROW_MSG(TestFormat<20>::format("{20}"),
597 EXPECT_THROW_MSG(TestFormat<21>::format("{21}"),
600 std::string format_str = fmt::format("{{{}}}", MAX_PACKED_ARGS + 1);
601 EXPECT_THROW_MSG(TestFormat<MAX_PACKED_ARGS>::format(format_str),
607 EXPECT_EQ("1/a/A", format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
610 EXPECT_EQ("BB/AA/CC", format("{1}{b}/{0}{a}/{2}{c}", FMT_CAPTURE(a, b, c)));
611 EXPECT_EQ(" A", format("{a:>2}", FMT_CAPTURE(a)));
612 EXPECT_THROW_MSG(format("{a+}", FMT_CAPTURE(a)), FormatError,
613 "missing '}' in format string");
614 EXPECT_THROW_MSG(format("{a}"), FormatError, "argument not found");
615 EXPECT_THROW_MSG(format("{d}", FMT_CAPTURE(a, b, c)), FormatError,
617 EXPECT_THROW_MSG(format("{a}{}", FMT_CAPTURE(a)),
619 EXPECT_THROW_MSG(format("{}{a}", FMT_CAPTURE(a)),
621 EXPECT_EQ(" -42", format("{0:{width}}", -42, fmt::arg("width", 4)));
622 EXPECT_EQ("st", format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
624 EXPECT_EQ(L"n=100", format(L"n={n}", FMT_CAPTURE_W(n)));
628 EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c'));
629 EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'),
631 EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'),
633 EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2));
634 EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2),
636 EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2),
638 EXPECT_THROW_MSG(format("{}"), FormatError, "argument index out of range");
642 EXPECT_EQ("42", format("{0:}", 42));
646 EXPECT_EQ("42 ", format("{0:<4}", 42));
647 EXPECT_EQ("42 ", format("{0:<4o}", 042));
648 EXPECT_EQ("42 ", format("{0:<4x}", 0x42));
649 EXPECT_EQ("-42 ", format("{0:<5}", -42));
650 EXPECT_EQ("42 ", format("{0:<5}", 42u));
651 EXPECT_EQ("-42 ", format("{0:<5}", -42l));
652 EXPECT_EQ("42 ", format("{0:<5}", 42ul));
653 EXPECT_EQ("-42 ", format("{0:<5}", -42ll));
654 EXPECT_EQ("42 ", format("{0:<5}", 42ull));
655 EXPECT_EQ("-42 ", format("{0:<5}", -42.0));
656 EXPECT_EQ("-42 ", format("{0:<5}", -42.0l));
657 EXPECT_EQ("c ", format("{0:<5}", 'c'));
658 EXPECT_EQ("abc ", format("{0:<5}", "abc"));
659 EXPECT_EQ("0xface ", format("{0:<8}", reinterpret_cast<void*>(0xface)));
663 EXPECT_EQ(" 42", format("{0:>4}", 42));
664 EXPECT_EQ(" 42", format("{0:>4o}", 042));
665 EXPECT_EQ(" 42", format("{0:>4x}", 0x42));
666 EXPECT_EQ(" -42", format("{0:>5}", -42));
667 EXPECT_EQ(" 42", format("{0:>5}", 42u));
668 EXPECT_EQ(" -42", format("{0:>5}", -42l));
669 EXPECT_EQ(" 42", format("{0:>5}", 42ul));
670 EXPECT_EQ(" -42", format("{0:>5}", -42ll));
671 EXPECT_EQ(" 42", format("{0:>5}", 42ull));
672 EXPECT_EQ(" -42", format("{0:>5}", -42.0));
673 EXPECT_EQ(" -42", format("{0:>5}", -42.0l));
674 EXPECT_EQ(" c", format("{0:>5}", 'c'));
675 EXPECT_EQ(" abc", format("{0:>5}", "abc"));
676 EXPECT_EQ(" 0xface", format("{0:>8}", reinterpret_cast<void*>(0xface)));
680 EXPECT_EQ(" 42", format("{0:=4}", 42));
681 EXPECT_EQ("+ 42", format("{0:=+4}", 42));
682 EXPECT_EQ(" 42", format("{0:=4o}", 042));
683 EXPECT_EQ("+ 42", format("{0:=+4o}", 042));
684 EXPECT_EQ(" 42", format("{0:=4x}", 0x42));
685 EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42));
686 EXPECT_EQ("- 42", format("{0:=5}", -42));
687 EXPECT_EQ(" 42", format("{0:=5}", 42u));
688 EXPECT_EQ("- 42", format("{0:=5}", -42l));
689 EXPECT_EQ(" 42", format("{0:=5}", 42ul));
690 EXPECT_EQ("- 42", format("{0:=5}", -42ll));
691 EXPECT_EQ(" 42", format("{0:=5}", 42ull));
692 EXPECT_EQ("- 42", format("{0:=5}", -42.0));
693 EXPECT_EQ("- 42", format("{0:=5}", -42.0l));
694 EXPECT_THROW_MSG(format("{0:=5", 'c'),
695 FormatError, "missing '}' in format string");
696 EXPECT_THROW_MSG(format("{0:=5}", 'c'),
697 FormatError, "invalid format specifier for char");
698 EXPECT_THROW_MSG(format("{0:=5}", "abc"),
699 FormatError, "format specifier '=' requires numeric argument");
700 EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
701 FormatError, "format specifier '=' requires numeric argument");
705 EXPECT_EQ(" 42 ", format("{0:^5}", 42));
706 EXPECT_EQ(" 42 ", format("{0:^5o}", 042));
707 EXPECT_EQ(" 42 ", format("{0:^5x}", 0x42));
708 EXPECT_EQ(" -42 ", format("{0:^5}", -42));
709 EXPECT_EQ(" 42 ", format("{0:^5}", 42u));
710 EXPECT_EQ(" -42 ", format("{0:^5}", -42l));
711 EXPECT_EQ(" 42 ", format("{0:^5}", 42ul));
712 EXPECT_EQ(" -42 ", format("{0:^5}", -42ll));
713 EXPECT_EQ(" 42 ", format("{0:^5}", 42ull));
714 EXPECT_EQ(" -42 ", format("{0:^6}", -42.0));
715 EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l));
716 EXPECT_EQ(" c ", format("{0:^5}", 'c'));
717 EXPECT_EQ(" abc ", format("{0:^6}", "abc"));
718 EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface)));
722 EXPECT_THROW_MSG(format("{0:{<5}", 'c'),
724 EXPECT_THROW_MSG(format("{0:{<5}}", 'c'),
726 EXPECT_EQ("**42", format("{0:*>4}", 42));
727 EXPECT_EQ("**-42", format("{0:*>5}", -42));
728 EXPECT_EQ("***42", format("{0:*>5}", 42u));
729 EXPECT_EQ("**-42", format("{0:*>5}", -42l));
730 EXPECT_EQ("***42", format("{0:*>5}", 42ul));
731 EXPECT_EQ("**-42", format("{0:*>5}", -42ll));
732 EXPECT_EQ("***42", format("{0:*>5}", 42ull));
733 EXPECT_EQ("**-42", format("{0:*>5}", -42.0));
734 EXPECT_EQ("**-42", format("{0:*>5}", -42.0l));
735 EXPECT_EQ("c****", format("{0:*<5}", 'c'));
736 EXPECT_EQ("abc**", format("{0:*<5}", "abc"));
737 EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface)));
741 EXPECT_EQ("+42", format("{0:+}", 42));
742 EXPECT_EQ("-42", format("{0:+}", -42));
743 EXPECT_EQ("+42", format("{0:+}", 42));
744 EXPECT_THROW_MSG(format("{0:+}", 42u),
745 FormatError, "format specifier '+' requires signed argument");
746 EXPECT_EQ("+42", format("{0:+}", 42l));
747 EXPECT_THROW_MSG(format("{0:+}", 42ul),
748 FormatError, "format specifier '+' requires signed argument");
749 EXPECT_EQ("+42", format("{0:+}", 42ll));
750 EXPECT_THROW_MSG(format("{0:+}", 42ull),
751 FormatError, "format specifier '+' requires signed argument");
752 EXPECT_EQ("+42", format("{0:+}", 42.0));
753 EXPECT_EQ("+42", format("{0:+}", 42.0l));
754 EXPECT_THROW_MSG(format("{0:+", 'c'),
755 FormatError, "missing '}' in format string");
756 EXPECT_THROW_MSG(format("{0:+}", 'c'),
757 FormatError, "invalid format specifier for char");
758 EXPECT_THROW_MSG(format("{0:+}", "abc"),
759 FormatError, "format specifier '+' requires numeric argument");
760 EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),
761 FormatError, "format specifier '+' requires numeric argument");
765 EXPECT_EQ("42", format("{0:-}", 42));
766 EXPECT_EQ("-42", format("{0:-}", -42));
767 EXPECT_EQ("42", format("{0:-}", 42));
768 EXPECT_THROW_MSG(format("{0:-}", 42u),
769 FormatError, "format specifier '-' requires signed argument");
770 EXPECT_EQ("42", format("{0:-}", 42l));
771 EXPECT_THROW_MSG(format("{0:-}", 42ul),
772 FormatError, "format specifier '-' requires signed argument");
773 EXPECT_EQ("42", format("{0:-}", 42ll));
774 EXPECT_THROW_MSG(format("{0:-}", 42ull),
775 FormatError, "format specifier '-' requires signed argument");
776 EXPECT_EQ("42", format("{0:-}", 42.0));
777 EXPECT_EQ("42", format("{0:-}", 42.0l));
778 EXPECT_THROW_MSG(format("{0:-", 'c'),
779 FormatError, "missing '}' in format string");
780 EXPECT_THROW_MSG(format("{0:-}", 'c'),
781 FormatError, "invalid format specifier for char");
782 EXPECT_THROW_MSG(format("{0:-}", "abc"),
783 FormatError, "format specifier '-' requires numeric argument");
784 EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),
785 FormatError, "format specifier '-' requires numeric argument");
789 EXPECT_EQ(" 42", format("{0: }", 42));
790 EXPECT_EQ("-42", format("{0: }", -42));
791 EXPECT_EQ(" 42", format("{0: }", 42));
792 EXPECT_THROW_MSG(format("{0: }", 42u),
793 FormatError, "format specifier ' ' requires signed argument");
794 EXPECT_EQ(" 42", format("{0: }", 42l));
795 EXPECT_THROW_MSG(format("{0: }", 42ul),
796 FormatError, "format specifier ' ' requires signed argument");
797 EXPECT_EQ(" 42", format("{0: }", 42ll));
798 EXPECT_THROW_MSG(format("{0: }", 42ull),
799 FormatError, "format specifier ' ' requires signed argument");
800 EXPECT_EQ(" 42", format("{0: }", 42.0));
801 EXPECT_EQ(" 42", format("{0: }", 42.0l));
802 EXPECT_THROW_MSG(format("{0: ", 'c'),
803 FormatError, "missing '}' in format string");
804 EXPECT_THROW_MSG(format("{0: }", 'c'),
805 FormatError, "invalid format specifier for char");
806 EXPECT_THROW_MSG(format("{0: }", "abc"),
807 FormatError, "format specifier ' ' requires numeric argument");
808 EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),
809 FormatError, "format specifier ' ' requires numeric argument");
813 EXPECT_EQ("42", format("{0:#}", 42));
814 EXPECT_EQ("-42", format("{0:#}", -42));
815 EXPECT_EQ("0b101010", format("{0:#b}", 42));
816 EXPECT_EQ("0B101010", format("{0:#B}", 42));
817 EXPECT_EQ("-0b101010", format("{0:#b}", -42));
818 EXPECT_EQ("0x42", format("{0:#x}", 0x42));
819 EXPECT_EQ("0X42", format("{0:#X}", 0x42));
820 EXPECT_EQ("-0x42", format("{0:#x}", -0x42));
821 EXPECT_EQ("042", format("{0:#o}", 042));
822 EXPECT_EQ("-042", format("{0:#o}", -042));
823 EXPECT_EQ("42", format("{0:#}", 42u));
824 EXPECT_EQ("0x42", format("{0:#x}", 0x42u));
825 EXPECT_EQ("042", format("{0:#o}", 042u));
827 EXPECT_EQ("-42", format("{0:#}", -42l));
828 EXPECT_EQ("0x42", format("{0:#x}", 0x42l));
829 EXPECT_EQ("-0x42", format("{0:#x}", -0x42l));
830 EXPECT_EQ("042", format("{0:#o}", 042l));
831 EXPECT_EQ("-042", format("{0:#o}", -042l));
832 EXPECT_EQ("42", format("{0:#}", 42ul));
833 EXPECT_EQ("0x42", format("{0:#x}", 0x42ul));
834 EXPECT_EQ("042", format("{0:#o}", 042ul));
836 EXPECT_EQ("-42", format("{0:#}", -42ll));
837 EXPECT_EQ("0x42", format("{0:#x}", 0x42ll));
838 EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll));
839 EXPECT_EQ("042", format("{0:#o}", 042ll));
840 EXPECT_EQ("-042", format("{0:#o}", -042ll));
841 EXPECT_EQ("42", format("{0:#}", 42ull));
842 EXPECT_EQ("0x42", format("{0:#x}", 0x42ull));
843 EXPECT_EQ("042", format("{0:#o}", 042ull));
845 EXPECT_EQ("-42.0000", format("{0:#}", -42.0));
846 EXPECT_EQ("-42.0000", format("{0:#}", -42.0l));
847 EXPECT_THROW_MSG(format("{0:#", 'c'),
848 FormatError, "missing '}' in format string");
849 EXPECT_THROW_MSG(format("{0:#}", 'c'),
850 FormatError, "invalid format specifier for char");
851 EXPECT_THROW_MSG(format("{0:#}", "abc"),
852 FormatError, "format specifier '#' requires numeric argument");
853 EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),
854 FormatError, "format specifier '#' requires numeric argument");
858 EXPECT_EQ("42", format("{0:0}", 42));
859 EXPECT_EQ("-0042", format("{0:05}", -42));
860 EXPECT_EQ("00042", format("{0:05}", 42u));
861 EXPECT_EQ("-0042", format("{0:05}", -42l));
862 EXPECT_EQ("00042", format("{0:05}", 42ul));
863 EXPECT_EQ("-0042", format("{0:05}", -42ll));
864 EXPECT_EQ("00042", format("{0:05}", 42ull));
865 EXPECT_EQ("-0042", format("{0:05}", -42.0));
866 EXPECT_EQ("-0042", format("{0:05}", -42.0l));
867 EXPECT_THROW_MSG(format("{0:0", 'c'),
868 FormatError, "missing '}' in format string");
869 EXPECT_THROW_MSG(format("{0:05}", 'c'),
870 FormatError, "invalid format specifier for char");
871 EXPECT_THROW_MSG(format("{0:05}", "abc"),
872 FormatError, "format specifier '0' requires numeric argument");
873 EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),
874 FormatError, "format specifier '0' requires numeric argument");
881 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
885 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
888 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
890 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
891 EXPECT_EQ(" -42", format("{0:4}", -42));
892 EXPECT_EQ(" 42", format("{0:5}", 42u));
893 EXPECT_EQ(" -42", format("{0:6}", -42l));
894 EXPECT_EQ(" 42", format("{0:7}", 42ul));
895 EXPECT_EQ(" -42", format("{0:6}", -42ll));
896 EXPECT_EQ(" 42", format("{0:7}", 42ull));
897 EXPECT_EQ(" -1.23", format("{0:8}", -1.23));
898 EXPECT_EQ(" -1.23", format("{0:9}", -1.23l));
899 EXPECT_EQ(" 0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe)));
900 EXPECT_EQ("x ", format("{0:11}", 'x'));
901 EXPECT_EQ("str ", format("{0:12}", "str"));
908 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
912 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
915 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
917 EXPECT_THROW_MSG(format("{0:{", 0),
918 FormatError, "invalid format string");
919 EXPECT_THROW_MSG(format("{0:{}", 0),
921 EXPECT_THROW_MSG(format("{0:{?}}", 0),
922 FormatError, "invalid format string");
923 EXPECT_THROW_MSG(format("{0:{1}}", 0),
926 EXPECT_THROW_MSG(format("{0:{0:}}", 0),
927 FormatError, "invalid format string");
929 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1),
931 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1u)),
933 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l),
937 EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)),
940 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1ul)),
943 EXPECT_THROW_MSG(format("{0:{1}}", 0, '0'),
945 EXPECT_THROW_MSG(format("{0:{1}}", 0, 0.0),
948 EXPECT_EQ(" -42", format("{0:{1}}", -42, 4));
949 EXPECT_EQ(" 42", format("{0:{1}}", 42u, 5));
950 EXPECT_EQ(" -42", format("{0:{1}}", -42l, 6));
951 EXPECT_EQ(" 42", format("{0:{1}}", 42ul, 7));
952 EXPECT_EQ(" -42", format("{0:{1}}", -42ll, 6));
953 EXPECT_EQ(" 42", format("{0:{1}}", 42ull, 7));
954 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23, 8));
955 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23l, 9));
957 format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
958 EXPECT_EQ("x ", format("{0:{1}}", 'x', 11));
959 EXPECT_EQ("str ", format("{0:{1}}", "str", 12));
966 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
970 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
973 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
975 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
977 EXPECT_THROW_MSG(format("{0:.", 0),
979 EXPECT_THROW_MSG(format("{0:.}", 0),
982 EXPECT_THROW_MSG(format("{0:.2", 0),
983 FormatError, "precision not allowed in integer format specifier");
984 EXPECT_THROW_MSG(format("{0:.2}", 42),
985 FormatError, "precision not allowed in integer format specifier");
986 EXPECT_THROW_MSG(format("{0:.2f}", 42),
987 FormatError, "precision not allowed in integer format specifier");
988 EXPECT_THROW_MSG(format("{0:.2}", 42u),
989 FormatError, "precision not allowed in integer format specifier");
990 EXPECT_THROW_MSG(format("{0:.2f}", 42u),
991 FormatError, "precision not allowed in integer format specifier");
992 EXPECT_THROW_MSG(format("{0:.2}", 42l),
993 FormatError, "precision not allowed in integer format specifier");
994 EXPECT_THROW_MSG(format("{0:.2f}", 42l),
995 FormatError, "precision not allowed in integer format specifier");
996 EXPECT_THROW_MSG(format("{0:.2}", 42ul),
997 FormatError, "precision not allowed in integer format specifier");
998 EXPECT_THROW_MSG(format("{0:.2f}", 42ul),
999 FormatError, "precision not allowed in integer format specifier");
1000 EXPECT_THROW_MSG(format("{0:.2}", 42ll),
1001 FormatError, "precision not allowed in integer format specifier");
1002 EXPECT_THROW_MSG(format("{0:.2f}", 42ll),
1003 FormatError, "precision not allowed in integer format specifier");
1004 EXPECT_THROW_MSG(format("{0:.2}", 42ull),
1005 FormatError, "precision not allowed in integer format specifier");
1006 EXPECT_THROW_MSG(format("{0:.2f}", 42ull),
1007 FormatError, "precision not allowed in integer format specifier");
1008 EXPECT_THROW_MSG(format("{0:3.0}", 'x'),
1009 FormatError, "precision not allowed in integer format specifier");
1010 EXPECT_EQ("1.2", format("{0:.2}", 1.2345));
1011 EXPECT_EQ("1.2", format("{0:.2}", 1.2345l));
1013 EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)),
1014 FormatError, "precision not allowed in pointer format specifier");
1015 EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)),
1016 FormatError, "precision not allowed in pointer format specifier");
1018 EXPECT_EQ("st", format("{0:.2}", "str"));
1025 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
1029 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
1032 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");
1034 EXPECT_THROW_MSG(format("{0:.{", 0),
1035 FormatError, "invalid format string");
1036 EXPECT_THROW_MSG(format("{0:.{}", 0),
1038 EXPECT_THROW_MSG(format("{0:.{?}}", 0),
1039 FormatError, "invalid format string");
1040 EXPECT_THROW_MSG(format("{0:.{1}", 0, 0),
1041 FormatError, "precision not allowed in integer format specifier");
1042 EXPECT_THROW_MSG(format("{0:.{1}}", 0),
1045 EXPECT_THROW_MSG(format("{0:.{0:}}", 0),
1046 FormatError, "invalid format string");
1048 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1),
1050 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)),
1052 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),
1056 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),
1059 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)),
1062 EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'),
1064 EXPECT_THROW_MSG(format("{0:.{1}}", 0, 0.0),
1067 EXPECT_THROW_MSG(format("{0:.{1}}", 42, 2),
1068 FormatError, "precision not allowed in integer format specifier");
1069 EXPECT_THROW_MSG(format("{0:.{1}f}", 42, 2),
1070 FormatError, "precision not allowed in integer format specifier");
1071 EXPECT_THROW_MSG(format("{0:.{1}}", 42u, 2),
1072 FormatError, "precision not allowed in integer format specifier");
1073 EXPECT_THROW_MSG(format("{0:.{1}f}", 42u, 2),
1074 FormatError, "precision not allowed in integer format specifier");
1075 EXPECT_THROW_MSG(format("{0:.{1}}", 42l, 2),
1076 FormatError, "precision not allowed in integer format specifier");
1077 EXPECT_THROW_MSG(format("{0:.{1}f}", 42l, 2),
1078 FormatError, "precision not allowed in integer format specifier");
1079 EXPECT_THROW_MSG(format("{0:.{1}}", 42ul, 2),
1080 FormatError, "precision not allowed in integer format specifier");
1081 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ul, 2),
1082 FormatError, "precision not allowed in integer format specifier");
1083 EXPECT_THROW_MSG(format("{0:.{1}}", 42ll, 2),
1084 FormatError, "precision not allowed in integer format specifier");
1085 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ll, 2),
1086 FormatError, "precision not allowed in integer format specifier");
1087 EXPECT_THROW_MSG(format("{0:.{1}}", 42ull, 2),
1088 FormatError, "precision not allowed in integer format specifier");
1089 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ull, 2),
1090 FormatError, "precision not allowed in integer format specifier");
1091 EXPECT_THROW_MSG(format("{0:3.{1}}", 'x', 0),
1092 FormatError, "precision not allowed in integer format specifier");
1093 EXPECT_EQ("1.2", format("{0:.{1}}", 1.2345, 2));
1094 EXPECT_EQ("1.2", format("{1:.{0}}", 2, 1.2345l));
1096 EXPECT_THROW_MSG(format("{0:.{1}}", reinterpret_cast<void*>(0xcafe), 2),
1097 FormatError, "precision not allowed in pointer format specifier");
1098 EXPECT_THROW_MSG(format("{0:.{1}f}", reinterpret_cast<void*>(0xcafe), 2),
1099 FormatError, "precision not allowed in pointer format specifier");
1101 EXPECT_EQ("st", format("{0:.{1}}", "str", 2));
1114 safe_sprintf(message, "unknown format code '%c' for %s", c, type_name);
1116 safe_sprintf(message, "unknown format code '\\x%02x' for %s", c,
1119 EXPECT_THROW_MSG(format(format_str, value), FormatError, message)
1125 EXPECT_EQ("true", format("{}", true));
1126 EXPECT_EQ("false", format("{}", false));
1127 EXPECT_EQ("1", format("{:d}", true));
1128 EXPECT_EQ("true ", format("{:5}", true));
1129 EXPECT_EQ(L"true", format(L"{}", true));
1134 EXPECT_EQ("42", format("{0:d}", s));
1136 EXPECT_EQ("42", format("{0:d}", us));
1140 EXPECT_THROW_MSG(format("{0:v", 42),
1141 FormatError, "missing '}' in format string");
1146 EXPECT_EQ("0", format("{0:b}", 0));
1147 EXPECT_EQ("101010", format("{0:b}", 42));
1148 EXPECT_EQ("101010", format("{0:b}", 42u));
1149 EXPECT_EQ("-101010", format("{0:b}", -42));
1150 EXPECT_EQ("11000000111001", format("{0:b}", 12345));
1151 EXPECT_EQ("10010001101000101011001111000", format("{0:b}", 0x12345678));
1152 EXPECT_EQ("10010000101010111100110111101111", format("{0:b}", 0x90ABCDEF));
1154 format("{0:b}", std::numeric_limits<uint32_t>::max()));
1158 EXPECT_EQ("0", format("{0}", 0));
1159 EXPECT_EQ("42", format("{0}", 42));
1160 EXPECT_EQ("42", format("{0:d}", 42));
1161 EXPECT_EQ("42", format("{0}", 42u));
1162 EXPECT_EQ("-42", format("{0}", -42));
1163 EXPECT_EQ("12345", format("{0}", 12345));
1164 EXPECT_EQ("67890", format("{0}", 67890));
1167 EXPECT_EQ(buffer, format("{0}", INT_MIN));
1169 EXPECT_EQ(buffer, format("{0}", INT_MAX));
1171 EXPECT_EQ(buffer, format("{0}", UINT_MAX));
1173 EXPECT_EQ(buffer, format("{0}", LONG_MIN));
1175 EXPECT_EQ(buffer, format("{0}", LONG_MAX));
1177 EXPECT_EQ(buffer, format("{0}", ULONG_MAX));
1181 EXPECT_EQ("0", format("{0:x}", 0));
1182 EXPECT_EQ("42", format("{0:x}", 0x42));
1183 EXPECT_EQ("42", format("{0:x}", 0x42u));
1184 EXPECT_EQ("-42", format("{0:x}", -0x42));
1185 EXPECT_EQ("12345678", format("{0:x}", 0x12345678));
1186 EXPECT_EQ("90abcdef", format("{0:x}", 0x90abcdef));
1187 EXPECT_EQ("12345678", format("{0:X}", 0x12345678));
1188 EXPECT_EQ("90ABCDEF", format("{0:X}", 0x90ABCDEF));
1192 EXPECT_EQ(buffer, format("{0:x}", INT_MIN));
1194 EXPECT_EQ(buffer, format("{0:x}", INT_MAX));
1196 EXPECT_EQ(buffer, format("{0:x}", UINT_MAX));
1198 EXPECT_EQ(buffer, format("{0:x}", LONG_MIN));
1200 EXPECT_EQ(buffer, format("{0:x}", LONG_MAX));
1202 EXPECT_EQ(buffer, format("{0:x}", ULONG_MAX));
1206 EXPECT_EQ("0", format("{0:o}", 0));
1207 EXPECT_EQ("42", format("{0:o}", 042));
1208 EXPECT_EQ("42", format("{0:o}", 042u));
1209 EXPECT_EQ("-42", format("{0:o}", -042));
1210 EXPECT_EQ("12345670", format("{0:o}", 012345670));
1213 EXPECT_EQ(buffer, format("{0:o}", INT_MIN));
1215 EXPECT_EQ(buffer, format("{0:o}", INT_MAX));
1217 EXPECT_EQ(buffer, format("{0:o}", UINT_MAX));
1219 EXPECT_EQ(buffer, format("{0:o}", LONG_MIN));
1221 EXPECT_EQ(buffer, format("{0:o}", LONG_MAX));
1223 EXPECT_EQ(buffer, format("{0:o}", ULONG_MAX));
1232 EXPECT_EQ("123", format("{:n}", 123));
1233 EXPECT_EQ("1--234", format("{:n}", 1234));
1234 EXPECT_EQ("1--234--567", format("{:n}", 1234567));
1238 EXPECT_EQ("392.500000", format("{0:f}", 392.5f));
1243 EXPECT_EQ("0", format("{0:}", 0.0));
1244 EXPECT_EQ("0.000000", format("{0:f}", 0.0));
1245 EXPECT_EQ("392.65", format("{0:}", 392.65));
1246 EXPECT_EQ("392.65", format("{0:g}", 392.65));
1247 EXPECT_EQ("392.65", format("{0:G}", 392.65));
1248 EXPECT_EQ("392.650000", format("{0:f}", 392.65));
1249 EXPECT_EQ("392.650000", format("{0:F}", 392.65));
1252 EXPECT_EQ(buffer, format("{0:e}", 392.65));
1254 EXPECT_EQ(buffer, format("{0:E}", 392.65));
1255 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.65));
1257 EXPECT_EQ(buffer, format("{:a}", -42.0));
1259 EXPECT_EQ(buffer, format("{:A}", -42.0));
1264 EXPECT_EQ("nan", format("{}", nan));
1265 EXPECT_EQ("+nan", format("{:+}", nan));
1266 EXPECT_EQ(" nan", format("{: }", nan));
1267 EXPECT_EQ("NAN", format("{:F}", nan));
1268 EXPECT_EQ("nan ", format("{:<7}", nan));
1269 EXPECT_EQ(" nan ", format("{:^7}", nan));
1270 EXPECT_EQ(" nan", format("{:>7}", nan));
1275 EXPECT_EQ("inf", format("{}", inf));
1276 EXPECT_EQ("+inf", format("{:+}", inf));
1277 EXPECT_EQ("-inf", format("{}", -inf));
1278 EXPECT_EQ(" inf", format("{: }", inf));
1279 EXPECT_EQ("INF", format("{:F}", inf));
1280 EXPECT_EQ("inf ", format("{:<7}", inf));
1281 EXPECT_EQ(" inf ", format("{:^7}", inf));
1282 EXPECT_EQ(" inf", format("{:>7}", inf));
1286 EXPECT_EQ("0", format("{0:}", 0.0l));
1287 EXPECT_EQ("0.000000", format("{0:f}", 0.0l));
1288 EXPECT_EQ("392.65", format("{0:}", 392.65l));
1289 EXPECT_EQ("392.65", format("{0:g}", 392.65l));
1290 EXPECT_EQ("392.65", format("{0:G}", 392.65l));
1291 EXPECT_EQ("392.650000", format("{0:f}", 392.65l));
1292 EXPECT_EQ("392.650000", format("{0:F}", 392.65l));
1295 EXPECT_EQ(buffer, format("{0:e}", 392.65l));
1296 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.64l));
1302 EXPECT_EQ("a", format("{0}", 'a'));
1303 EXPECT_EQ("z", format("{0:c}", 'z'));
1304 EXPECT_EQ(L"a", format(L"{0}", 'a'));
1307 std::string format_str = fmt::format("{{:{}}}", *type);
1308 EXPECT_EQ(fmt::format(format_str, n), fmt::format(format_str, 'x'));
1310 EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
1314 EXPECT_EQ("42", format("{}", static_cast<unsigned char>(42)));
1315 EXPECT_EQ("42", format("{}", static_cast<uint8_t>(42)));
1319 EXPECT_EQ(L"a", format(L"{0}", L'a'));
1321 //format("{}", L'a');
1326 EXPECT_EQ("test", format("{0}", "test"));
1327 EXPECT_EQ("test", format("{0:s}", "test"));
1329 EXPECT_EQ("nonconst", format("{0}", nonconst));
1330 EXPECT_THROW_MSG(format("{0}", reinterpret_cast<const char*>(0)),
1336 EXPECT_EQ("test", format("{0:s}", str));
1338 EXPECT_EQ("test", format("{0:s}", const_str));
1343 EXPECT_EQ("test", format("{0:s}", str));
1345 EXPECT_EQ("test", format("{0:s}", const_str));
1347 EXPECT_EQ("test", format("{0:s}", ptr));
1352 EXPECT_EQ("0x0", format("{0}", reinterpret_cast<void*>(0)));
1353 EXPECT_EQ("0x1234", format("{0}", reinterpret_cast<void*>(0x1234)));
1354 EXPECT_EQ("0x1234", format("{0:p}", reinterpret_cast<void*>(0x1234)));
1356 format("{0}", reinterpret_cast<void*>(~uintptr_t())));
1360 EXPECT_EQ("test", format("{0}", std::string("test")));
1364 EXPECT_EQ("test", format("{0}", StringRef("test")));
1368 EXPECT_EQ("test", format("{0}", CStringRef("test")));
1377 EXPECT_THROW_MSG(fmt::format("{:s}", date), FormatError,
1378 "unmatched '}' in format string");
1389 EXPECT_EQ("42", format("{0}", Answer()));
1393 EXPECT_EQ(L"42", format(L"{}", 42));
1394 EXPECT_EQ(L"4.2", format(L"{}", 4.2));
1395 EXPECT_EQ(L"abc", format(L"{}", L"abc"));
1396 EXPECT_EQ(L"z", format(L"{}", L'z'));
1401 format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%",
1409 std::string message = format("The answer is {}", 42);
1412 EXPECT_EQ("42", format("{}", 42));
1413 EXPECT_EQ("42", format(std::string("{}"), 42));
1443 format("First, thou shalt count to {0}", "three"));
1445 format("Bring me a {}", "shrubbery"));
1446 EXPECT_EQ("From 1 to 3", format("From {} to {}", 1, 3));
1450 EXPECT_EQ(buffer, format("{:03.2f}", -1.2));
1452 EXPECT_EQ("a, b, c", format("{0}, {1}, {2}", 'a', 'b', 'c'));
1453 EXPECT_EQ("a, b, c", format("{}, {}, {}", 'a', 'b', 'c'));
1454 EXPECT_EQ("c, b, a", format("{2}, {1}, {0}", 'a', 'b', 'c'));
1455 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
1458 format("{:<30}", "left aligned"));
1460 format("{:>30}", "right aligned"));
1462 format("{:^30}", "centered"));
1464 format("{:*^30}", "centered"));
1467 format("{:+f}; {:+f}", 3.14, -3.14));
1469 format("{: f}; {: f}", 3.14, -3.14));
1471 format("{:-f}; {:-f}", 3.14, -3.14));
1474 format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42));
1476 format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42));
1478 EXPECT_EQ("The answer is 42", format("The answer is {}", 42));
1480 format("The answer is {:d}", "forty-two"), FormatError,
1481 "unknown format code 'd' for string");
1484 format(L"Cyrillic letter {}", L'\x42e'));
1551 EXPECT_EQ("abc1", format("{}c{}", "ab", 1));
1552 EXPECT_EQ(L"abc1", format(L"{}c{}", L"ab", 1));
1557 return fmt::format("{}", value);
1566 std::string format_message(int id, const char *format,
1570 w.write(format, args);
1583 void print_error(const char *file, int line, const char *format,
1586 fmt::print(format, args...);
1592 fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1605 EXPECT_EQ(format("{}c{}", "ab", 1), udl_format);
1607 EXPECT_EQ(format(L"{}c{}", L"ab", 1), udl_format_w);
1611 auto udl_a = format("{first}{second}{first}{third}",
1613 EXPECT_EQ(format("{first}{second}{first}{third}",
1617 auto udl_a_w = format(L"{first}{second}{first}{third}",
1619 EXPECT_EQ(format(L"{first}{second}{first}{third}",
1629 EXPECT_EQ("0", fmt::format("{}", A));
1649 formatter.format(format_str);
1661 fmt::format("{}", 42);