GUnit/test/GAssert.cpp at 1a4f16d679642c5b58ddb11e997f60731ddc1974 · cpp-testing/GUnit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
//
// Copyright (c) 2016-2017 Kris Jusiak (kris at jusiak dot net)
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <gtest/gtest.h>
#include "GUnit/GAssert.h"

struct call_only_once {
  int a{42};
  bool called{false};

  auto value() -> int {
    if (called) {
      throw std::runtime_error("Called twice, should only evaluate once.");
    }

    called = true;
    return a;
  }
};

TEST(GAssert, ShouldSupportExpect) {
  auto i = 42;
  const auto b = true;

  EXPECT(true);
  EXPECT(!false) << "message";
  EXPECT(b);

  call_only_once once{};
  EXPECT(once.value() == 42);
  EXPECT_THROW(once.value(), std::runtime_error);

  EXPECT(i == 42);
  EXPECT(42 == i);
  EXPECT(42 == i);

  EXPECT(i != 0);
  EXPECT(0 != i);

  EXPECT(i > 0) << "message";
  EXPECT(i >= 0) << "message";
  EXPECT(i <= 42) << "message";
  EXPECT(i < 100) << "message";

  EXPECT(42.0 == 42.);
  EXPECT(2*21 == i);

  struct convertible {
    operator bool() const { return false; }
  };

  EXPECT(not convertible{});
  EXPECT(false == convertible{});

  EXPECT(false or true);
}

TEST(GAssert, ShouldSupportASSERT) {
  const auto i = 42;

  ASSERT(true);

  ASSERT(i == 42);
  ASSERT(42 == i);

  ASSERT(i != 0);
  ASSERT(0 != i);

  ASSERT(i > 0) << "message";
  ASSERT(i >= 0) << "message";
  ASSERT(i <= 42) << "message";
  ASSERT(i < 100) << "message";

  ASSERT(42.0 == 42.);
  ASSERT(2*21 == i);

  ASSERT("42" == std::string{"42"});
  ASSERT(std::string{"42"} == "42");
  ASSERT("42" != std::string{});
  ASSERT(std::string{} != "42");

  struct convertible {
    operator bool() const { return true; }
  };

  ASSERT(convertible{});
  ASSERT(false == not convertible{});

  ASSERT(false or true);
}