@@ -8,8 +8,13 @@
 #include "GUnit/GAssert.h"
 
 int main() {
+  const auto b = true;
   const auto i = 42;
+
+  EXPECT(true);
+  EXPECT(b);
   EXPECT(42 == i);
   EXPECT(42 >= 0) << "message";
+
   ASSERT(42.0 == 42.);
 }
@@ -53,15 +53,26 @@ class msg : public decltype(Message()) {
 
 class op {
   template <class TLhs>
-  class comp {
+  class comp : public decltype(Message()) {
    public:
     explicit comp(const info& info, const TLhs& lhs) : info_{info}, lhs_{lhs} {}
+    ~comp() {
+      if (!followed_ && std::is_same<bool, TLhs>::value) {
+        const AssertionResult gtest_ar =
+            (internal::CmpHelperEQ(info_.expr.c_str(), "true", lhs_, true));
+        if (!gtest_ar) {
+          internal::AssertHelper(info_.failure, info_.file, info_.line,
+                                 gtest_ar.failure_message()) = *this;
+        }
+      }
+    }
 
     template <class TRhs,
               std::enable_if_t<std::is_floating_point<TLhs>::value ||
                                    std::is_floating_point<TRhs>::value,
                                int> = 0>
     auto operator==(const TRhs& rhs) const {
+      followed_ = true;
       return msg<TLhs, TRhs, internal::CmpHelperFloatingPointEQ<TLhs>>{
           info_, "==", lhs_, rhs};
     }
@@ -71,43 +82,50 @@ class op {
                                    !std::is_floating_point<TRhs>::value,
                                int> = 0>
     auto operator==(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperEQ>{
           info_, "==", lhs_, rhs};
     }
 
     template <class TRhs>
     auto operator!=(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperNE>{
           info_, "!=", lhs_, rhs};
     }
 
     template <class TRhs>
     auto operator>(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperGT>{info_, ">",
                                                                   lhs_, rhs};
     }
 
     template <class TRhs>
     auto operator>=(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperGE>{
           info_, ">=", lhs_, rhs};
     }
 
     template <class TRhs>
     auto operator<=(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperLE>{
           info_, "<=", lhs_, rhs};
     }
 
     template <class TRhs>
     auto operator<(const TRhs& rhs) const {
+      followed_ = true;
       return msg<const TLhs&, const TRhs&, internal::CmpHelperLT>{info_, "<",
                                                                   lhs_, rhs};
     }
 
    private:
     info info_{};
     TLhs lhs_{};
+    mutable bool followed_{false};
   };
 
  public:
 
@@ -388,7 +388,7 @@ class Steps : public ::testing::EmptyTestEventListener {
     return Step<-1, true>{*this, {"Then", File::c_str(), line}, pattern};
   }
 
-  // clang-format off
+// clang-format off
   #if defined(__clang__)
   #pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"
   #endif
 
@@ -10,6 +10,11 @@
 
 TEST(GAssert, ShouldSupportExpect) {
   auto i = 42;
+  const auto b = true;
+
+  EXPECT(true);
+  EXPECT(!false) << "message";
+  EXPECT(b);
 
   EXPECT(i == 42);
   EXPECT(42 == i);
@@ -27,7 +32,9 @@ TEST(GAssert, ShouldSupportExpect) {
 }
 
 TEST(GAssert, ShouldSupportASSERT) {
-  auto i = 42;
+  const auto i = 42;
+
+  ASSERT(true);
 
   ASSERT(i == 42);
   ASSERT(42 == i);
Original file line number	Diff line number	Diff line change
`@@ -388,7 +388,7 @@ class Steps : public ::testing::EmptyTestEventListener {`
`388`	`388`	`return Step<-1, true>{*this, {"Then", File::c_str(), line}, pattern};`
`389`	`389`	`}`
`390`	`390`
`391`		`- // clang-format off`
	`391`	`+// clang-format off`
`392`	`392`	`#if defined(__clang__)`
`393`	`393`	`#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"`
`394`	`394`	`#endif`