1 #ifndef _XETESTCASERESULT_HPP
2 #define _XETESTCASERESULT_HPP
3 /*-------------------------------------------------------------------------
4 * drawElements Quality Program Test Executor
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 Test case result models.
24 *//*--------------------------------------------------------------------*/
25
26 #include "xeDefs.hpp"
27 #include "xeTestCase.hpp"
28
29 #include <string>
30 #include <vector>
31 #include <ostream>
32
33 namespace xe
34 {
35
36 enum TestStatusCode
37 {
38 TESTSTATUSCODE_PASS, //!< Test case passed.
39 TESTSTATUSCODE_FAIL, //!< Test case failed (not passed).
40 TESTSTATUSCODE_QUALITY_WARNING, //!< Result within specification, but suspicious quality wise
41 TESTSTATUSCODE_COMPATIBILITY_WARNING, //!< Result within specification, but likely to cause fragmentation
42 TESTSTATUSCODE_PENDING, //!< Not yet started.
43 TESTSTATUSCODE_RUNNING, //!< Currently running (not stored in database).
44 TESTSTATUSCODE_NOT_SUPPORTED, //!< Some feature was not supported in the implementation.
45 TESTSTATUSCODE_RESOURCE_ERROR, //!< A resource error has occurred.
46 TESTSTATUSCODE_INTERNAL_ERROR, //!< An internal error has occurred.
47 TESTSTATUSCODE_CANCELED, //!< User canceled the execution
48 TESTSTATUSCODE_TIMEOUT, //!< Test was killed because of watch dog timeout.
49 TESTSTATUSCODE_CRASH, //!< Test executable crashed before finishing the test.
50 TESTSTATUSCODE_DISABLED, //!< Test case disabled (for current target)
51 TESTSTATUSCODE_TERMINATED, //!< Terminated for other reason.
52
53 TESTSTATUSCODE_LAST
54 };
55
56 const char* getTestStatusCodeName (TestStatusCode statusCode);
57
58 namespace ri
59 {
60
61 class Item;
62 class Result;
63 class Text;
64 class Number;
65 class Image;
66 class ImageSet;
67 class VertexShader;
68 class FragmentShader;
69 class ShaderProgram;
70 class ShaderSource;
71 class InfoLog;
72 class EglConfig;
73 class EglConfigSet;
74 class Section;
75 class KernelSource;
76 class CompileInfo;
77 class SampleList;
78 class SampleInfo;
79 class ValueInfo;
80 class Sample;
81 class SampleValue;
82
83 // \todo [2014-02-28 pyry] Make List<T> for items that have only specific subitems.
84
85 class List
86 {
87 public:
88 List (void);
89 ~List (void);
90
getNumItems(void) const91 int getNumItems (void) const { return (int)m_items.size(); }
getItem(int ndx) const92 const Item& getItem (int ndx) const { return *m_items[ndx]; }
getItem(int ndx)93 Item& getItem (int ndx) { return *m_items[ndx]; }
94
95 template <typename T>
96 T* allocItem (void);
97
98 private:
99 std::vector<Item*> m_items;
100 };
101
102 template <typename T>
allocItem(void)103 T* List::allocItem (void)
104 {
105 m_items.reserve(m_items.size()+1);
106 T* item = new T();
107 m_items.push_back(static_cast<ri::Item*>(item));
108 return item;
109 }
110
111 } // ri
112
113 class TestCaseResultHeader
114 {
115 public:
TestCaseResultHeader(void)116 TestCaseResultHeader (void) : caseType(TESTCASETYPE_LAST), statusCode(TESTSTATUSCODE_LAST) {}
117
118 std::string casePath; //!< Full test case path.
119 TestCaseType caseType; //!< Test case type.
120 TestStatusCode statusCode; //!< Test status code.
121 std::string statusDetails; //!< Status description.
122 };
123
124 class TestCaseResult : public TestCaseResultHeader
125 {
126 public:
127 ri::List resultItems; //!< Test log items.
128 };
129
130 // Result items.
131 namespace ri
132 {
133
134 // Result item type.
135 enum Type
136 {
137 TYPE_RESULT = 0,
138 TYPE_TEXT,
139 TYPE_NUMBER,
140 TYPE_IMAGE,
141 TYPE_IMAGESET,
142 TYPE_SHADER,
143 TYPE_SHADERPROGRAM,
144 TYPE_SHADERSOURCE,
145 TYPE_INFOLOG,
146 TYPE_EGLCONFIG,
147 TYPE_EGLCONFIGSET,
148 TYPE_SECTION,
149 TYPE_KERNELSOURCE,
150 TYPE_COMPILEINFO,
151 TYPE_SAMPLELIST,
152 TYPE_SAMPLEINFO,
153 TYPE_VALUEINFO,
154 TYPE_SAMPLE,
155 TYPE_SAMPLEVALUE,
156
157 TYPE_LAST
158 };
159
160 class NumericValue
161 {
162 public:
163 enum Type
164 {
165 TYPE_EMPTY = 0,
166 TYPE_INT64,
167 TYPE_FLOAT64,
168
169 TYPE_LAST
170 };
171
NumericValue(void)172 NumericValue (void) : m_type(TYPE_EMPTY) {}
NumericValue(deInt64 value)173 NumericValue (deInt64 value) : m_type(TYPE_INT64) { m_value.int64 = value; }
NumericValue(double value)174 NumericValue (double value) : m_type(TYPE_FLOAT64) { m_value.float64 = value; }
175
getType(void) const176 Type getType (void) const { return m_type; }
getInt64(void) const177 deInt64 getInt64 (void) const { DE_ASSERT(getType() == TYPE_INT64); return m_value.int64; }
getFloat64(void) const178 double getFloat64 (void) const { DE_ASSERT(getType() == TYPE_FLOAT64); return m_value.float64; }
179
180 private:
181 Type m_type;
182 union
183 {
184 deInt64 int64;
185 double float64;
186 } m_value;
187 };
188
189 std::ostream& operator<< (std::ostream& str, const NumericValue& value);
190
191 class Item
192 {
193 public:
194
~Item(void)195 virtual ~Item (void) {}
196
getType(void) const197 Type getType (void) const { return m_type; }
198
199 protected:
Item(Type type)200 Item (Type type) : m_type(type) {}
201
202 private:
203 Item (const Item& other);
204 Item& operator= (const Item& other);
205
206 Type m_type;
207 };
208
209 class Result : public Item
210 {
211 public:
Result(void)212 Result (void) : Item(TYPE_RESULT), statusCode(TESTSTATUSCODE_LAST) {}
~Result(void)213 ~Result (void) {}
214
215 TestStatusCode statusCode;
216 std::string details;
217 };
218
219 class Text : public Item
220 {
221 public:
Text(void)222 Text (void) : Item(TYPE_TEXT) {}
~Text(void)223 ~Text (void) {}
224
225 std::string text;
226 };
227
228 class Number : public Item
229 {
230 public:
Number(void)231 Number (void) : Item(TYPE_NUMBER) {}
~Number(void)232 ~Number (void) {}
233
234 std::string name;
235 std::string description;
236 std::string unit;
237 std::string tag;
238 NumericValue value;
239 };
240
241 class Image : public Item
242 {
243 public:
244 enum Format
245 {
246 FORMAT_RGB888,
247 FORMAT_RGBA8888,
248
249 FORMAT_LAST
250 };
251
252 enum Compression
253 {
254 COMPRESSION_NONE = 0,
255 COMPRESSION_PNG,
256
257 COMPRESSION_LAST
258 };
259
Image(void)260 Image (void) : Item(TYPE_IMAGE), width(0), height(0), format(FORMAT_LAST), compression(COMPRESSION_LAST) {}
~Image(void)261 ~Image (void) {}
262
263 std::string name;
264 std::string description;
265 int width;
266 int height;
267 Format format;
268 Compression compression;
269 std::vector<deUint8> data;
270 };
271
272 class ImageSet : public Item
273 {
274 public:
ImageSet(void)275 ImageSet (void) : Item(TYPE_IMAGESET) {}
~ImageSet(void)276 ~ImageSet (void) {}
277
278 std::string name;
279 std::string description;
280 List images;
281 };
282
283 class ShaderSource : public Item
284 {
285 public:
ShaderSource(void)286 ShaderSource (void) : Item(TYPE_SHADERSOURCE) {}
~ShaderSource(void)287 ~ShaderSource (void) {}
288
289 std::string source;
290 };
291
292 class InfoLog : public Item
293 {
294 public:
InfoLog(void)295 InfoLog (void) : Item(TYPE_INFOLOG) {}
~InfoLog(void)296 ~InfoLog (void) {}
297
298 std::string log;
299 };
300
301 class Shader : public Item
302 {
303 public:
304 enum ShaderType
305 {
306 SHADERTYPE_VERTEX = 0,
307 SHADERTYPE_FRAGMENT,
308 SHADERTYPE_GEOMETRY,
309 SHADERTYPE_TESS_CONTROL,
310 SHADERTYPE_TESS_EVALUATION,
311 SHADERTYPE_COMPUTE,
312
313 SHADERTYPE_LAST
314 };
315
Shader(void)316 Shader (void) : Item(TYPE_SHADER), shaderType(SHADERTYPE_LAST), compileStatus(false) {}
~Shader(void)317 ~Shader (void) {}
318
319 ShaderType shaderType;
320 bool compileStatus;
321 ShaderSource source;
322 InfoLog infoLog;
323 };
324
325 class ShaderProgram : public Item
326 {
327 public:
ShaderProgram(void)328 ShaderProgram (void) : Item(TYPE_SHADERPROGRAM), linkStatus(false) {}
~ShaderProgram(void)329 ~ShaderProgram (void) {}
330
331 List shaders;
332 bool linkStatus;
333 InfoLog linkInfoLog;
334 };
335
336 class EglConfig : public Item
337 {
338 public:
339 EglConfig (void);
~EglConfig(void)340 ~EglConfig (void) {}
341
342 int bufferSize;
343 int redSize;
344 int greenSize;
345 int blueSize;
346 int luminanceSize;
347 int alphaSize;
348 int alphaMaskSize;
349 bool bindToTextureRGB;
350 bool bindToTextureRGBA;
351 std::string colorBufferType;
352 std::string configCaveat;
353 int configID;
354 std::string conformant;
355 int depthSize;
356 int level;
357 int maxPBufferWidth;
358 int maxPBufferHeight;
359 int maxPBufferPixels;
360 int maxSwapInterval;
361 int minSwapInterval;
362 bool nativeRenderable;
363 std::string renderableType;
364 int sampleBuffers;
365 int samples;
366 int stencilSize;
367 std::string surfaceTypes;
368 std::string transparentType;
369 int transparentRedValue;
370 int transparentGreenValue;
371 int transparentBlueValue;
372 };
373
EglConfig(void)374 inline EglConfig::EglConfig (void)
375 : Item (TYPE_EGLCONFIG)
376 , bufferSize (0)
377 , redSize (0)
378 , greenSize (0)
379 , blueSize (0)
380 , luminanceSize (0)
381 , alphaSize (0)
382 , alphaMaskSize (0)
383 , bindToTextureRGB (false)
384 , bindToTextureRGBA (false)
385 , configID (0)
386 , depthSize (0)
387 , level (0)
388 , maxPBufferWidth (0)
389 , maxPBufferHeight (0)
390 , maxPBufferPixels (0)
391 , maxSwapInterval (0)
392 , minSwapInterval (0)
393 , nativeRenderable (false)
394 , sampleBuffers (0)
395 , samples (0)
396 , stencilSize (0)
397 , transparentRedValue (0)
398 , transparentGreenValue (0)
399 , transparentBlueValue (0)
400 {
401 }
402
403 class EglConfigSet : public Item
404 {
405 public:
EglConfigSet(void)406 EglConfigSet (void) : Item(TYPE_EGLCONFIGSET) {}
~EglConfigSet(void)407 ~EglConfigSet (void) {}
408
409 std::string name;
410 std::string description;
411 List configs;
412 };
413
414 class Section : public Item
415 {
416 public:
Section(void)417 Section (void) : Item(TYPE_SECTION) {}
~Section(void)418 ~Section (void) {}
419
420 std::string name;
421 std::string description;
422 List items;
423 };
424
425 class KernelSource : public Item
426 {
427 public:
KernelSource(void)428 KernelSource (void) : Item(TYPE_KERNELSOURCE) {}
~KernelSource(void)429 ~KernelSource (void) {}
430
431 std::string source;
432 };
433
434 class CompileInfo : public Item
435 {
436 public:
CompileInfo(void)437 CompileInfo (void) : Item(TYPE_COMPILEINFO), compileStatus(false) {}
~CompileInfo(void)438 ~CompileInfo (void) {}
439
440 std::string name;
441 std::string description;
442 bool compileStatus;
443 InfoLog infoLog;
444 };
445
446 class ValueInfo : public Item
447 {
448 public:
449 enum ValueTag
450 {
451 VALUETAG_PREDICTOR,
452 VALUETAG_RESPONSE,
453
454 VALUETAG_LAST
455 };
456
ValueInfo(void)457 ValueInfo (void) : Item(TYPE_VALUEINFO), tag(VALUETAG_LAST) {}
~ValueInfo(void)458 ~ValueInfo (void) {}
459
460 std::string name;
461 std::string description;
462 std::string unit;
463 ValueTag tag;
464 };
465
466 class SampleInfo : public Item
467 {
468 public:
SampleInfo(void)469 SampleInfo (void) : Item(TYPE_SAMPLEINFO) {}
~SampleInfo(void)470 ~SampleInfo (void) {}
471
472 List valueInfos;
473 };
474
475 class SampleValue : public Item
476 {
477 public:
SampleValue(void)478 SampleValue (void) : Item(TYPE_SAMPLEVALUE) {}
~SampleValue(void)479 ~SampleValue (void) {}
480
481 NumericValue value;
482 };
483
484 class Sample : public Item
485 {
486 public:
Sample(void)487 Sample (void) : Item(TYPE_SAMPLE) {}
~Sample(void)488 ~Sample (void) {}
489
490 List values;
491 };
492
493 class SampleList : public Item
494 {
495 public:
SampleList(void)496 SampleList (void) : Item(TYPE_SAMPLELIST) {}
~SampleList(void)497 ~SampleList (void) {}
498
499 std::string name;
500 std::string description;
501 SampleInfo sampleInfo;
502 List samples;
503 };
504
505 } // ri
506 } // xe
507
508 #endif // _XETESTCASERESULT_HPP
509