[libc] Add [EXPECT|ASSERT]_[TRUE|FALSE] unittest macros.

[sivachandra]

Summary

These macros can only be used for values of type bool.

[abrachet]

libc/utils/UnitTest/Test.h

91

This doesn't call internal::test and won't give an error message.

196–197

Will this give an error message that makes sense? I think it will do something like "expected true but was true"

[sivachandra]

libc/utils/UnitTest/Test.h

91

Ah sorry, this was supposed to be a demo patch. I will update this to make it review ready and update soon.

[sivachandra]

Ready for a review.

[sivachandra]

I am convinced (thanks to @gchatelet) that we can safely extend our macros to bool. Some of them, like EXPECT_LE might not be meaningful for bool, but I do not see any reason to make special effort to prevent such uses.

[abrachet]

libc/utils/UnitTest/Test.h

68–69

@gchatelet will be happy about this change :)

190–191

Could we shorten this to EXPECT_EQ(VAL, true)?

[sivachandra]

libc/utils/UnitTest/Test.h

190–191

Indeed!

[gchatelet]

Thx!

libc/utils/UnitTest/Test.h

68–69

woohoo \O/

libc/utils/CPP/TypeTraits.h

 template <> struct IsIntegral<unsigned long> : public TrueValue {};
 template <> struct IsIntegral<long long> : public TrueValue {};
 template <> struct IsIntegral<unsigned long long> : public TrueValue {};
 template <> struct IsIntegral<bool> : public TrueValue {};
 
 template <typename Type> struct IsIntegralNotBool : public IsIntegral<Type> {};
 template <> struct IsIntegralNotBool<bool> : public FalseValue {};
 
+template <typename Type> struct IsBool : public FalseValue {};
+template <> struct IsBool<bool> : public TrueValue {};
+
 template <typename T> struct IsPointerType : public FalseValue {};
 template <typename T> struct IsPointerType<T *> : public TrueValue {};
 
 template <typename T1, typename T2> struct IsSame : public FalseValue {};
 template <typename T> struct IsSame<T, T> : public TrueValue {};
 
 } // namespace cpp
 } // namespace __llvm_libc

libc/utils/UnitTest/Test.h

protected:
   // parameters, for enhanced type checking. Other gtest like unittest
   // frameworks have a similar function which takes a boolean argument
   // instead of the explicit |LHS| and |RHS| arguments. This boolean argument
   // is the result of the |Cond| operation on |LHS| and |RHS|. Though not bad,
   // |Cond| on mismatched |LHS| and |RHS| types can potentially succeed because
   // of type promotion.
   template <
       typename ValType,
       cpp::EnableIfType<cpp::IsIntegralNotBool<ValType>::Value, ValType> = 0>
   static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS,
                    ValType RHS, const char *LHSStr, const char *RHSStr,
                    const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, LHS, RHS, LHSStr, RHSStr, File, Line);
   }
 
   template <
       typename ValType,
       cpp::EnableIfType<cpp::IsPointerType<ValType>::Value, ValType> = nullptr>
   static bool test(RunContext &Ctx, TestCondition Cond, ValType LHS,
                    ValType RHS, const char *LHSStr, const char *RHSStr,
                    const char *File, unsigned long Line) {
     return internal::test(Ctx, Cond, (unsigned long long)LHS,
                           (unsigned long long)RHS, LHSStr, RHSStr, File, Line);
   }
 
+  // Restricting the ValType to bool ensures that only values of type bool
+  // are used with [EXPECT|ASSERT]_[TRUE|FALSE].
+  template <typename ValType,
+            cpp::EnableIfType<cpp::IsBool<ValType>::Value, ValType> = true>
+  static bool testTrue(RunContext &Ctx, ValType Val, const char *ValStr,
+                       const char *File, unsigned long Line) {
+    return Val;
+  }
+
   static bool testStrEq(RunContext &Ctx, const char *LHS, const char *RHS,
                         const char *LHSStr, const char *RHSStr,
                         const char *File, unsigned long Line);
 
   static bool testStrNe(RunContext &Ctx, const char *LHS, const char *RHS,
                         const char *LHSStr, const char *RHSStr,
                         const char *File, unsigned long Line);
 
#define ASSERT_STREQ(LHS, RHS)                                                 \
   return
 
 #define EXPECT_STRNE(LHS, RHS)                                                 \
   __llvm_libc::testing::Test::testStrNe(Ctx, (LHS), (RHS), #LHS, #RHS,         \
                                         __FILE__, __LINE__)
 #define ASSERT_STRNE(LHS, RHS)                                                 \
   if (!EXPECT_STRNE(LHS, RHS))                                                 \
   return
+
+#define EXPECT_TRUE(VAL)                                                       \
+  __llvm_libc::testing::Test::testTrue(Ctx, (VAL), #VAL, __FILE__, __LINE__)
+
+#define ASSERT_TRUE(VAL)                                                       \
+  if (!EXPECT_TRUE(VAL))                                                       \
+  return
+
+#define EXPECT_FALSE(VAL)                                                      \
+  __llvm_libc::testing::Test::testTrue(Ctx, !(VAL), #VAL, __FILE__, __LINE__)
+
+#define ASSERT_FALSE(VAL)                                                      \
+  if (!EXPECT_FALSE(VAL))                                                      \
+  return