framework/common/tcuTestLog.hpp

   1 #ifndef _TCUTESTLOG_HPP
   2 #define _TCUTESTLOG_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 Test Log C++ Wrapper.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "qpTestLog.h"
  28 #include "tcuTexture.hpp"
  29
  30 #include <sstream>
  31
  32 namespace tcu
  33 {
  34
  35 class Surface;
  36 class MessageBuilder;
  37 class LogImageSet;
  38 class LogImage;
  39 class LogSection;
  40 class LogShaderProgram;
  41 class LogShader;
  42 class LogSpirVAssemblySource;
  43 class LogKernelSource;
  44 class LogSampleList;
  45 class LogValueInfo;
  46 class SampleBuilder;
  47 template<typename T> class LogNumber;
  48
  49 /*--------------------------------------------------------------------*//*!
  50  * \brief Test log
  51  *
  52  * TestLog provides convinient C++ API for logging. The API has been designed
  53  * around stream operators much like STL iostream library. The following
  54  * examples demonstrate how to use TestLog.
  55  *
  56  * \code
  57  * TestLog& log = m_testCtx.getLog();
  58  *
  59  * // Write message to log.
  60  * log << TestLog::Message << "Hello, World!" << TestLog::EndMessage;
  61  * int myNumber = 3;
  62  * log << TestLog::Message << "Diff is " << myNumber << TestLog::EndMessage;
  63  *
  64  * // Write image
  65  * Surface myImage(256, 256);
  66  * log << TestLog::Image("TestImage", "My test image", myImage);
  67  *
  68  * // Multiple commands can be combined:
  69  * log << TestLog::Section("Details", "Test case details")
  70  *     << TestLog::Message << "Here be dragons" << TestLog::EndMessage
  71  *     << TestLog::ImageSet("Result", "Result images")
  72  *     << TestLog::Image("ImageA", "Image A", imageA)
  73  *     << TestLog::Image("ImageB", "Image B", imageB)
  74  *     << TestLog::EndImageSet << TestLog::EndSection;
  75  * \endcode
  76  *//*--------------------------------------------------------------------*/
  77 class TestLog
  78 {
  79 public:
  80         // Tokens
  81         static const class BeginMessageToken {}                 Message;
  82         static const class EndMessageToken {}                   EndMessage;
  83         static const class EndImageSetToken {}                  EndImageSet;
  84         static const class EndSectionToken {}                   EndSection;
  85         static const class EndShaderProgramToken {}             EndShaderProgram;
  86         static const class SampleInfoToken {}                   SampleInfo;
  87         static const class EndSampleInfoToken {}                EndSampleInfo;
  88         static const class BeginSampleToken {}                  Sample;
  89         static const class EndSampleToken {}                    EndSample;
  90         static const class EndSampleListToken {}                EndSampleList;
  91
  92         // Typedefs.
  93         typedef LogImageSet                             ImageSet;
  94         typedef LogImage                                Image;
  95         typedef LogSection                              Section;
  96         typedef LogShaderProgram                ShaderProgram;
  97         typedef LogShader                               Shader;
  98         typedef LogSpirVAssemblySource  SpirVAssemblySource;
  99         typedef LogKernelSource                 KernelSource;
 100         typedef LogSampleList                   SampleList;
 101         typedef LogValueInfo                    ValueInfo;
 102         typedef LogNumber<float>                Float;
 103         typedef LogNumber<deInt64>              Integer;
 104
 105         explicit                        TestLog                                 (const char* fileName, deUint32 flags = 0);
 106                                                 ~TestLog                                (void);
 107
 108         MessageBuilder          operator<<                              (const BeginMessageToken&);
 109         MessageBuilder          message                                 (void);
 110
 111         TestLog&                        operator<<                              (const ImageSet& imageSet);
 112         TestLog&                        operator<<                              (const Image& image);
 113         TestLog&                        operator<<                              (const EndImageSetToken&);
 114
 115         TestLog&                        operator<<                              (const Section& section);
 116         TestLog&                        operator<<                              (const EndSectionToken&);
 117
 118         TestLog&                        operator<<                              (const ShaderProgram& shaderProgram);
 119         TestLog&                        operator<<                              (const EndShaderProgramToken&);
 120         TestLog&                        operator<<                              (const Shader& shader);
 121         TestLog&                        operator<<                              (const SpirVAssemblySource& module);
 122
 123         TestLog&                        operator<<                              (const KernelSource& kernelSrc);
 124
 125         template<typename T>
 126         TestLog&                        operator<<                              (const LogNumber<T>& number);
 127
 128         TestLog&                        operator<<                              (const SampleList& sampleList);
 129         TestLog&                        operator<<                              (const SampleInfoToken&);
 130         TestLog&                        operator<<                              (const ValueInfo& valueInfo);
 131         TestLog&                        operator<<                              (const EndSampleInfoToken&);
 132         SampleBuilder           operator<<                              (const BeginSampleToken&);
 133         TestLog&                        operator<<                              (const EndSampleListToken&);
 134
 135         // Raw api
 136         void                            writeMessage                    (const char* message);
 137
 138         void                            startImageSet                   (const char* name, const char* description);
 139         void                            endImageSet                             (void);
 140         void                            writeImage                              (const char* name, const char* description, const ConstPixelBufferAccess& surface, const Vec4& scale, const Vec4& bias, qpImageCompressionMode compressionMode = QP_IMAGE_COMPRESSION_MODE_BEST);
 141         void                            writeImage                              (const char* name, const char* description, qpImageCompressionMode compressionMode, qpImageFormat format, int width, int height, int stride, const void* data);
 142
 143         void                            startSection                    (const char* name, const char* description);
 144         void                            endSection                              (void);
 145
 146         void                            startShaderProgram              (bool linkOk, const char* linkInfoLog);
 147         void                            endShaderProgram                (void);
 148         void                            writeShader                             (qpShaderType type, const char* source, bool compileOk, const char* infoLog);
 149         void                            writeSpirVAssemblySource(const char* source);
 150         void                            writeKernelSource               (const char* source);
 151         void                            writeCompileInfo                (const char* name, const char* description, bool compileOk, const char* infoLog);
 152
 153         void                            writeFloat                              (const char* name, const char* description, const char* unit, qpKeyValueTag tag, float value);
 154         void                            writeInteger                    (const char* name, const char* description, const char* unit, qpKeyValueTag tag, deInt64 value);
 155
 156         void                            startEglConfigSet               (const char* name, const char* description);
 157         void                            writeEglConfig                  (const qpEglConfigInfo* config);
 158         void                            endEglConfigSet                 (void);
 159
 160         void                            startCase                               (const char* testCasePath, qpTestCaseType testCaseType);
 161         void                            endCase                                 (qpTestResult result, const char* description);
 162         void                            terminateCase                   (qpTestResult result);
 163
 164         void                            startSampleList                 (const std::string& name, const std::string& description);
 165         void                            startSampleInfo                 (void);
 166         void                            writeValueInfo                  (const std::string& name, const std::string& description, const std::string& unit, qpSampleValueTag tag);
 167         void                            endSampleInfo                   (void);
 168         void                            startSample                             (void);
 169         void                            writeSampleValue                (double value);
 170         void                            writeSampleValue                (deInt64 value);
 171         void                            endSample                               (void);
 172         void                            endSampleList                   (void);
 173
 174 private:
 175                                                 TestLog                                 (const TestLog& other); // Not allowed!
 176         TestLog&                        operator=                               (const TestLog& other); // Not allowed!
 177
 178         qpTestLog*                      m_log;
 179 };
 180
 181 class MessageBuilder
 182 {
 183 public:
 184         explicit                                MessageBuilder          (TestLog* log) : m_log(log) {}
 185                                                         ~MessageBuilder         (void) {}
 186
 187         std::string                             toString                        (void) const { return m_str.str(); }
 188
 189         TestLog&                                operator<<                      (const TestLog::EndMessageToken&);
 190
 191         template <typename T>
 192         MessageBuilder&                 operator<<                      (const T& value);
 193
 194                                                         MessageBuilder          (const MessageBuilder& other);
 195         MessageBuilder&                 operator=                       (const MessageBuilder& other);
 196
 197 private:
 198         TestLog*                                m_log;
 199         std::ostringstream              m_str;
 200 };
 201
 202 class SampleBuilder
 203 {
 204 public:
 205                                                         SampleBuilder           (TestLog* log) : m_log(log) {}
 206
 207         SampleBuilder&                  operator<<                      (int v)         { m_values.push_back(Value((deInt64)v));        return *this; }
 208         SampleBuilder&                  operator<<                      (deInt64 v)     { m_values.push_back(Value(v));                         return *this; }
 209         SampleBuilder&                  operator<<                      (float v)       { m_values.push_back(Value((double)v));         return *this; }
 210         SampleBuilder&                  operator<<                      (double v)      { m_values.push_back(Value(v));                         return *this; }
 211
 212         TestLog&                                operator<<                      (const TestLog::EndSampleToken&);
 213
 214 private:
 215         struct Value
 216         {
 217                 enum Type { TYPE_INT64 = 0, TYPE_FLOAT64, TYPE_LAST };
 218
 219                 Type    type;
 220                 union
 221                 {
 222                         deInt64         int64;
 223                         double          float64;
 224                 } value;
 225
 226                 Value (void)            : type(TYPE_LAST)               { value.int64 = 0;              }
 227                 Value (double v)        : type(TYPE_FLOAT64)    { value.float64 = v;    }
 228                 Value (deInt64 v)       : type(TYPE_INT64)              { value.int64 = v;              }
 229         };
 230
 231         TestLog*                                m_log;
 232         std::vector<Value>              m_values;
 233 };
 234
 235 class LogImageSet
 236 {
 237 public:
 238         LogImageSet (const std::string& name, const std::string& description)
 239                 : m_name                (name)
 240                 , m_description (description)
 241         {
 242         }
 243
 244         void write (TestLog& log) const;
 245
 246 private:
 247         std::string             m_name;
 248         std::string             m_description;
 249 };
 250
 251 // \note Doesn't take copy of surface contents
 252 class LogImage
 253 {
 254 public:
 255         LogImage (const std::string& name, const std::string& description, const Surface& surface, qpImageCompressionMode compression = QP_IMAGE_COMPRESSION_MODE_BEST);
 256
 257         LogImage (const std::string& name, const std::string& description, const ConstPixelBufferAccess& access, qpImageCompressionMode compression = QP_IMAGE_COMPRESSION_MODE_BEST);
 258
 259         LogImage (const std::string& name, const std::string& description, const ConstPixelBufferAccess& access, const Vec4& scale, const Vec4& bias, qpImageCompressionMode compression = QP_IMAGE_COMPRESSION_MODE_BEST);
 260
 261         void write (TestLog& log) const;
 262
 263 private:
 264         std::string                             m_name;
 265         std::string                             m_description;
 266         ConstPixelBufferAccess  m_access;
 267         Vec4                                    m_scale;
 268         Vec4                                    m_bias;
 269         qpImageCompressionMode  m_compression;
 270 };
 271
 272 class LogSection
 273 {
 274 public:
 275         LogSection (const std::string& name, const std::string& description)
 276                 : m_name                (name)
 277                 , m_description (description)
 278         {
 279         }
 280
 281         void write (TestLog& log) const;
 282
 283 private:
 284         std::string             m_name;
 285         std::string             m_description;
 286 };
 287
 288 class LogShaderProgram
 289 {
 290 public:
 291         LogShaderProgram (bool linkOk, const std::string& linkInfoLog)
 292                 : m_linkOk              (linkOk)
 293                 , m_linkInfoLog (linkInfoLog)
 294         {
 295         }
 296
 297         void write (TestLog& log) const;
 298
 299 private:
 300         bool                    m_linkOk;
 301         std::string             m_linkInfoLog;
 302 };
 303
 304 class LogShader
 305 {
 306 public:
 307         LogShader (qpShaderType type, const std::string& source, bool compileOk, const std::string& infoLog)
 308                 : m_type                (type)
 309                 , m_source              (source)
 310                 , m_compileOk   (compileOk)
 311                 , m_infoLog             (infoLog)
 312         {
 313         }
 314
 315         void write (TestLog& log) const;
 316
 317 private:
 318         qpShaderType    m_type;
 319         std::string             m_source;
 320         bool                    m_compileOk;
 321         std::string             m_infoLog;
 322 };
 323
 324 class LogSpirVAssemblySource
 325 {
 326 public:
 327         LogSpirVAssemblySource (const std::string& source)
 328                 : m_source              (source)
 329         {
 330         }
 331
 332         void write (TestLog& log) const;
 333
 334 private:
 335         std::string             m_source;
 336 };
 337
 338 class LogKernelSource
 339 {
 340 public:
 341         explicit LogKernelSource (const std::string& source)
 342                 : m_source(source)
 343         {
 344         }
 345
 346         void write (TestLog& log) const;
 347
 348 private:
 349         std::string     m_source;
 350 };
 351
 352 class LogSampleList
 353 {
 354 public:
 355         LogSampleList (const std::string& name, const std::string& description)
 356                 : m_name                (name)
 357                 , m_description (description)
 358         {
 359         }
 360
 361         void write (TestLog& log) const;
 362
 363 private:
 364         std::string             m_name;
 365         std::string             m_description;
 366 };
 367
 368 class LogValueInfo
 369 {
 370 public:
 371         LogValueInfo (const std::string& name, const std::string& description, const std::string& unit, qpSampleValueTag tag)
 372                 : m_name                (name)
 373                 , m_description (description)
 374                 , m_unit                (unit)
 375                 , m_tag                 (tag)
 376         {
 377         }
 378
 379         void write (TestLog& log) const;
 380
 381 private:
 382         std::string                     m_name;
 383         std::string                     m_description;
 384         std::string                     m_unit;
 385         qpSampleValueTag        m_tag;
 386 };
 387
 388 template<typename T>
 389 class LogNumber
 390 {
 391 public:
 392         LogNumber (const std::string& name, const std::string& desc, const std::string& unit, qpKeyValueTag tag, T value)
 393                 : m_name        (name)
 394                 , m_desc        (desc)
 395                 , m_unit        (unit)
 396                 , m_tag         (tag)
 397                 , m_value       (value)
 398         {
 399         }
 400
 401         void write (TestLog& log) const;
 402
 403 private:
 404         std::string             m_name;
 405         std::string             m_desc;
 406         std::string             m_unit;
 407         qpKeyValueTag   m_tag;
 408         T                               m_value;
 409 };
 410
 411 // Section helper that closes section when leaving scope.
 412 class ScopedLogSection
 413 {
 414 public:
 415         ScopedLogSection (TestLog& log, const std::string& name, const std::string& description)
 416                 : m_log(log)
 417         {
 418                 m_log << TestLog::Section(name, description);
 419         }
 420
 421         ~ScopedLogSection (void)
 422         {
 423                 m_log << TestLog::EndSection;
 424         }
 425
 426 private:
 427         TestLog& m_log;
 428 };
 429
 430 // TestLog stream operators.
 431
 432 inline TestLog& TestLog::operator<< (const ImageSet& imageSet)                  { imageSet.write(*this);        return *this;   }
 433 inline TestLog& TestLog::operator<< (const Image& image)                                { image.write(*this);           return *this;   }
 434 inline TestLog& TestLog::operator<< (const EndImageSetToken&)                   { endImageSet();                        return *this;   }
 435 inline TestLog& TestLog::operator<< (const Section& section)                    { section.write(*this);         return *this;   }
 436 inline TestLog& TestLog::operator<< (const EndSectionToken&)                    { endSection();                         return *this;   }
 437 inline TestLog& TestLog::operator<< (const ShaderProgram& shaderProg)   { shaderProg.write(*this);      return *this;   }
 438 inline TestLog& TestLog::operator<< (const EndShaderProgramToken&)              { endShaderProgram();           return *this;   }
 439 inline TestLog& TestLog::operator<< (const Shader& shader)                              { shader.write(*this);          return *this;   }
 440 inline TestLog& TestLog::operator<< (const SpirVAssemblySource& module) { module.write(*this);          return *this;   }
 441 inline TestLog& TestLog::operator<< (const KernelSource& kernelSrc)             { kernelSrc.write(*this);       return *this;   }
 442 inline TestLog& TestLog::operator<<     (const SampleList& sampleList)          { sampleList.write(*this);      return *this;   }
 443 inline TestLog& TestLog::operator<<     (const SampleInfoToken&)                        { startSampleInfo();            return *this;   }
 444 inline TestLog& TestLog::operator<<     (const ValueInfo& valueInfo)            { valueInfo.write(*this);       return *this;   }
 445 inline TestLog& TestLog::operator<<     (const EndSampleInfoToken&)                     { endSampleInfo();                      return *this;   }
 446 inline TestLog& TestLog::operator<<     (const EndSampleListToken&)                     { endSampleList();                      return *this;   }
 447
 448 template<typename T>
 449 inline TestLog& TestLog::operator<< (const LogNumber<T>& number)
 450 {
 451         number.write(*this);
 452         return *this;
 453 }
 454
 455 inline TestLog& operator<< (TestLog& log, const std::exception& e)
 456 {
 457         // \todo [2012-10-18 pyry] Print type info?
 458         return log << TestLog::Message << e.what() << TestLog::EndMessage;
 459 }
 460
 461 // Utility class inline implementations.
 462
 463 template <typename T>
 464 inline MessageBuilder& MessageBuilder::operator<< (const T& value)
 465 {
 466         // Overload stream operator to implement custom format
 467         m_str << value;
 468         return *this;
 469 }
 470
 471 inline MessageBuilder TestLog::operator<< (const BeginMessageToken&)
 472 {
 473         return MessageBuilder(this);
 474 }
 475
 476 inline MessageBuilder TestLog::message (void)
 477 {
 478         return MessageBuilder(this);
 479 }
 480
 481 inline SampleBuilder TestLog::operator<< (const BeginSampleToken&)
 482 {
 483         return SampleBuilder(this);
 484 }
 485
 486 inline void LogImageSet::write (TestLog& log) const
 487 {
 488         log.startImageSet(m_name.c_str(), m_description.c_str());
 489 }
 490
 491 inline void LogSection::write (TestLog& log) const
 492 {
 493         log.startSection(m_name.c_str(), m_description.c_str());
 494 }
 495
 496 inline void LogShaderProgram::write (TestLog& log) const
 497 {
 498         log.startShaderProgram(m_linkOk, m_linkInfoLog.c_str());
 499 }
 500
 501 inline void LogShader::write (TestLog& log) const
 502 {
 503         log.writeShader(m_type, m_source.c_str(), m_compileOk, m_infoLog.c_str());
 504 }
 505
 506 inline void LogSpirVAssemblySource::write (TestLog& log) const
 507 {
 508         log.writeSpirVAssemblySource(m_source.c_str());
 509 }
 510
 511 inline void LogKernelSource::write (TestLog& log) const
 512 {
 513         log.writeKernelSource(m_source.c_str());
 514 }
 515
 516 inline void LogSampleList::write (TestLog& log) const
 517 {
 518         log.startSampleList(m_name, m_description);
 519 }
 520
 521 inline void LogValueInfo::write (TestLog& log) const
 522 {
 523         log.writeValueInfo(m_name, m_description, m_unit, m_tag);
 524 }
 525
 526 template<>
 527 inline void LogNumber<float>::write (TestLog& log) const
 528 {
 529         log.writeFloat(m_name.c_str(), m_desc.c_str(), m_unit.c_str(), m_tag, m_value);
 530 }
 531
 532 template<>
 533 inline void LogNumber<deInt64>::write (TestLog& log) const
 534 {
 535         log.writeInteger(m_name.c_str(), m_desc.c_str(), m_unit.c_str(), m_tag, m_value);
 536 }
 537
 538 } // tcu
 539
 540 #endif // _TCUTESTLOG_HPP