Export of internal Abseil changes.

--
70f43a482d7d4ae4a255f17ca02b0106653dd600 by Shaindel Schwartz <shaindel@google.com>:

Internal change

PiperOrigin-RevId: 201571193

--
93e6e9c2e683158be49d9dd1f5cb1a91d0c0f556 by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 201567108

--
fbd8ee94fbe9f2448e5adf5e88706f9c8216048f by Juemin Yang <jueminyang@google.com>:

str_format release

PiperOrigin-RevId: 201565129

--
387faa301555a8a888c4429df52734aa806dca46 by Abseil Team <absl-team@google.com>:

Adds a defaulted allocator parameter to the size_type constructor of InlinedVector

PiperOrigin-RevId: 201558711

--
39b15ea2c68d7129d70cbde7e71af900032595ec by Matt Calabrese <calabrese@google.com>:

Update the variant implementation to eliminate unnecessary checking on alternative access when the index is known or required to be correct.

PiperOrigin-RevId: 201529535

--
adab77f1f7bb363aa534297f22aae2b0f08889ea by Abseil Team <absl-team@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 201458388

--
a701dc0ba62e3cadf0de14203415b91df4ee8151 by Greg Falcon <gfalcon@google.com>:

Internal cleanup

PiperOrigin-RevId: 201394836

--
8a7191410b8f440fdfa27f722ff05e451502ab61 by Abseil Team <absl-team@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 201369269
GitOrigin-RevId: 70f43a482d7d4ae4a255f17ca02b0106653dd600
Change-Id: I8ab073b30b4e27405a3b6da2c826bb4f3f0b9af6

1 files changed, 150 insertions, 0 deletions

diff --git a/absl/strings/internal/str_format/checker_test.cc b/absl/strings/internal/str_format/checker_test.cc
new file mode 100644
index 0000000..14d11ea
--- /dev/null
+++ b/absl/strings/internal/str_format/checker_test.cc
@@ -0,0 +1,150 @@
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/strings/str_format.h"
+
+namespace absl {
+namespace str_format_internal {
+namespace {
+
+std::string ConvToString(Conv conv) {
+  std::string out;
+#define CONV_SET_CASE(c) \
+  if (Contains(conv, Conv::c)) out += #c;
+  ABSL_CONVERSION_CHARS_EXPAND_(CONV_SET_CASE, )
+#undef CONV_SET_CASE
+  if (Contains(conv, Conv::star)) out += "*";
+  return out;
+}
+
+TEST(StrFormatChecker, ArgumentToConv) {
+  Conv conv = ArgumentToConv<std::string>();
+  EXPECT_EQ(ConvToString(conv), "s");
+
+  conv = ArgumentToConv<const char*>();
+  EXPECT_EQ(ConvToString(conv), "sp");
+
+  conv = ArgumentToConv<double>();
+  EXPECT_EQ(ConvToString(conv), "fFeEgGaA");
+
+  conv = ArgumentToConv<int>();
+  EXPECT_EQ(ConvToString(conv), "cdiouxXfFeEgGaA*");
+
+  conv = ArgumentToConv<std::string*>();
+  EXPECT_EQ(ConvToString(conv), "p");
+}
+
+#if ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+struct Case {
+  bool result;
+  const char* format;
+};
+
+template <typename... Args>
+constexpr Case ValidFormat(const char* format) {
+  return {ValidFormatImpl<ArgumentToConv<Args>()...>(format), format};
+}
+
+TEST(StrFormatChecker, ValidFormat) {
+  // We want to make sure these expressions are constexpr and they have the
+  // expected value.
+  // If they are not constexpr the attribute will just ignore them and not give
+  // a compile time error.
+  enum e {};
+  enum class e2 {};
+  constexpr Case trues[] = {
+      ValidFormat<>("abc"),  //
+
+      ValidFormat<e>("%d"),                             //
+      ValidFormat<e2>("%d"),                            //
+      ValidFormat<int>("%% %d"),                        //
+      ValidFormat<int>("%ld"),                          //
+      ValidFormat<int>("%lld"),                         //
+      ValidFormat<std::string>("%s"),                        //
+      ValidFormat<std::string>("%10s"),                      //
+      ValidFormat<int>("%.10x"),                        //
+      ValidFormat<int, int>("%*.3x"),                   //
+      ValidFormat<int>("%1.d"),                         //
+      ValidFormat<int>("%.d"),                          //
+      ValidFormat<int, double>("%d %g"),                //
+      ValidFormat<int, std::string>("%*s"),                  //
+      ValidFormat<int, double>("%.*f"),                 //
+      ValidFormat<void (*)(), volatile int*>("%p %p"),  //
+      ValidFormat<string_view, const char*, double, void*>(
+          "string_view=%s const char*=%s double=%f void*=%p)"),
+
+      ValidFormat<int>("%% %1$d"),            //
+      ValidFormat<int>("%1$ld"),              //
+      ValidFormat<int>("%1$lld"),             //
+      ValidFormat<std::string>("%1$s"),            //
+      ValidFormat<std::string>("%1$10s"),          //
+      ValidFormat<int>("%1$.10x"),            //
+      ValidFormat<int>("%1$*1$.*1$d"),        //
+      ValidFormat<int, int>("%1$*2$.3x"),     //
+      ValidFormat<int>("%1$1.d"),             //
+      ValidFormat<int>("%1$.d"),              //
+      ValidFormat<double, int>("%2$d %1$g"),  //
+      ValidFormat<int, std::string>("%2$*1$s"),    //
+      ValidFormat<int, double>("%2$.*1$f"),   //
+      ValidFormat<void*, string_view, const char*, double>(
+          "string_view=%2$s const char*=%3$s double=%4$f void*=%1$p "
+          "repeat=%3$s)")};
+
+  for (Case c : trues) {
+    EXPECT_TRUE(c.result) << c.format;
+  }
+
+  constexpr Case falses[] = {
+      ValidFormat<int>(""),  //
+
+      ValidFormat<e>("%s"),             //
+      ValidFormat<e2>("%s"),            //
+      ValidFormat<>("%s"),              //
+      ValidFormat<>("%r"),              //
+      ValidFormat<int>("%s"),           //
+      ValidFormat<int>("%.1.d"),        //
+      ValidFormat<int>("%*1d"),         //
+      ValidFormat<int>("%1-d"),         //
+      ValidFormat<std::string, int>("%*s"),  //
+      ValidFormat<int>("%*d"),          //
+      ValidFormat<std::string>("%p"),        //
+      ValidFormat<int (*)(int)>("%d"),  //
+
+      ValidFormat<>("%3$d"),                //
+      ValidFormat<>("%1$r"),                //
+      ValidFormat<int>("%1$s"),             //
+      ValidFormat<int>("%1$.1.d"),          //
+      ValidFormat<int>("%1$*2$1d"),         //
+      ValidFormat<int>("%1$1-d"),           //
+      ValidFormat<std::string, int>("%2$*1$s"),  //
+      ValidFormat<std::string>("%1$p"),
+
+      ValidFormat<int, int>("%d %2$d"),  //
+  };
+
+  for (Case c : falses) {
+    EXPECT_FALSE(c.result) << c.format;
+  }
+}
+
+TEST(StrFormatChecker, LongFormat) {
+#define CHARS_X_40 "1234567890123456789012345678901234567890"
+#define CHARS_X_400                                                            \
+  CHARS_X_40 CHARS_X_40 CHARS_X_40 CHARS_X_40 CHARS_X_40 CHARS_X_40 CHARS_X_40 \
+      CHARS_X_40 CHARS_X_40 CHARS_X_40
+#define CHARS_X_4000                                                      \
+  CHARS_X_400 CHARS_X_400 CHARS_X_400 CHARS_X_400 CHARS_X_400 CHARS_X_400 \
+      CHARS_X_400 CHARS_X_400 CHARS_X_400 CHARS_X_400
+  constexpr char long_format[] =
+      CHARS_X_4000 "%d" CHARS_X_4000 "%s" CHARS_X_4000;
+  constexpr bool is_valid = ValidFormat<int, std::string>(long_format).result;
+  EXPECT_TRUE(is_valid);
+}
+
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+}  // namespace
+}  // namespace str_format_internal
+}  // namespace absl