[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

90

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

186–187

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

90

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

66–68

@gchatelet will be happy about this change :)

180–181

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

[sivachandra]

libc/utils/UnitTest/Test.h

180–181

Indeed!

[gchatelet]

Thx!

libc/utils/UnitTest/Test.h

66–68

woohoo \O/

libc/utils/CPP/TypeTraits.h

 template <> struct IsIntegral<int> : public TrueValue {};
 template <> struct IsIntegral<unsigned int> : public TrueValue {};
 template <> struct IsIntegral<long> : public TrueValue {};
 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 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:
 
   // We make use of a template function, with |LHS| and |RHS| as explicit
   // 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>
+  template <typename ValType,
+            cpp::EnableIfType<cpp::IsIntegral<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);
   }
 
   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);
 
 private:
   virtual void Run(RunContext &Ctx) = 0;
   virtual const char *getName() const = 0;
 
   static Test *Start;
   static Test *End;
 };
#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) EXPECT_EQ((VAL), true)
+
+#define ASSERT_TRUE(VAL)                                                       \
+  if (!EXPECT_TRUE(VAL))                                                       \
+  return
+
+#define EXPECT_FALSE(VAL) EXPECT_EQ((VAL), false)
+
+#define ASSERT_FALSE(VAL)                                                      \
+  if (!EXPECT_FALSE(VAL))                                                      \
+  return

libc/utils/UnitTest/Test.cpp

template bool Test::test<unsigned int, 0>(RunContext &Ctx, TestCondition Cond,
                                           unsigned long Line);
 
 template bool Test::test<unsigned long, 0>(RunContext &Ctx, TestCondition Cond,
                                            unsigned long LHS, unsigned long RHS,
                                            const char *LHSStr,
                                            const char *RHSStr, const char *File,
                                            unsigned long Line);
 
+template bool Test::test<bool, 0>(RunContext &Ctx, TestCondition Cond, bool LHS,
+                                  bool RHS, const char *LHSStr,
+                                  const char *RHSStr, const char *File,
+                                  unsigned long Line);
+
 template bool Test::test<unsigned long long, 0>(
     RunContext &Ctx, TestCondition Cond, unsigned long long LHS,
     unsigned long long RHS, const char *LHSStr, const char *RHSStr,
     const char *File, unsigned long Line);
 
 bool Test::testStrEq(RunContext &Ctx, const char *LHS, const char *RHS,
                      const char *LHSStr, const char *RHSStr, const char *File,
                      unsigned long Line) {