// Copyright 2005, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The Google C++ Testing and Mocking Framework (Google Test)

//

// This file implements the AssertionResult type.

// IWYU pragma: private, include "gtest/gtest.h"

// IWYU pragma: friend gtest/.*

// IWYU pragma: friend gmock/.*

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_

#define GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_

#include <memory>

#include <ostream>

#include <string>

#include <type_traits>

#include "gtest/gtest-message.h"

#include "gtest/internal/gtest-port.h"

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251                                   \

/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// A class for indicating whether an assertion was successful.  When

// the assertion wasn't successful, the AssertionResult object

// remembers a non-empty message that describes how it failed.

//

// To create an instance of this class, use one of the factory functions

// (AssertionSuccess() and AssertionFailure()).

//

// This class is useful for two purposes:

//   1. Defining predicate functions to be used with Boolean test assertions

//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts

//   2. Defining predicate-format functions to be

//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).

//

// For example, if you define IsEven predicate:

//

//   testing::AssertionResult IsEven(int n) {

//     if ((n % 2) == 0)

//       return testing::AssertionSuccess();

//     else

//       return testing::AssertionFailure() << n << " is odd";

//   }

//

// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))

// will print the message

//

//   Value of: IsEven(Fib(5))

//     Actual: false (5 is odd)

//   Expected: true

//

// instead of a more opaque

//

//   Value of: IsEven(Fib(5))

//     Actual: false

//   Expected: true

//

// in case IsEven is a simple Boolean predicate.

//

// If you expect your predicate to be reused and want to support informative

// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up

// about half as often as positive ones in our tests), supply messages for

// both success and failure cases:

//

//   testing::AssertionResult IsEven(int n) {

//     if ((n % 2) == 0)

//       return testing::AssertionSuccess() << n << " is even";

//     else

//       return testing::AssertionFailure() << n << " is odd";

//   }

//

// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print

//

//   Value of: IsEven(Fib(6))

//     Actual: true (8 is even)

//   Expected: false

//

// NB: Predicates that support negative Boolean assertions have reduced

// performance in positive ones so be careful not to use them in tests

// that have lots (tens of thousands) of positive Boolean assertions.

//

// To use this class with EXPECT_PRED_FORMAT assertions such as:

//

//   // Verifies that Foo() returns an even number.

//   EXPECT_PRED_FORMAT1(IsEven, Foo());

//

// you need to define:

//

//   testing::AssertionResult IsEven(const char* expr, int n) {

//     if ((n % 2) == 0)

//       return testing::AssertionSuccess();

//     else

//       return testing::AssertionFailure()

//         << "Expected: " << expr << " is even\n  Actual: it's " << n;

//   }

//

// If Foo() returns 5, you will see the following message:

//

//   Expected: Foo() is even

//     Actual: it's 5

class GTEST_API_ AssertionResult {

 public:

  // Copy constructor.

  // Used in EXPECT_TRUE/FALSE(assertion_result).

  AssertionResult(const AssertionResult& other);

// C4800 is a level 3 warning in Visual Studio 2015 and earlier.

// This warning is not emitted in Visual Studio 2017.

// This warning is off by default starting in Visual Studio 2019 but can be

// enabled with command-line options.

#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)

  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)

#endif

  // Used in the EXPECT_TRUE/FALSE(bool_expression).

  //

  // T must be contextually convertible to bool.

  //

  // The second parameter prevents this overload from being considered if

  // the argument is implicitly convertible to AssertionResult. In that case

  // we want AssertionResult's copy constructor to be used.

  template <typename T>

  explicit AssertionResult(

      const T& success,

      typename std::enable_if<

          !std::is_convertible<T, AssertionResult>::value>::type*

      /*enabler*/

      = nullptr)

      : success_(success) {}

#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)

  GTEST_DISABLE_MSC_WARNINGS_POP_()

#endif

  // Assignment operator.

  AssertionResult& operator=(AssertionResult other) {

    swap(other);

    return *this;

  }

  // Returns true if and only if the assertion succeeded.

  operator bool() const { return success_; }  // NOLINT

  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.

  AssertionResult operator!() const;

  // Returns the text streamed into this AssertionResult. Test assertions

  // use it when they fail (i.e., the predicate's outcome doesn't match the

  // assertion's expectation). When nothing has been streamed into the

  // object, returns an empty string.

  const char* message() const {

    return message_ != nullptr ? message_->c_str() : "";

  }

  // Deprecated; please use message() instead.

  const char* failure_message() const { return message(); }

  // Streams a custom failure message into this object.

  template <typename T>

  AssertionResult& operator<<(const T& value) {

    AppendMessage(Message() << value);

    return *this;

  }

  // Allows streaming basic output manipulators such as endl or flush into

  // this object.

  AssertionResult& operator<<(

      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {

    AppendMessage(Message() << basic_manipulator);

    return *this;

  }

 private:

  // Appends the contents of message to message_.

  void AppendMessage(const Message& a_message) {

    if (message_ == nullptr) message_ = ::std::make_unique<::std::string>();

    message_->append(a_message.GetString().c_str());

  }

  // Swap the contents of this AssertionResult with other.

  void swap(AssertionResult& other);

  // Stores result of the assertion predicate.

  bool success_;

  // Stores the message describing the condition in case the expectation

  // construct is not satisfied with the predicate's outcome.

  // Referenced via a pointer to avoid taking too much stack frame space

  // with test assertions.

  std::unique_ptr< ::std::string> message_;

};

// Makes a successful assertion result.

GTEST_API_ AssertionResult AssertionSuccess();

// Makes a failed assertion result.

GTEST_API_ AssertionResult AssertionFailure();

// Makes a failed assertion result with the given failure message.

// Deprecated; use AssertionFailure() << msg.

GTEST_API_ AssertionResult AssertionFailure(const Message& msg);

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4251

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_