cpp-expect/test/expect_test.cxx

//
//  expect.t.h
//  expect
//
//  Created by Sam Jaffe on 1/10/17.
//

#include <gmock/gmock.h>

#include "expect/expect.hpp"

struct my_error : public std::logic_error {
  using std::logic_error::logic_error;
};

using ::testing::Eq;
using ::testing::HasSubstr;
using ::testing::StrEq;

TEST(ExpectTest, ExpectTrueIsSafe) {
  int i = 1;
  EXPECT_NO_THROW(expects(i == 1));
}

TEST(ExpectTest, ExpectFalseThrows) {
  int i = 1;
  EXPECT_THROW(expects(i == 2), std::logic_error);
}

TEST(ExpectTest, CanProvideCustomErrorType) {
  int i = 1;
  EXPECT_THROW((expects(i == 2, my_error, "error")), my_error);
}

TEST(ExpectTest, FailsWithErrorMessageContainingExpr) {
  int i = 1;
  try {
    expects(i == 2);
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), HasSubstr("i == 2"));
  }
}

TEST(ExpectTest, CanProvideCustomErrorMessage) {
  int i = 1;
  try {
    expects(i == 2, "example error message");
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), StrEq("example error message"));
  }
}

TEST(ExpectGracefulTest, ReturnsEarly) {
  int i = 1;
  expects_graceful(i == 2);
  FAIL() << "expected return";
}

TEST(ExpectGracefulTest, ReturnValueCanBeControlled) {
  auto get_gracefully = [](bool no) {
    expects_graceful(no, 7);
    return 1;
  };
  EXPECT_THAT(get_gracefully(true), Eq(1));
  EXPECT_THAT(get_gracefully(false), Eq(7));
}

TEST(EnsureTest, EnsureFiresOffWhenScopeExit) {
  int i = 7;
  ensures(i == 6);
  i = 6;
}

TEST(EnsureTest, ThrowsIfFailed) {
  int i = 7;
  EXPECT_THROW(ensures(i == 6), std::runtime_error);
}

TEST(EnsureTest, FailsWithErrorMessageContainingExpr) {
  int i = 1;
  try {
    { ensures(i == 2); }
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), HasSubstr("i == 2"));
  }
}

TEST(EnsureTest, CanProvideCustomErrorType) {
  int i = 1;
  EXPECT_THROW((expects(i == 2, my_error, "error")), my_error);
}

TEST(EnsureTest, CanProvideCustomErrorMessage) {
  int i = 1;
  try {
    { ensures(i == 2, "example error message"); }
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), StrEq("example error message"));
  }
}

TEST(ReturnEnsureTest, ReturnsFirstExprIfPassesLambda) {
  int i = 6;
  EXPECT_THAT(return_ensures(i + 1, _ > 5), Eq(7));
}

TEST(ReturnEnsureTest, ThrowsWhenFailingLambda) {
  EXPECT_THROW(return_ensures(7, _ < 5), std::runtime_error);
}

TEST(ReturnEnsureTest, FailsWithErrorMessageContainingExprAndLambda) {
  try {
    int i = 6;
    (void) return_ensures(i + 1, _ < 5);
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), HasSubstr("_ < 5"));
    EXPECT_THAT(e.what(), HasSubstr("i + 1"));
  }
}

TEST(ReturnEnsureTest, CanProvideCustomErrorMessage) {
  try {
    (void) return_ensures(7, _ < 5, "example error message");
    FAIL() << "expected exception";
  } catch (std::exception const & e) {
    EXPECT_THAT(e.what(), StrEq("example error message"));
  }
}

TEST(ReturnEnsureTest, CanProvideCustomErrorType) {
  EXPECT_THROW(return_ensures(7, _ < 5, my_error, "error"), my_error);
}