framework/common/tcuDefs.hpp

   1 #ifndef _TCUDEFS_HPP
   2 #define _TCUDEFS_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Tester Core
   5  * ----------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Basic definitions.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "deDefs.hpp"
  27 #include "qpTestLog.h"
  28
  29 #include <string>
  30 #include <stdexcept>
  31
  32 /*--------------------------------------------------------------------*//*!
  33  * \brief dEQP Common Test Framework
  34  *
  35  * Code in this namespace doesn't require support for any specific client
  36  * APIs.
  37  *//*--------------------------------------------------------------------*/
  38 namespace tcu
  39 {
  40
  41 //! Kill program. Called when a fatal error occurs.
  42 void    die             (const char* format, ...) DE_PRINTF_FUNC_ATTR(1, 2);
  43
  44 //! Print to debug console.
  45 void    print   (const char* format, ...) DE_PRINTF_FUNC_ATTR(1, 2);
  46
  47 //! Base exception class for dEQP test framework.
  48 class Exception : public std::runtime_error
  49 {
  50 public:
  51                                                 Exception                       (const char* message, const char* expr, const char* file, int line);
  52                                                 Exception                       (const std::string& message);
  53         virtual                         ~Exception                      (void) throw() {}
  54
  55         const char*                     getMessage                      (void) const { return m_message.c_str(); }
  56
  57 private:
  58         const std::string       m_message;
  59 };
  60
  61 //! Base exception class for test exceptions that affect test result
  62 class TestException : public Exception
  63 {
  64 public:
  65                                                 TestException           (const char* message, const char* expr, const char* file, int line, qpTestResult result);
  66                                                 TestException           (const std::string& message, qpTestResult result);
  67         virtual                         ~TestException          (void) throw() {}
  68
  69         qpTestResult            getTestResult           (void) const { return m_result; }
  70         virtual bool            isFatal                         (void) const { return false; }
  71
  72 private:
  73         const qpTestResult      m_result;
  74 };
  75
  76 //! Exception for test errors.
  77 class TestError : public TestException
  78 {
  79 public:
  80                                         TestError                       (const char* message, const char* expr, const char* file, int line);
  81                                         TestError                       (const std::string& message);
  82         virtual                 ~TestError                      (void) throw() {}
  83 };
  84
  85 //! Exception for internal errors.
  86 class InternalError : public TestException
  87 {
  88 public:
  89                                         InternalError           (const char* message, const char* expr, const char* file, int line);
  90                                         InternalError           (const std::string& message);
  91         virtual                 ~InternalError          (void) throw() {}
  92 };
  93
  94 //! Resource error. Tester will terminate if thrown out of test case.
  95 class ResourceError : public TestException
  96 {
  97 public:
  98                                         ResourceError           (const char* message, const char* expr, const char* file, int line);
  99                                         ResourceError           (const std::string& message);
 100         virtual                 ~ResourceError          (void) throw() {}
 101
 102         virtual bool    isFatal                         (void) const { return true; }
 103 };
 104
 105 //! Not supported error.
 106 class NotSupportedError : public TestException
 107 {
 108 public:
 109                                         NotSupportedError       (const char* message, const char* expr, const char* file, int line);
 110                                         NotSupportedError       (const std::string& message);
 111         virtual                 ~NotSupportedError      (void) throw() {}
 112 };
 113
 114 } // tcu
 115
 116 #define TCU_THROW_EXPR(ERRCLASS, MSG, EXPR)                                             \
 117                         throw tcu::ERRCLASS(MSG, EXPR, __FILE__, __LINE__)
 118
 119 #define TCU_THROW(ERRCLASS, MSG)                                                                \
 120                         TCU_THROW_EXPR(ERRCLASS, MSG, DE_NULL)
 121
 122 #define TCU_CHECK_AND_THROW(ERRCLASS, X, MSG)                                   \
 123         do {                                                                                                            \
 124                 if (!(!deGetFalse() && (X)))                                                    \
 125                         TCU_THROW_EXPR(ERRCLASS, MSG, #X);                                      \
 126         } while(deGetFalse())
 127
 128 //! Throw TestError.
 129 #define TCU_FAIL(MSG)                           TCU_THROW(TestError, MSG)
 130
 131 //! Throw TestError if condition X is not satisfied.
 132 #define TCU_CHECK(X)                    do { if (!(!deGetFalse() && (X))) throw tcu::TestError(DE_NULL, #X, __FILE__, __LINE__); } while(deGetFalse())
 133
 134 //! Throw TestError if condition X is not satisfied.
 135 #define TCU_CHECK_MSG(X, MSG)   do { if (!(!deGetFalse() && (X))) throw tcu::TestError((MSG), #X, __FILE__, __LINE__); } while(deGetFalse())
 136
 137 //! Throw InternalError if condition X is not satisfied
 138 #define TCU_CHECK_INTERNAL(X)   do { if (!(!deGetFalse() && (X))) throw tcu::InternalError(DE_NULL, #X, __FILE__, __LINE__); } while(deGetFalse())
 139
 140 #endif // _TCUDEFS_HPP