test.cpp (6477B)
1 // This is free and unencumbered software released into the public domain. 2 // 3 // Anyone is free to copy, modify, publish, use, compile, sell, or 4 // distribute this software, either in source code form or as a compiled 5 // binary, for any purpose, commercial or non-commercial, and by any 6 // means. 7 // 8 // In jurisdictions that recognize copyright laws, the author or authors 9 // of this software dedicate any and all copyright interest in the 10 // software to the public domain. We make this dedication for the benefit 11 // of the public at large and to the detriment of our heirs and 12 // successors. We intend this dedication to be an overt act of 13 // relinquishment in perpetuity of all present and future rights to this 14 // software under copyright law. 15 // 16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 // IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 // OTHER DEALINGS IN THE SOFTWARE. 23 // 24 // For more information, please refer to <http://unlicense.org/> 25 26 #include "utest.h" 27 28 #ifdef _MSC_VER 29 // disable 'conditional expression is constant' - our examples below use this! 30 #pragma warning(disable : 4127) 31 #endif 32 33 UTEST(cpp, ASSERT_TRUE) { ASSERT_TRUE(1); } 34 35 UTEST(cpp, ASSERT_FALSE) { ASSERT_FALSE(0); } 36 37 UTEST(cpp, ASSERT_EQ) { ASSERT_EQ(1, 1); } 38 39 UTEST(cpp, ASSERT_NE) { ASSERT_NE(1, 2); } 40 41 UTEST(cpp, ASSERT_LT) { ASSERT_LT(1, 2); } 42 43 UTEST(cpp, ASSERT_LE) { 44 ASSERT_LE(1, 1); 45 ASSERT_LE(1, 2); 46 } 47 48 UTEST(cpp, ASSERT_GT) { ASSERT_GT(2, 1); } 49 50 UTEST(cpp, ASSERT_GE) { 51 ASSERT_GE(1, 1); 52 ASSERT_GE(2, 1); 53 } 54 55 UTEST(cpp, ASSERT_STREQ) { ASSERT_STREQ("foo", "foo"); } 56 57 UTEST(cpp, ASSERT_STRNE) { ASSERT_STRNE("foo", "bar"); } 58 59 UTEST(cpp, ASSERT_STRNEQ) { ASSERT_STRNEQ("foo", "foobar", strlen("foo")); } 60 61 UTEST(cpp, ASSERT_STRNNE) { ASSERT_STRNNE("foo", "barfoo", strlen("foo")); } 62 63 UTEST(cpp, EXPECT_TRUE) { EXPECT_TRUE(1); } 64 65 UTEST(cpp, EXPECT_FALSE) { EXPECT_FALSE(0); } 66 67 UTEST(cpp, EXPECT_EQ) { EXPECT_EQ(1, 1); } 68 69 UTEST(cpp, EXPECT_NE) { EXPECT_NE(1, 2); } 70 71 UTEST(cpp, EXPECT_LT) { EXPECT_LT(1, 2); } 72 73 UTEST(cpp, EXPECT_LE) { 74 EXPECT_LE(1, 1); 75 EXPECT_LE(1, 2); 76 } 77 78 UTEST(cpp, EXPECT_GT) { EXPECT_GT(2, 1); } 79 80 UTEST(cpp, EXPECT_GE) { 81 EXPECT_GE(1, 1); 82 EXPECT_GE(2, 1); 83 } 84 85 UTEST(cpp, EXPECT_STREQ) { EXPECT_STREQ("foo", "foo"); } 86 87 UTEST(cpp, EXPECT_STRNE) { EXPECT_STRNE("foo", "bar"); } 88 89 UTEST(cpp, EXPECT_STRNEQ) { EXPECT_STRNEQ("foo", "foobar", strlen("foo")); } 90 91 UTEST(cpp, EXPECT_STRNNE) { EXPECT_STRNNE("foo", "barfoo", strlen("foo")); } 92 93 UTEST(cpp, no_double_eval) { 94 int i = 0; 95 ASSERT_EQ(i++, 0); 96 ASSERT_EQ(i, 1); 97 } 98 99 struct MyTestF { 100 int foo; 101 }; 102 103 UTEST_F_SETUP(MyTestF) { 104 ASSERT_EQ(0, utest_fixture->foo); 105 utest_fixture->foo = 42; 106 } 107 108 UTEST_F_TEARDOWN(MyTestF) { ASSERT_EQ(13, utest_fixture->foo); } 109 110 UTEST_F(MyTestF, cpp_1) { 111 ASSERT_EQ(42, utest_fixture->foo); 112 utest_fixture->foo = 13; 113 } 114 115 UTEST_F(MyTestF, cpp_2) { 116 ASSERT_EQ(42, utest_fixture->foo); 117 utest_fixture->foo = 13; 118 } 119 120 struct MyTestI { 121 size_t foo; 122 size_t bar; 123 }; 124 125 UTEST_I_SETUP(MyTestI) { 126 ASSERT_EQ(0u, utest_fixture->foo); 127 ASSERT_EQ(0u, utest_fixture->bar); 128 utest_fixture->foo = 42; 129 utest_fixture->bar = utest_index; 130 } 131 132 UTEST_I_TEARDOWN(MyTestI) { 133 ASSERT_EQ(13u, utest_fixture->foo); 134 ASSERT_EQ(utest_index, utest_fixture->bar); 135 } 136 137 UTEST_I(MyTestI, cpp_1, 2) { 138 ASSERT_GT(2u, utest_fixture->bar); 139 utest_fixture->foo = 13; 140 } 141 142 UTEST_I(MyTestI, cpp_2, 128) { 143 ASSERT_GT(128u, utest_fixture->bar); 144 utest_fixture->foo = 13; 145 } 146 147 UTEST(cpp, Float) { 148 float a = 1; 149 float b = 2; 150 EXPECT_NE(a, b); 151 ASSERT_NE(a, b); 152 } 153 154 UTEST(cpp, Double) { 155 double a = 1; 156 double b = 2; 157 EXPECT_NE(a, b); 158 ASSERT_NE(a, b); 159 } 160 161 UTEST(cpp, LongDouble) { 162 long double a = 1; 163 long double b = 2; 164 EXPECT_NE(a, b); 165 ASSERT_NE(a, b); 166 } 167 168 UTEST(cpp, Char) { 169 char a = 1; 170 char b = 2; 171 EXPECT_NE(a, b); 172 ASSERT_NE(a, b); 173 } 174 175 UTEST(cpp, SignedChar) { 176 signed char a = 1; 177 signed char b = 2; 178 EXPECT_NE(a, b); 179 ASSERT_NE(a, b); 180 } 181 182 UTEST(cpp, UChar) { 183 unsigned char a = 1; 184 unsigned char b = 2; 185 EXPECT_NE(a, b); 186 ASSERT_NE(a, b); 187 } 188 189 UTEST(cpp, Short) { 190 short a = 1; 191 short b = 2; 192 EXPECT_NE(a, b); 193 ASSERT_NE(a, b); 194 } 195 196 UTEST(cpp, UShort) { 197 unsigned short a = 1; 198 unsigned short b = 2; 199 EXPECT_NE(a, b); 200 ASSERT_NE(a, b); 201 } 202 203 UTEST(cpp, Int) { 204 int a = 1; 205 int b = 2; 206 EXPECT_NE(a, b); 207 ASSERT_NE(a, b); 208 } 209 210 UTEST(cpp, UInt) { 211 unsigned int a = 1; 212 unsigned int b = 2; 213 EXPECT_NE(a, b); 214 ASSERT_NE(a, b); 215 } 216 217 UTEST(cpp, Long) { 218 long a = 1; 219 long b = 2; 220 EXPECT_NE(a, b); 221 ASSERT_NE(a, b); 222 } 223 224 UTEST(cpp, ULong) { 225 unsigned long a = 1; 226 unsigned long b = 2; 227 EXPECT_NE(a, b); 228 ASSERT_NE(a, b); 229 } 230 231 #if defined(__clang__) 232 #if __has_warning("-Wunsafe-buffer-usage") 233 #pragma clang diagnostic push 234 #pragma clang diagnostic ignored "-Wunsafe-buffer-usage" 235 #endif 236 #endif 237 238 UTEST(cpp, Ptr) { 239 char foo = 42; 240 EXPECT_NE(&foo, &foo + 1); 241 } 242 243 static const int data[4] = {42, 13, 6, -53}; 244 245 UTEST(cpp, Array) { EXPECT_NE(data, data + 1); } 246 247 #if defined(__clang__) 248 #if __has_warning("-Wunsafe-buffer-usage") 249 #pragma clang diagnostic pop 250 #endif 251 #endif 252 253 UTEST(cpp, Near) { 254 float a = 42.0f; 255 float b = 42.01f; 256 EXPECT_NEAR(a, b, 0.01f); 257 ASSERT_NEAR(a, b, 0.01f); 258 } 259 260 // GCC stdlib has a sanitizer bug in exceptions! 261 #if defined(__has_feature) 262 #if __has_feature(memory_sanitizer) 263 #define MEMORY_SANITIZER 264 #endif 265 #endif 266 267 #if defined(MEMORY_SANITIZER) 268 __attribute__((no_sanitize("memory"))) 269 #endif 270 static int 271 foo(int bar) { 272 if (bar == 1) 273 throw std::range_error("bad bar"); 274 return bar + 1; 275 } 276 277 UTEST(cpp, Exception) { 278 EXPECT_EXCEPTION(foo(1), std::range_error); 279 ASSERT_EXCEPTION(foo(1), std::range_error); 280 } 281 282 #if !defined(MEMORY_SANITIZER) 283 UTEST(cpp, ExceptionWithMessage) { 284 EXPECT_EXCEPTION_WITH_MESSAGE(foo(1), std::range_error, "bad bar"); 285 ASSERT_EXCEPTION_WITH_MESSAGE(foo(1), std::range_error, "bad bar"); 286 } 287 #endif 288 289 UTEST(cpp, Todo) { UTEST_SKIP("Not yet implemented!"); } 290 291 enum SomeEnum { SomeEnumFoo, SomeEnumBar }; 292 293 UTEST(cpp, Enum) { 294 EXPECT_NE(SomeEnumFoo, SomeEnumBar); 295 ASSERT_EQ(SomeEnumFoo, SomeEnumFoo); 296 } 297 298 UTEST(cpp, Modulo) { 299 int c = 42; 300 EXPECT_NE(c % 16, 0); 301 EXPECT_NE(0, c % 16); 302 ASSERT_EQ(10, c % 16); 303 }