framework/common/tcuTestCase.hpp

   1 #ifndef _TCUTESTCASE_HPP
   2 #define _TCUTESTCASE_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 Base class for a test case.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "tcuTestContext.hpp"
  28
  29 #include <string>
  30 #include <vector>
  31
  32 namespace tcu
  33 {
  34
  35 enum TestNodeType
  36 {
  37         NODETYPE_ROOT = 0,              //!< Root for all test packages.
  38         NODETYPE_PACKAGE,               //!< Test case package -- same as group, but is omitted from XML dump.
  39         NODETYPE_GROUP,                 //!< Test case container -- cannot be executed.
  40         NODETYPE_SELF_VALIDATE, //!< Self-validating test case -- can be executed
  41         NODETYPE_PERFORMANCE,   //!< Performace test case -- can be executed
  42         NODETYPE_CAPABILITY,    //!< Capability score case -- can be executed
  43         NODETYPE_ACCURACY               //!< Accuracy test case -- can be executed
  44 };
  45
  46 enum TestNodeClass
  47 {
  48         NODECLASS_GROUP = 0,    //!< Root or non-leaf in the test hierarchy tree
  49         NODECLASS_EXECUTABLE,   //!< Non-root leaf in the test hierarchy tree
  50
  51         NODECLASS_LAST
  52 };
  53
  54 enum TestRunnerType
  55 {
  56         RUNNERTYPE_ANY          = 0u,
  57         RUNNERTYPE_NONE         = (1u << 0),
  58         RUNNERTYPE_AMBER        = (1u << 1)
  59 };
  60
  61 inline TestNodeClass getTestNodeTypeClass (TestNodeType type)
  62 {
  63         switch (type)
  64         {
  65                 case NODETYPE_ROOT:                             return NODECLASS_GROUP;
  66                 case NODETYPE_PACKAGE:                  return NODECLASS_GROUP;
  67                 case NODETYPE_GROUP:                    return NODECLASS_GROUP;
  68                 case NODETYPE_SELF_VALIDATE:    return NODECLASS_EXECUTABLE;
  69                 case NODETYPE_PERFORMANCE:              return NODECLASS_EXECUTABLE;
  70                 case NODETYPE_CAPABILITY:               return NODECLASS_EXECUTABLE;
  71                 case NODETYPE_ACCURACY:                 return NODECLASS_EXECUTABLE;
  72                 default:
  73                         DE_ASSERT(false);
  74                         return NODECLASS_LAST;
  75         }
  76 }
  77
  78 inline bool isTestNodeTypeExecutable (TestNodeType type)
  79 {
  80         return getTestNodeTypeClass(type) == NODECLASS_EXECUTABLE;
  81 }
  82
  83 inline bool isValidTestCaseNameChar (char c)
  84 {
  85         return de::inRange(c, 'a', 'z') ||
  86                    de::inRange(c, 'A', 'Z') ||
  87                    de::inRange(c, '0', '9') ||
  88                    c == '_' || c == '-';
  89 }
  90
  91 /*--------------------------------------------------------------------*//*!
  92  * \brief Test case hierarchy node
  93  *
  94  * Test node forms the backbone of the test case hierarchy. All objects
  95  * in the hierarchy are derived from this class.
  96  *
  97  * Each test node has a type and all except the root node have name and
  98  * description. Root and test group nodes have a list of children.
  99  *
 100  * During test execution TestExecutor iterates the hierarchy. Upon entering
 101  * the node (both groups and test cases) init() is called. When exiting the
 102  * node deinit() is called respectively.
 103  *//*--------------------------------------------------------------------*/
 104 class TestNode
 105 {
 106 public:
 107         enum IterateResult
 108         {
 109                 STOP            = 0,
 110                 CONTINUE        = 1
 111         };
 112
 113         // Methods.
 114                                                         TestNode                                (TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description);
 115                                                         TestNode                                (TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description, const std::vector<TestNode*>& children);
 116         virtual                                 ~TestNode                               (void);
 117
 118         TestNodeType                    getNodeType                             (void) const    { return m_nodeType;                    }
 119         TestContext&                    getTestContext                  (void) const    { return m_testCtx;                             }
 120         const char*                             getName                                 (void) const    { return m_name.c_str();                }
 121         const char*                             getDescription                  (void) const    { return m_description.c_str(); }
 122         void                                    getChildren                             (std::vector<TestNode*>& children) const;
 123         void                                    addChild                                (TestNode* node);
 124         bool                                    empty                                   () const                { return m_children.empty();    }
 125
 126         virtual void                    init                                    (void);
 127         virtual void                    deinit                                  (void);
 128         virtual IterateResult   iterate                                 (void) = 0;
 129         virtual TestRunnerType  getRunnerType                   (void) const    { return RUNNERTYPE_NONE;               }
 130         virtual bool                    validateRequirements    ()                              { return true;                                  }
 131 protected:
 132         TestContext&                    m_testCtx;
 133         std::string                             m_name;
 134         std::string                             m_description;
 135
 136 private:
 137         const TestNodeType              m_nodeType;
 138         std::vector<TestNode*>  m_children;
 139 };
 140
 141 /*--------------------------------------------------------------------*//*!
 142  * \brief Test case group node
 143  *
 144  * Test case group implementations must inherit this class. To save resources
 145  * during test execution the group must delay creation of any child groups
 146  * until init() is called.
 147  *
 148  * Default deinit() for test group will destroy all child nodes.
 149  *//*--------------------------------------------------------------------*/
 150 class TestCaseGroup : public TestNode
 151 {
 152 public:
 153                                                         TestCaseGroup   (TestContext& testCtx, const char* name, const char* description);
 154                                                         TestCaseGroup   (TestContext& testCtx, const char* name, const char* description, const std::vector<TestNode*>& children);
 155         virtual                                 ~TestCaseGroup  (void);
 156
 157         virtual IterateResult   iterate                 (void);
 158 };
 159
 160 /*--------------------------------------------------------------------*//*!
 161  * \brief Test case class
 162  *
 163  * Test case implementations must inherit this class.
 164  *
 165  * Test case objects are usually constructed when TestExecutor enters parent
 166  * group. Allocating any non-parameter resources, especially target API objects
 167  * must be delayed to init().
 168  *
 169  * Upon entering the test case TestExecutor calls init(). If initialization
 170  * is successful (no exception is thrown) the executor will then call iterate()
 171  * until test case returns STOP. After that deinit() will be called.
 172  *
 173  * Before exiting the execution phase (i.e. at returning STOP from iterate())
 174  * the test case must set valid status code to test context (m_testCtx).
 175  *
 176  * Test case can also signal error condition by throwing an exception. In
 177  * that case the framework will set result code and details based on the
 178  * exception.
 179  *//*--------------------------------------------------------------------*/
 180 class TestCase : public TestNode
 181 {
 182 public:
 183                                         TestCase                        (TestContext& testCtx, const char* name, const char* description);
 184                                         TestCase                        (TestContext& testCtx, TestNodeType nodeType, const char* name, const char* description);
 185         virtual                 ~TestCase                       (void);
 186 };
 187
 188 class TestStatus
 189 {
 190 public:
 191                                                 TestStatus              (qpTestResult code, const std::string& description) : m_code(code), m_description(description) {}
 192
 193         bool                            isComplete              (void) const { return m_code != QP_TEST_RESULT_LAST;                    }
 194         qpTestResult            getCode                 (void) const { DE_ASSERT(isComplete()); return m_code;                  }
 195         const std::string&      getDescription  (void) const { DE_ASSERT(isComplete()); return m_description;   }
 196
 197         static TestStatus       pass                    (const std::string& description)        { return TestStatus(QP_TEST_RESULT_PASS,        description);   }
 198         static TestStatus       fail                    (const std::string& description)        { return TestStatus(QP_TEST_RESULT_FAIL,        description);   }
 199         static TestStatus       incomplete              (void)                                                          { return TestStatus(QP_TEST_RESULT_LAST,        "");                    }
 200
 201 private:
 202         qpTestResult            m_code;
 203         std::string                     m_description;
 204 } DE_WARN_UNUSED_TYPE;
 205
 206 } // tcu
 207
 208 #endif // _TCUTESTCASE_HPP