1 // Copyright 2006, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 // This file is AUTOMATICALLY GENERATED on 01/02/2018 by command 31 // 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! 32 // 33 // Implements a family of generic predicate assertion macros. 34 35 // GOOGLETEST_CM0001 DO NOT DELETE 36 37 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 38 #define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 39 40 #include "gtest/gtest.h" 41 42 namespace testing { 43 44 // This header implements a family of generic predicate assertion 45 // macros: 46 // 47 // ASSERT_PRED_FORMAT1(pred_format, v1) 48 // ASSERT_PRED_FORMAT2(pred_format, v1, v2) 49 // ... 50 // 51 // where pred_format is a function or functor that takes n (in the 52 // case of ASSERT_PRED_FORMATn) values and their source expression 53 // text, and returns a testing::AssertionResult. See the definition 54 // of ASSERT_EQ in gtest.h for an example. 55 // 56 // If you don't care about formatting, you can use the more 57 // restrictive version: 58 // 59 // ASSERT_PRED1(pred, v1) 60 // ASSERT_PRED2(pred, v1, v2) 61 // ... 62 // 63 // where pred is an n-ary function or functor that returns bool, 64 // and the values v1, v2, ..., must support the << operator for 65 // streaming to std::ostream. 66 // 67 // We also define the EXPECT_* variations. 68 // 69 // For now we only support predicates whose arity is at most 5. 70 71 // GTEST_ASSERT_ is the basic statement to which all of the assertions 72 // in this file reduce. Don't use this in your code. 73 74 #define GTEST_ASSERT_(expression, on_failure) \ 75 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 76 if (const ::testing::AssertionResult gtest_ar = (expression)) \ 77 ; \ 78 else \ 79 on_failure(gtest_ar.failure_message()) 80 81 82 // Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use 83 // this in your code. 84 template <typename Pred, 85 typename T1> 86 AssertionResult AssertPred1Helper(const char* pred_text, 87 const char* e1, 88 Pred pred, 89 const T1& v1) { 90 if (pred(v1)) return AssertionSuccess(); 91 92 return AssertionFailure() << pred_text << "(" 93 << e1 << ") evaluates to false, where" 94 << "\n" << e1 << " evaluates to " << v1; 95 } 96 97 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. 98 // Don't use this in your code. 99 #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ 100 GTEST_ASSERT_(pred_format(#v1, v1), \ 101 on_failure) 102 103 // Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use 104 // this in your code. 105 #define GTEST_PRED1_(pred, v1, on_failure)\ 106 GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ 107 #v1, \ 108 pred, \ 109 v1), on_failure) 110 111 // Unary predicate assertion macros. 112 #define EXPECT_PRED_FORMAT1(pred_format, v1) \ 113 GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) 114 #define EXPECT_PRED1(pred, v1) \ 115 GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) 116 #define ASSERT_PRED_FORMAT1(pred_format, v1) \ 117 GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) 118 #define ASSERT_PRED1(pred, v1) \ 119 GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) 120 121 122 123 // Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use 124 // this in your code. 125 template <typename Pred, 126 typename T1, 127 typename T2> 128 AssertionResult AssertPred2Helper(const char* pred_text, 129 const char* e1, 130 const char* e2, 131 Pred pred, 132 const T1& v1, 133 const T2& v2) { 134 if (pred(v1, v2)) return AssertionSuccess(); 135 136 return AssertionFailure() << pred_text << "(" 137 << e1 << ", " 138 << e2 << ") evaluates to false, where" 139 << "\n" << e1 << " evaluates to " << v1 140 << "\n" << e2 << " evaluates to " << v2; 141 } 142 143 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. 144 // Don't use this in your code. 145 #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ 146 GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \ 147 on_failure) 148 149 // Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use 150 // this in your code. 151 #define GTEST_PRED2_(pred, v1, v2, on_failure)\ 152 GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ 153 #v1, \ 154 #v2, \ 155 pred, \ 156 v1, \ 157 v2), on_failure) 158 159 // Binary predicate assertion macros. 160 #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ 161 GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) 162 #define EXPECT_PRED2(pred, v1, v2) \ 163 GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) 164 #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ 165 GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) 166 #define ASSERT_PRED2(pred, v1, v2) \ 167 GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) 168 169 170 171 // Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use 172 // this in your code. 173 template <typename Pred, 174 typename T1, 175 typename T2, 176 typename T3> 177 AssertionResult AssertPred3Helper(const char* pred_text, 178 const char* e1, 179 const char* e2, 180 const char* e3, 181 Pred pred, 182 const T1& v1, 183 const T2& v2, 184 const T3& v3) { 185 if (pred(v1, v2, v3)) return AssertionSuccess(); 186 187 return AssertionFailure() << pred_text << "(" 188 << e1 << ", " 189 << e2 << ", " 190 << e3 << ") evaluates to false, where" 191 << "\n" << e1 << " evaluates to " << v1 192 << "\n" << e2 << " evaluates to " << v2 193 << "\n" << e3 << " evaluates to " << v3; 194 } 195 196 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. 197 // Don't use this in your code. 198 #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ 199 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \ 200 on_failure) 201 202 // Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use 203 // this in your code. 204 #define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ 205 GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ 206 #v1, \ 207 #v2, \ 208 #v3, \ 209 pred, \ 210 v1, \ 211 v2, \ 212 v3), on_failure) 213 214 // Ternary predicate assertion macros. 215 #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ 216 GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) 217 #define EXPECT_PRED3(pred, v1, v2, v3) \ 218 GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) 219 #define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ 220 GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) 221 #define ASSERT_PRED3(pred, v1, v2, v3) \ 222 GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) 223 224 225 226 // Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use 227 // this in your code. 228 template <typename Pred, 229 typename T1, 230 typename T2, 231 typename T3, 232 typename T4> 233 AssertionResult AssertPred4Helper(const char* pred_text, 234 const char* e1, 235 const char* e2, 236 const char* e3, 237 const char* e4, 238 Pred pred, 239 const T1& v1, 240 const T2& v2, 241 const T3& v3, 242 const T4& v4) { 243 if (pred(v1, v2, v3, v4)) return AssertionSuccess(); 244 245 return AssertionFailure() << pred_text << "(" 246 << e1 << ", " 247 << e2 << ", " 248 << e3 << ", " 249 << e4 << ") evaluates to false, where" 250 << "\n" << e1 << " evaluates to " << v1 251 << "\n" << e2 << " evaluates to " << v2 252 << "\n" << e3 << " evaluates to " << v3 253 << "\n" << e4 << " evaluates to " << v4; 254 } 255 256 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. 257 // Don't use this in your code. 258 #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ 259 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \ 260 on_failure) 261 262 // Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use 263 // this in your code. 264 #define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ 265 GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ 266 #v1, \ 267 #v2, \ 268 #v3, \ 269 #v4, \ 270 pred, \ 271 v1, \ 272 v2, \ 273 v3, \ 274 v4), on_failure) 275 276 // 4-ary predicate assertion macros. 277 #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ 278 GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) 279 #define EXPECT_PRED4(pred, v1, v2, v3, v4) \ 280 GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) 281 #define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ 282 GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) 283 #define ASSERT_PRED4(pred, v1, v2, v3, v4) \ 284 GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) 285 286 287 288 // Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use 289 // this in your code. 290 template <typename Pred, 291 typename T1, 292 typename T2, 293 typename T3, 294 typename T4, 295 typename T5> 296 AssertionResult AssertPred5Helper(const char* pred_text, 297 const char* e1, 298 const char* e2, 299 const char* e3, 300 const char* e4, 301 const char* e5, 302 Pred pred, 303 const T1& v1, 304 const T2& v2, 305 const T3& v3, 306 const T4& v4, 307 const T5& v5) { 308 if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); 309 310 return AssertionFailure() << pred_text << "(" 311 << e1 << ", " 312 << e2 << ", " 313 << e3 << ", " 314 << e4 << ", " 315 << e5 << ") evaluates to false, where" 316 << "\n" << e1 << " evaluates to " << v1 317 << "\n" << e2 << " evaluates to " << v2 318 << "\n" << e3 << " evaluates to " << v3 319 << "\n" << e4 << " evaluates to " << v4 320 << "\n" << e5 << " evaluates to " << v5; 321 } 322 323 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. 324 // Don't use this in your code. 325 #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ 326 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \ 327 on_failure) 328 329 // Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use 330 // this in your code. 331 #define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ 332 GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ 333 #v1, \ 334 #v2, \ 335 #v3, \ 336 #v4, \ 337 #v5, \ 338 pred, \ 339 v1, \ 340 v2, \ 341 v3, \ 342 v4, \ 343 v5), on_failure) 344 345 // 5-ary predicate assertion macros. 346 #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ 347 GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) 348 #define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ 349 GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) 350 #define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ 351 GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) 352 #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ 353 GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) 354 355 356 357 } // namespace testing 358 359 #endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 360