Example of use of TYPED_TEST - Not to be submitted

[gchatelet]

• Add documentation, split forward / backward tests

libc/test/src/string/strchr_test.cpp

 //===-- Unittests for strchr ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/string/strchr.h"
 #include "test/UnitTest/Test.h"
 
-TEST(LlvmLibcStrChrTest, FindsFirstCharacter) {
+///////////////////////////////////////////////////////////////////////////////
+// Implementations should be included but are inlined here for convenience.
+template <bool ReturnNull = true>
+constexpr static char *strchr_implementation(const char *src, int c) {
+  char ch = static_cast<char>(c);
+  for (; *src && *src != ch; ++src)
+    ;
+  char *ret = ReturnNull ? nullptr : const_cast<char *>(src);
+  return *src == ch ? const_cast<char *>(src) : ret;
+}
+
+constexpr static char *strrchr_implementation(const char *src, int c) {
+  char ch = static_cast<char>(c);
+  char *last_occurrence = nullptr;
+  for (; *src; ++src) {
+    if (*src == ch)
+      last_occurrence = const_cast<char *>(src);
+  }
+  return last_occurrence;
+}
+
+char *strchr(const char *src, int c) { return strchr_implementation(src, c); }
+char *strrchr(const char *src, int c) { return strrchr_implementation(src, c); }
+char *index(const char *src, int c) { return strchr_implementation(src, c); }
+char *rindex(const char *src, int c) { return strrchr_implementation(src, c); }
+///////////////////////////////////////////////////////////////////////////////
+
+// A simple wrapper to map from type to function.
+template <auto Function> struct Wrapper {
+  static char *foo(const char *src, int c) { return Function(src, c); }
+};
+
+namespace __llvm_libc {
+
+using ForwardFunctions = testing::TypeList<Wrapper<strchr>, Wrapper<index>>;
+using BackwardFunctions = testing::TypeList<Wrapper<strrchr>, Wrapper<rindex>>;
+using AllFunctions = testing::TypeList<Wrapper<strchr>, Wrapper<strrchr>,
+                                       Wrapper<index>, Wrapper<rindex>>;
+
+TYPED_TEST(LlvmLibcStrChrTest, FindsFirstCharacter, AllFunctions) {
   const char *src = "abcde";
 
   // Should return original string since 'a' is the first character.
-  ASSERT_STREQ(__llvm_libc::strchr(src, 'a'), "abcde");
+  ASSERT_STREQ(ParamType::foo(src, 'a'), "abcde");
   // Source string should not change.
   ASSERT_STREQ(src, "abcde");
 }
 
-TEST(LlvmLibcStrChrTest, FindsMiddleCharacter) {
+TYPED_TEST(LlvmLibcStrChrTest, FindsMiddleCharacter, AllFunctions) {
   const char *src = "abcde";
 
   // Should return characters after (and including) 'c'.
-  ASSERT_STREQ(__llvm_libc::strchr(src, 'c'), "cde");
+  ASSERT_STREQ(ParamType::foo(src, 'c'), "cde");
   // Source string should not change.
   ASSERT_STREQ(src, "abcde");
 }
 
-TEST(LlvmLibcStrChrTest, FindsLastCharacterThatIsNotNullTerminator) {
+TYPED_TEST(LlvmLibcStrChrTest, FindsLastCharacterThatIsNotNullTerminator,
+           AllFunctions) {
   const char *src = "abcde";
 
   // Should return 'e' and null-terminator.
-  ASSERT_STREQ(__llvm_libc::strchr(src, 'e'), "e");
+  ASSERT_STREQ(ParamType::foo(src, 'e'), "e");
   // Source string should not change.
   ASSERT_STREQ(src, "abcde");
 }
 
-TEST(LlvmLibcStrChrTest, FindsNullTerminator) {
+TYPED_TEST(LlvmLibcStrChrTest, FindsNullTerminator, AllFunctions) {
   const char *src = "abcde";
 
   // Should return null terminator.
-  ASSERT_STREQ(__llvm_libc::strchr(src, '\0'), "");
+  ASSERT_STREQ(ParamType::foo(src, '\0'), "");
   // Source string should not change.
   ASSERT_STREQ(src, "abcde");
 }
 
-TEST(LlvmLibcStrChrTest, CharacterNotWithinStringShouldReturnNullptr) {
+TYPED_TEST(LlvmLibcStrChrTest, CharacterNotWithinStringShouldReturnNullptr,
+           AllFunctions) {
   // Since 'z' is not within the string, should return nullptr.
-  ASSERT_STREQ(__llvm_libc::strchr("123?", 'z'), nullptr);
+  ASSERT_STREQ(ParamType::foo("123?", 'z'), nullptr);
 }
 
-TEST(LlvmLibcStrChrTest, TheSourceShouldNotChange) {
+TYPED_TEST(LlvmLibcStrChrTest, TheSourceShouldNotChange, AllFunctions) {
   const char *src = "abcde";
   // When the character is found, the source string should not change.
-  __llvm_libc::strchr(src, 'd');
+  ParamType::foo(src, 'd');
   ASSERT_STREQ(src, "abcde");
   // Same case for when the character is not found.
-  __llvm_libc::strchr(src, 'z');
+  ParamType::foo(src, 'z');
   ASSERT_STREQ(src, "abcde");
   // Same case for when looking for null terminator.
-  __llvm_libc::strchr(src, '\0');
+  ParamType::foo(src, '\0');
   ASSERT_STREQ(src, "abcde");
 }
 
-TEST(LlvmLibcStrChrTest, ShouldFindFirstOfDuplicates) {
+TYPED_TEST(LlvmLibcStrChrTest, ShouldFindFirstOfDuplicates, ForwardFunctions) {
   // '1' is duplicated in the string, but it should find the first copy.
-  ASSERT_STREQ(__llvm_libc::strchr("abc1def1ghi", '1'), "1def1ghi");
+  ASSERT_STREQ(ParamType::foo("abc1def1ghi", '1'), "1def1ghi");
 
   const char *dups = "XXXXX";
   // Should return original string since 'X' is the first character.
-  ASSERT_STREQ(__llvm_libc::strchr(dups, 'X'), dups);
+  ASSERT_STREQ(ParamType::foo(dups, 'X'), dups);
 }
 
-TEST(LlvmLibcStrChrTest, EmptyStringShouldOnlyMatchNullTerminator) {
+TYPED_TEST(LlvmLibcStrChrTest, EmptyStringShouldOnlyMatchNullTerminator,
+           AllFunctions) {
   // Null terminator should match.
-  ASSERT_STREQ(__llvm_libc::strchr("", '\0'), "");
+  ASSERT_STREQ(ParamType::foo("", '\0'), "");
   // All other characters should not match.
-  ASSERT_STREQ(__llvm_libc::strchr("", 'Z'), nullptr);
-  ASSERT_STREQ(__llvm_libc::strchr("", '3'), nullptr);
-  ASSERT_STREQ(__llvm_libc::strchr("", '*'), nullptr);
+  ASSERT_STREQ(ParamType::foo("", 'Z'), nullptr);
+  ASSERT_STREQ(ParamType::foo("", '3'), nullptr);
+  ASSERT_STREQ(ParamType::foo("", '*'), nullptr);
 }
+
+} // namespace __llvm_libc