modules/internal/ditFrameworkTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Internal Test Module
   3  * ---------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Miscellaneous framework tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "ditFrameworkTests.hpp"
  25 #include "ditTextureFormatTests.hpp"
  26 #include "ditAstcTests.hpp"
  27 #include "ditVulkanTests.hpp"
  28
  29 #include "tcuFloatFormat.hpp"
  30 #include "tcuEither.hpp"
  31 #include "tcuTestLog.hpp"
  32 #include "tcuCommandLine.hpp"
  33
  34 #include "rrRenderer.hpp"
  35 #include "tcuTextureUtil.hpp"
  36 #include "tcuVectorUtil.hpp"
  37 #include "tcuFloat.hpp"
  38
  39 #include "deRandom.hpp"
  40 #include "deArrayUtil.hpp"
  41
  42 #include <stdexcept>
  43
  44 namespace dit
  45 {
  46
  47 namespace
  48 {
  49
  50 using std::string;
  51 using std::vector;
  52 using tcu::TestLog;
  53
  54 struct MatchCase
  55 {
  56         enum Expected { NO_MATCH, MATCH_GROUP, MATCH_CASE, EXPECTED_LAST };
  57
  58         const char*     path;
  59         Expected        expected;
  60 };
  61
  62 const char* getMatchCaseExpectedDesc (MatchCase::Expected expected)
  63 {
  64         static const char* descs[] =
  65         {
  66                 "no match",
  67                 "group to match",
  68                 "case to match"
  69         };
  70         return de::getSizedArrayElement<MatchCase::EXPECTED_LAST>(descs, expected);
  71 }
  72
  73 class CaseListParserCase : public tcu::TestCase
  74 {
  75 public:
  76         CaseListParserCase (tcu::TestContext& testCtx, const char* name, const char* caseList, const MatchCase* subCases, int numSubCases)
  77                 : tcu::TestCase (testCtx, name, "")
  78                 , m_caseList    (caseList)
  79                 , m_subCases    (subCases)
  80                 , m_numSubCases (numSubCases)
  81         {
  82         }
  83
  84         IterateResult iterate (void)
  85         {
  86                 TestLog&                                                        log             = m_testCtx.getLog();
  87                 tcu::CommandLine                                        cmdLine;
  88                 de::MovePtr<tcu::CaseListFilter>        caseListFilter;
  89                 int                                                                     numPass = 0;
  90
  91                 log << TestLog::Message << "Input:\n\"" << m_caseList << "\"" << TestLog::EndMessage;
  92
  93                 {
  94                         const char* argv[] =
  95                         {
  96                                 "deqp",
  97                                 "--deqp-caselist",
  98                                 m_caseList
  99                         };
 100
 101                         if (!cmdLine.parse(DE_LENGTH_OF_ARRAY(argv), argv))
 102                                 TCU_FAIL("Failed to parse command line");
 103                 }
 104
 105                 caseListFilter = cmdLine.createCaseListFilter(m_testCtx.getArchive());
 106
 107                 for (int subCaseNdx = 0; subCaseNdx < m_numSubCases; subCaseNdx++)
 108                 {
 109                         const MatchCase&        curCase         = m_subCases[subCaseNdx];
 110                         bool                            matchGroup;
 111                         bool                            matchCase;
 112
 113                         log << TestLog::Message << "Checking \"" << curCase.path << "\""
 114                                                                         << ", expecting " << getMatchCaseExpectedDesc(curCase.expected)
 115                                 << TestLog::EndMessage;
 116
 117                         matchGroup      = caseListFilter->checkTestGroupName(curCase.path);
 118                         matchCase       = caseListFilter->checkTestCaseName(curCase.path);
 119
 120                         if ((matchGroup == (curCase.expected == MatchCase::MATCH_GROUP)) &&
 121                                 (matchCase      == (curCase.expected == MatchCase::MATCH_CASE)))
 122                         {
 123                                 log << TestLog::Message << "   pass" << TestLog::EndMessage;
 124                                 numPass += 1;
 125                         }
 126                         else
 127                                 log << TestLog::Message << "   FAIL!" << TestLog::EndMessage;
 128                 }
 129
 130                 m_testCtx.setTestResult((numPass == m_numSubCases) ? QP_TEST_RESULT_PASS        : QP_TEST_RESULT_FAIL,
 131                                                                 (numPass == m_numSubCases) ? "All passed"                       : "Unexpected match result");
 132
 133                 return STOP;
 134         }
 135
 136 private:
 137         const char* const                       m_caseList;
 138         const MatchCase* const          m_subCases;
 139         const int                                       m_numSubCases;
 140 };
 141
 142 class NegativeCaseListCase : public tcu::TestCase
 143 {
 144 public:
 145         NegativeCaseListCase (tcu::TestContext& testCtx, const char* name, const char* caseList)
 146                 : tcu::TestCase (testCtx, name, "")
 147                 , m_caseList    (caseList)
 148         {
 149         }
 150
 151         IterateResult iterate (void)
 152         {
 153                 TestLog&                        log             = m_testCtx.getLog();
 154                 tcu::CommandLine        cmdLine;
 155
 156                 log << TestLog::Message << "Input:\n\"" << m_caseList << "\"" << TestLog::EndMessage;
 157
 158                 {
 159                         const char* argv[] =
 160                         {
 161                                 "deqp",
 162                                 "--deqp-caselist",
 163                                 m_caseList
 164                         };
 165
 166                         TCU_CHECK(cmdLine.parse(DE_LENGTH_OF_ARRAY(argv), argv));
 167
 168                         try
 169                         {
 170                                 de::UniquePtr<tcu::CaseListFilter>      filter  (cmdLine.createCaseListFilter(m_testCtx.getArchive()));
 171
 172                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Parsing passed, should have failed");
 173                         }
 174                         catch (const std::invalid_argument& e)
 175                         {
 176                                 log << TestLog::Message << e.what() << TestLog::EndMessage;
 177                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Parsing failed as expected");
 178                         }
 179                 }
 180
 181                 return STOP;
 182         }
 183
 184 private:
 185         const char* const       m_caseList;
 186 };
 187
 188 class TrieParserTests : public tcu::TestCaseGroup
 189 {
 190 public:
 191         TrieParserTests (tcu::TestContext& testCtx)
 192                 : tcu::TestCaseGroup(testCtx, "trie", "Test case trie parser tests")
 193         {
 194         }
 195
 196         void init (void)
 197         {
 198                 {
 199                         static const char* const        caseList        = "{test}";
 200                         static const MatchCase          subCases[]      =
 201                         {
 202                                 { "test",               MatchCase::MATCH_CASE   },
 203                                 { "test.cd",    MatchCase::NO_MATCH             },
 204                         };
 205                         addChild(new CaseListParserCase(m_testCtx, "single_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 206                 }
 207                 {
 208                         static const char* const        caseList        = "{a{b}}";
 209                         static const MatchCase          subCases[]      =
 210                         {
 211                                 { "a",          MatchCase::MATCH_GROUP  },
 212                                 { "b",          MatchCase::NO_MATCH             },
 213                                 { "a.b",        MatchCase::MATCH_CASE   },
 214                                 { "a.a",        MatchCase::NO_MATCH             },
 215                         };
 216                         addChild(new CaseListParserCase(m_testCtx, "simple_group_1", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 217                 }
 218                 {
 219                         static const char* const        caseList        = "{a{b,c}}";
 220                         static const MatchCase          subCases[]      =
 221                         {
 222                                 { "a",          MatchCase::MATCH_GROUP  },
 223                                 { "b",          MatchCase::NO_MATCH             },
 224                                 { "a.b",        MatchCase::MATCH_CASE   },
 225                                 { "a.a",        MatchCase::NO_MATCH             },
 226                                 { "a.c",        MatchCase::MATCH_CASE   },
 227                         };
 228                         addChild(new CaseListParserCase(m_testCtx, "simple_group_2", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 229                 }
 230                 {
 231                         static const char* const        caseList        = "{a{b},c{d,e}}";
 232                         static const MatchCase          subCases[]      =
 233                         {
 234                                 { "a",          MatchCase::MATCH_GROUP  },
 235                                 { "b",          MatchCase::NO_MATCH             },
 236                                 { "a.b",        MatchCase::MATCH_CASE   },
 237                                 { "a.c",        MatchCase::NO_MATCH             },
 238                                 { "a.d",        MatchCase::NO_MATCH             },
 239                                 { "a.e",        MatchCase::NO_MATCH             },
 240                                 { "c",          MatchCase::MATCH_GROUP  },
 241                                 { "c.b",        MatchCase::NO_MATCH             },
 242                                 { "c.d",        MatchCase::MATCH_CASE   },
 243                                 { "c.e",        MatchCase::MATCH_CASE   },
 244                         };
 245                         addChild(new CaseListParserCase(m_testCtx, "two_groups", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 246                 }
 247                 {
 248                         static const char* const        caseList        = "{a,c{d,e}}";
 249                         static const MatchCase          subCases[]      =
 250                         {
 251                                 { "a",          MatchCase::MATCH_CASE   },
 252                                 { "b",          MatchCase::NO_MATCH             },
 253                                 { "a.b",        MatchCase::NO_MATCH             },
 254                                 { "a.c",        MatchCase::NO_MATCH             },
 255                                 { "a.d",        MatchCase::NO_MATCH             },
 256                                 { "a.e",        MatchCase::NO_MATCH             },
 257                                 { "c",          MatchCase::MATCH_GROUP  },
 258                                 { "c.b",        MatchCase::NO_MATCH             },
 259                                 { "c.d",        MatchCase::MATCH_CASE   },
 260                                 { "c.e",        MatchCase::MATCH_CASE   },
 261                         };
 262                         addChild(new CaseListParserCase(m_testCtx, "case_group", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 263                 }
 264                 {
 265                         static const char* const        caseList        = "{c{d,e},a}";
 266                         static const MatchCase          subCases[]      =
 267                         {
 268                                 { "a",          MatchCase::MATCH_CASE   },
 269                                 { "b",          MatchCase::NO_MATCH             },
 270                                 { "a.b",        MatchCase::NO_MATCH             },
 271                                 { "a.c",        MatchCase::NO_MATCH             },
 272                                 { "a.d",        MatchCase::NO_MATCH             },
 273                                 { "a.e",        MatchCase::NO_MATCH             },
 274                                 { "c",          MatchCase::MATCH_GROUP  },
 275                                 { "c.b",        MatchCase::NO_MATCH             },
 276                                 { "c.d",        MatchCase::MATCH_CASE   },
 277                                 { "c.e",        MatchCase::MATCH_CASE   },
 278                         };
 279                         addChild(new CaseListParserCase(m_testCtx, "group_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 280                 }
 281                 {
 282                         static const char* const        caseList        = "{test}\r";
 283                         static const MatchCase          subCases[]      =
 284                         {
 285                                 { "test",               MatchCase::MATCH_CASE   },
 286                                 { "test.cd",    MatchCase::NO_MATCH             },
 287                         };
 288                         addChild(new CaseListParserCase(m_testCtx, "trailing_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 289                 }
 290                 {
 291                         static const char* const        caseList        = "{test}\n";
 292                         static const MatchCase          subCases[]      =
 293                         {
 294                                 { "test",               MatchCase::MATCH_CASE   },
 295                                 { "test.cd",    MatchCase::NO_MATCH             },
 296                         };
 297                         addChild(new CaseListParserCase(m_testCtx, "trailing_lf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 298                 }
 299                 {
 300                         static const char* const        caseList        = "{test}\r\n";
 301                         static const MatchCase          subCases[]      =
 302                         {
 303                                 { "test",               MatchCase::MATCH_CASE   },
 304                                 { "test.cd",    MatchCase::NO_MATCH             },
 305                         };
 306                         addChild(new CaseListParserCase(m_testCtx, "trailing_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 307                 }
 308
 309                 // Negative tests
 310                 addChild(new NegativeCaseListCase(m_testCtx, "empty_string",                    ""));
 311                 addChild(new NegativeCaseListCase(m_testCtx, "empty_line",                              "\n"));
 312                 addChild(new NegativeCaseListCase(m_testCtx, "empty_root",                              "{}"));
 313                 addChild(new NegativeCaseListCase(m_testCtx, "empty_group",                             "{test{}}"));
 314                 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name_1",              "{{}}"));
 315                 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name_2",              "{{test}}"));
 316                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_1",             "{"));
 317                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_2",             "{test"));
 318                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_3",             "{test,"));
 319                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_4",             "{test{a}"));
 320                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_5",             "{a,b"));
 321                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_1",    "{test{"));
 322                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_2",    "{test{a"));
 323                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_3",    "{test{a,"));
 324                 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_4",    "{test{a,b"));
 325                 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_1",               "{a,,b}"));
 326                 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_2",               "{,b}"));
 327                 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_3",               "{a,}"));
 328                 addChild(new NegativeCaseListCase(m_testCtx, "no_separator",                    "{a{b}c}"));
 329                 addChild(new NegativeCaseListCase(m_testCtx, "invalid_char_1",                  "{a.b}"));
 330                 addChild(new NegativeCaseListCase(m_testCtx, "invalid_char_2",                  "{a[]}"));
 331                 addChild(new NegativeCaseListCase(m_testCtx, "trailing_char_1",                 "{a}}"));
 332                 addChild(new NegativeCaseListCase(m_testCtx, "trailing_char_2",                 "{a}x"));
 333                 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_1",              "{\na}"));
 334                 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_2",              "{a\n,b}"));
 335                 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_3",              "{a,\nb}"));
 336                 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_4",              "{a{b\n}}"));
 337                 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_5",              "{a{b}\n}"));
 338         }
 339 };
 340
 341 class ListParserTests : public tcu::TestCaseGroup
 342 {
 343 public:
 344         ListParserTests (tcu::TestContext& testCtx)
 345                 : tcu::TestCaseGroup(testCtx, "list", "Test case list parser tests")
 346         {
 347         }
 348
 349         void init (void)
 350         {
 351                 {
 352                         static const char* const        caseList        = "test";
 353                         static const MatchCase          subCases[]      =
 354                         {
 355                                 { "test",               MatchCase::MATCH_CASE   },
 356                                 { "test.cd",    MatchCase::NO_MATCH             },
 357                         };
 358                         addChild(new CaseListParserCase(m_testCtx, "single_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 359                 }
 360                 {
 361                         static const char* const        caseList        = "a.b";
 362                         static const MatchCase          subCases[]      =
 363                         {
 364                                 { "a",          MatchCase::MATCH_GROUP  },
 365                                 { "b",          MatchCase::NO_MATCH             },
 366                                 { "a.b",        MatchCase::MATCH_CASE   },
 367                                 { "a.a",        MatchCase::NO_MATCH             },
 368                         };
 369                         addChild(new CaseListParserCase(m_testCtx, "simple_group_1", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 370                 }
 371                 {
 372                         static const char* const        caseList        = "a.b\na.c";
 373                         static const MatchCase          subCases[]      =
 374                         {
 375                                 { "a",          MatchCase::MATCH_GROUP  },
 376                                 { "b",          MatchCase::NO_MATCH             },
 377                                 { "a.b",        MatchCase::MATCH_CASE   },
 378                                 { "a.a",        MatchCase::NO_MATCH             },
 379                                 { "a.c",        MatchCase::MATCH_CASE   },
 380                         };
 381                         addChild(new CaseListParserCase(m_testCtx, "simple_group_2", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 382                 }
 383                 {
 384                         static const char* const        caseList        = "a.b\na.c";
 385                         static const MatchCase          subCases[]      =
 386                         {
 387                                 { "a",          MatchCase::MATCH_GROUP  },
 388                                 { "b",          MatchCase::NO_MATCH             },
 389                                 { "a.b",        MatchCase::MATCH_CASE   },
 390                                 { "a.a",        MatchCase::NO_MATCH             },
 391                                 { "a.c",        MatchCase::MATCH_CASE   },
 392                         };
 393                         addChild(new CaseListParserCase(m_testCtx, "separator_ln", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 394                 }
 395                 {
 396                         static const char* const        caseList        = "a.b\ra.c";
 397                         static const MatchCase          subCases[]      =
 398                         {
 399                                 { "a",          MatchCase::MATCH_GROUP  },
 400                                 { "b",          MatchCase::NO_MATCH             },
 401                                 { "a.b",        MatchCase::MATCH_CASE   },
 402                                 { "a.a",        MatchCase::NO_MATCH             },
 403                                 { "a.c",        MatchCase::MATCH_CASE   },
 404                         };
 405                         addChild(new CaseListParserCase(m_testCtx, "separator_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 406                 }
 407                 {
 408                         static const char* const        caseList        = "a.b\r\na.c";
 409                         static const MatchCase          subCases[]      =
 410                         {
 411                                 { "a",          MatchCase::MATCH_GROUP  },
 412                                 { "b",          MatchCase::NO_MATCH             },
 413                                 { "a.b",        MatchCase::MATCH_CASE   },
 414                                 { "a.a",        MatchCase::NO_MATCH             },
 415                                 { "a.c",        MatchCase::MATCH_CASE   },
 416                         };
 417                         addChild(new CaseListParserCase(m_testCtx, "separator_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 418                 }
 419                 {
 420                         static const char* const        caseList        = "a.b\na.c\n";
 421                         static const MatchCase          subCases[]      =
 422                         {
 423                                 { "a",          MatchCase::MATCH_GROUP  },
 424                                 { "b",          MatchCase::NO_MATCH             },
 425                                 { "a.b",        MatchCase::MATCH_CASE   },
 426                                 { "a.a",        MatchCase::NO_MATCH             },
 427                                 { "a.c",        MatchCase::MATCH_CASE   },
 428                         };
 429                         addChild(new CaseListParserCase(m_testCtx, "end_ln", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 430                 }
 431                 {
 432                         static const char* const        caseList        = "a.b\na.c\r";
 433                         static const MatchCase          subCases[]      =
 434                         {
 435                                 { "a",          MatchCase::MATCH_GROUP  },
 436                                 { "b",          MatchCase::NO_MATCH             },
 437                                 { "a.b",        MatchCase::MATCH_CASE   },
 438                                 { "a.a",        MatchCase::NO_MATCH             },
 439                                 { "a.c",        MatchCase::MATCH_CASE   },
 440                         };
 441                         addChild(new CaseListParserCase(m_testCtx, "end_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 442                 }
 443                 {
 444                         static const char* const        caseList        = "a.b\na.c\r\n";
 445                         static const MatchCase          subCases[]      =
 446                         {
 447                                 { "a",          MatchCase::MATCH_GROUP  },
 448                                 { "b",          MatchCase::NO_MATCH             },
 449                                 { "a.b",        MatchCase::MATCH_CASE   },
 450                                 { "a.a",        MatchCase::NO_MATCH             },
 451                                 { "a.c",        MatchCase::MATCH_CASE   },
 452                         };
 453                         addChild(new CaseListParserCase(m_testCtx, "end_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 454                 }
 455                 {
 456                         static const char* const        caseList        = "a.b\nc.d\nc.e";
 457                         static const MatchCase          subCases[]      =
 458                         {
 459                                 { "a",          MatchCase::MATCH_GROUP  },
 460                                 { "b",          MatchCase::NO_MATCH             },
 461                                 { "a.b",        MatchCase::MATCH_CASE   },
 462                                 { "a.c",        MatchCase::NO_MATCH             },
 463                                 { "a.d",        MatchCase::NO_MATCH             },
 464                                 { "a.e",        MatchCase::NO_MATCH             },
 465                                 { "c",          MatchCase::MATCH_GROUP  },
 466                                 { "c.b",        MatchCase::NO_MATCH             },
 467                                 { "c.d",        MatchCase::MATCH_CASE   },
 468                                 { "c.e",        MatchCase::MATCH_CASE   },
 469                         };
 470                         addChild(new CaseListParserCase(m_testCtx, "two_groups", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 471                 }
 472                 {
 473                         static const char* const        caseList        = "a\nc.d\nc.e";
 474                         static const MatchCase          subCases[]      =
 475                         {
 476                                 { "a",          MatchCase::MATCH_CASE   },
 477                                 { "b",          MatchCase::NO_MATCH             },
 478                                 { "a.b",        MatchCase::NO_MATCH             },
 479                                 { "a.c",        MatchCase::NO_MATCH             },
 480                                 { "a.d",        MatchCase::NO_MATCH             },
 481                                 { "a.e",        MatchCase::NO_MATCH             },
 482                                 { "c",          MatchCase::MATCH_GROUP  },
 483                                 { "c.b",        MatchCase::NO_MATCH             },
 484                                 { "c.d",        MatchCase::MATCH_CASE   },
 485                                 { "c.e",        MatchCase::MATCH_CASE   },
 486                         };
 487                         addChild(new CaseListParserCase(m_testCtx, "case_group", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 488                 }
 489                 {
 490                         static const char* const        caseList        = "c.d\nc.e\na";
 491                         static const MatchCase          subCases[]      =
 492                         {
 493                                 { "a",          MatchCase::MATCH_CASE   },
 494                                 { "b",          MatchCase::NO_MATCH             },
 495                                 { "a.b",        MatchCase::NO_MATCH             },
 496                                 { "a.c",        MatchCase::NO_MATCH             },
 497                                 { "a.d",        MatchCase::NO_MATCH             },
 498                                 { "a.e",        MatchCase::NO_MATCH             },
 499                                 { "c",          MatchCase::MATCH_GROUP  },
 500                                 { "c.b",        MatchCase::NO_MATCH             },
 501                                 { "c.d",        MatchCase::MATCH_CASE   },
 502                                 { "c.e",        MatchCase::MATCH_CASE   },
 503                         };
 504                         addChild(new CaseListParserCase(m_testCtx, "group_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 505                 }
 506                 {
 507                         static const char* const        caseList        = "a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.x";
 508                         static const MatchCase          subCases[]      =
 509                         {
 510                                 { "a",                                                                                          MatchCase::MATCH_GROUP  },
 511                                 { "b",                                                                                          MatchCase::NO_MATCH             },
 512                                 { "a.b",                                                                                        MatchCase::MATCH_GROUP  },
 513                                 { "a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.x",      MatchCase::MATCH_CASE   },
 514                         };
 515                         addChild(new CaseListParserCase(m_testCtx, "long_name", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 516                 }
 517                 {
 518                         static const char* const        caseList        =
 519                                 "a.b.c.d.e\n"
 520                                 "a.b.c.f\n"
 521                                 "x.y.z\n"
 522                                 "a.b.c.d.g\n"
 523                                 "a.b.c.x\n";
 524                         static const MatchCase          subCases[]      =
 525                         {
 526                                 { "a",                          MatchCase::MATCH_GROUP  },
 527                                 { "a.b",                        MatchCase::MATCH_GROUP  },
 528                                 { "a.b.c.d.e",          MatchCase::MATCH_CASE   },
 529                                 { "a.b.c.d.g",          MatchCase::MATCH_CASE   },
 530                                 { "x.y",                        MatchCase::MATCH_GROUP  },
 531                                 { "x.y.z",                      MatchCase::MATCH_CASE   },
 532                                 { "a.b.c.f",            MatchCase::MATCH_CASE   },
 533                                 { "a.b.c.x",            MatchCase::MATCH_CASE   },
 534                         };
 535                         addChild(new CaseListParserCase(m_testCtx, "partial_prefix", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 536                 }
 537                 {
 538                         static const char* const        caseList        =
 539                                 "a.a.c.d\n"
 540                                 "a.b.c.d\n";
 541                         static const MatchCase          subCases[]      =
 542                         {
 543                                 { "a",                          MatchCase::MATCH_GROUP  },
 544                                 { "a.a",                        MatchCase::MATCH_GROUP  },
 545                                 { "a.b.c.d",            MatchCase::MATCH_CASE   },
 546                                 { "a.b.c.d",            MatchCase::MATCH_CASE   },
 547                         };
 548                         addChild(new CaseListParserCase(m_testCtx, "reparenting", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases)));
 549                 }
 550
 551                 // Negative tests
 552                 addChild(new NegativeCaseListCase(m_testCtx, "empty_string",                    ""));
 553                 addChild(new NegativeCaseListCase(m_testCtx, "empty_line",                              "\n"));
 554                 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name",                ".test"));
 555                 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name",                 "test."));
 556         }
 557 };
 558
 559 class CaseListParserTests : public tcu::TestCaseGroup
 560 {
 561 public:
 562         CaseListParserTests (tcu::TestContext& testCtx)
 563                 : tcu::TestCaseGroup(testCtx, "case_list_parser", "Test case list parser tests")
 564         {
 565         }
 566
 567         void init (void)
 568         {
 569                 addChild(new TrieParserTests(m_testCtx));
 570                 addChild(new ListParserTests(m_testCtx));
 571         }
 572 };
 573
 574 inline deUint32 ulpDiff (float a, float b)
 575 {
 576         const deUint32 ab = tcu::Float32(a).bits();
 577         const deUint32 bb = tcu::Float32(b).bits();
 578         return de::max(ab, bb) - de::min(ab, bb);
 579 }
 580
 581 template<int Size>
 582 inline tcu::Vector<deUint32, Size> ulpDiff (const tcu::Vector<float, Size>& a, const tcu::Vector<float,  Size>& b)
 583 {
 584         tcu::Vector<deUint32, Size> res;
 585         for (int ndx = 0; ndx < Size; ndx++)
 586                 res[ndx] = ulpDiff(a[ndx], b[ndx]);
 587         return res;
 588 }
 589
 590 class ConstantInterpolationTest : public tcu::TestCase
 591 {
 592 public:
 593         ConstantInterpolationTest (tcu::TestContext& testCtx)
 594                 : tcu::TestCase(testCtx, "const_interpolation", "Constant value interpolation")
 595         {
 596                 const int supportedMsaaLevels[] = {1, 2, 4, 8, 16};
 597
 598                 for (int msaaNdx = 0; msaaNdx < DE_LENGTH_OF_ARRAY(supportedMsaaLevels); msaaNdx++)
 599                 {
 600                         const int numSamples = supportedMsaaLevels[msaaNdx];
 601                         {
 602                                 SubCase c;
 603                                 c.rtSize        = tcu::IVec3(128, 128, numSamples);
 604                                 c.vtx[0]        = tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f);
 605                                 c.vtx[1]        = tcu::Vec4(-1.0f, +1.0f, 0.5f, 1.0f);
 606                                 c.vtx[2]        = tcu::Vec4(+1.0f, -1.0f, 0.5f, 1.0f);
 607                                 c.varying       = tcu::Vec4(0.0f, 1.0f, 8.0f, -8.0f);
 608                                 m_cases.push_back(c);
 609                         }
 610
 611                         {
 612                                 SubCase c;
 613                                 c.rtSize        = tcu::IVec3(128, 128, numSamples);
 614                                 c.vtx[0]        = tcu::Vec4(-1.0f, +1.0f, 0.5f, 1.0f);
 615                                 c.vtx[1]        = tcu::Vec4(+1.0f, -1.0f, 0.5f, 1.0f);
 616                                 c.vtx[2]        = tcu::Vec4(+1.0f, +1.0f, 0.5f, 1.0f);
 617                                 c.varying       = tcu::Vec4(0.0f, 1.0f, 8.0f, -8.0f);
 618                                 m_cases.push_back(c);
 619                         }
 620                         {
 621                                 SubCase c;
 622                                 c.rtSize        = tcu::IVec3(129, 113, numSamples);
 623                                 c.vtx[0]        = tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f);
 624                                 c.vtx[1]        = tcu::Vec4(-1.0f, +1.0f, 0.5f, 1.0f);
 625                                 c.vtx[2]        = tcu::Vec4(+1.0f, -1.0f, 0.5f, 1.0f);
 626                                 c.varying       = tcu::Vec4(0.0f, 1.0f, 8.0f, -8.0f);
 627                                 m_cases.push_back(c);
 628                         }
 629                         {
 630                                 SubCase c;
 631                                 c.rtSize        = tcu::IVec3(107, 131, numSamples);
 632                                 c.vtx[0]        = tcu::Vec4(-1.0f, +1.0f, 0.5f, 1.0f);
 633                                 c.vtx[1]        = tcu::Vec4(+1.0f, -1.0f, 0.5f, 1.0f);
 634                                 c.vtx[2]        = tcu::Vec4(+1.0f, +1.0f, 0.5f, 1.0f);
 635                                 c.varying       = tcu::Vec4(0.0f, 1.0f, 8.0f, -8.0f);
 636                                 m_cases.push_back(c);
 637                         }
 638                 }
 639
 640                 {
 641                         de::Random rnd(0x89423f);
 642                         for (int ndx = 0; ndx < 25; ndx++)
 643                         {
 644                                 const float     depth   = rnd.getFloat()*2.0f - 1.0f;
 645                                 SubCase         c;
 646
 647                                 c.rtSize.x() = rnd.getInt(16, 256);
 648                                 c.rtSize.y() = rnd.getInt(16, 256);
 649                                 c.rtSize.z() = rnd.choose<int>(DE_ARRAY_BEGIN(supportedMsaaLevels), DE_ARRAY_END(supportedMsaaLevels));
 650
 651                                 for (int vtxNdx = 0; vtxNdx < DE_LENGTH_OF_ARRAY(c.vtx); vtxNdx++)
 652                                 {
 653                                         c.vtx[vtxNdx].x() = rnd.getFloat()*2.0f - 1.0f;
 654                                         c.vtx[vtxNdx].y() = rnd.getFloat()*2.0f - 1.0f;
 655                                         c.vtx[vtxNdx].z() = depth;
 656                                         c.vtx[vtxNdx].w() = 1.0f;
 657                                 }
 658
 659                                 for (int compNdx = 0; compNdx < 4; compNdx++)
 660                                 {
 661                                         float v;
 662                                         do
 663                                         {
 664                                                 v = tcu::Float32(rnd.getUint32()).asFloat();
 665                                         } while (deFloatIsInf(v) || deFloatIsNaN(v));
 666                                         c.varying[compNdx] = v;
 667                                 }
 668                                 m_cases.push_back(c);
 669                         }
 670                 }
 671         }
 672
 673         void init (void)
 674         {
 675                 m_caseIter = m_cases.begin();
 676                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "All iterations passed");
 677         }
 678
 679         IterateResult iterate (void)
 680         {
 681                 {
 682                         tcu::ScopedLogSection section(m_testCtx.getLog(), "SubCase", "");
 683                         runCase(*m_caseIter);
 684                 }
 685                 return (++m_caseIter != m_cases.end()) ? CONTINUE : STOP;
 686         }
 687
 688 protected:
 689         struct SubCase
 690         {
 691                 tcu::IVec3      rtSize; // (width, height, samples)
 692                 tcu::Vec4       vtx[3];
 693                 tcu::Vec4       varying;
 694         };
 695
 696         void runCase (const SubCase& subCase)
 697         {
 698                 using namespace tcu;
 699
 700                 const deUint32  maxColorUlpDiff = 2;
 701                 const deUint32  maxDepthUlpDiff = 0;
 702
 703                 const int               width                   = subCase.rtSize.x();
 704                 const int               height                  = subCase.rtSize.y();
 705                 const int               numSamples              = subCase.rtSize.z();
 706                 const float             zn                              = 0.0f;
 707                 const float             zf                              = 1.0f;
 708
 709                 TextureLevel    interpolated    (TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT), numSamples, width, height);
 710                 TextureLevel    depthStencil    (TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV), numSamples, width, height);
 711
 712                 m_testCtx.getLog() << TestLog::Message
 713                                                    << "RT size (w, h, #samples) = " << subCase.rtSize << "\n"
 714                                                    << "vtx[0] = " << subCase.vtx[0] << "\n"
 715                                                    << "vtx[1] = " << subCase.vtx[1] << "\n"
 716                                                    << "vtx[2] = " << subCase.vtx[2] << "\n"
 717                                                    << "color = " << subCase.varying
 718                                                    << TestLog::EndMessage;
 719
 720                 clear                   (interpolated.getAccess(), subCase.varying - Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 721                 clearDepth              (depthStencil.getAccess(), 0.0f);
 722                 clearStencil    (depthStencil.getAccess(), 0);
 723
 724                 {
 725                         class VtxShader : public rr::VertexShader
 726                         {
 727                         public:
 728                                 VtxShader (void)
 729                                         : rr::VertexShader(2, 1)
 730                                 {
 731                                         m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
 732                                         m_inputs[1].type        = rr::GENERICVECTYPE_FLOAT;
 733                                         m_outputs[0].type       = rr::GENERICVECTYPE_FLOAT;
 734                                 }
 735
 736                                 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
 737                                 {
 738                                         for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
 739                                         {
 740                                                 rr::readVertexAttrib(packets[packetNdx]->position, inputs[0], packets[packetNdx]->instanceNdx, packets[packetNdx]->vertexNdx);
 741                                                 packets[packetNdx]->outputs[0] = rr::readVertexAttribFloat(inputs[1], packets[packetNdx]->instanceNdx, packets[packetNdx]->vertexNdx);
 742                                         }
 743                                 }
 744                         } vtxShader;
 745
 746                         class FragShader : public rr::FragmentShader
 747                         {
 748                         public:
 749                                 FragShader (void)
 750                                         : rr::FragmentShader(1, 1)
 751                                 {
 752                                         m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
 753                                         m_outputs[0].type       = rr::GENERICVECTYPE_FLOAT;
 754                                 }
 755
 756                                 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
 757                                 {
 758                                         for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
 759                                         {
 760                                                 for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; fragNdx++)
 761                                                 {
 762                                                         const tcu::Vec4 interp = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
 763                                                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, interp);
 764                                                 }
 765                                         }
 766                                 }
 767                         } fragShader;
 768
 769                         const rr::Program                                               program                 (&vtxShader, &fragShader);
 770
 771                         const rr::MultisamplePixelBufferAccess  colorAccess             = rr::MultisamplePixelBufferAccess::fromMultisampleAccess(interpolated.getAccess());
 772                         const rr::MultisamplePixelBufferAccess  dsAccess                = rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthStencil.getAccess());
 773                         const rr::RenderTarget                                  renderTarget    (colorAccess, dsAccess, dsAccess);
 774                         const rr::VertexAttrib                                  vertexAttribs[] =
 775                         {
 776                                 rr::VertexAttrib(rr::VERTEXATTRIBTYPE_FLOAT, 4, 0, 0, subCase.vtx),
 777                                 rr::VertexAttrib(subCase.varying)
 778                         };
 779                         rr::ViewportState                                               viewport                (colorAccess);
 780                         rr::RenderState                                                 state                   (viewport);
 781                         const rr::DrawCommand                                   drawCmd                 (state, renderTarget, program, DE_LENGTH_OF_ARRAY(vertexAttribs), vertexAttribs, rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0));
 782                         const rr::Renderer                                              renderer;
 783
 784                         viewport.zn     = zn;
 785                         viewport.zf     = zf;
 786
 787                         state.fragOps.depthTestEnabled                                                  = true;
 788                         state.fragOps.depthFunc                                                                 = rr::TESTFUNC_ALWAYS;
 789                         state.fragOps.stencilTestEnabled                                                = true;
 790                         state.fragOps.stencilStates[rr::FACETYPE_BACK].func             = rr::TESTFUNC_ALWAYS;
 791                         state.fragOps.stencilStates[rr::FACETYPE_BACK].dpPass   = rr::STENCILOP_INCR;
 792                         state.fragOps.stencilStates[rr::FACETYPE_FRONT]                 = state.fragOps.stencilStates[rr::FACETYPE_BACK];
 793
 794                         renderer.draw(drawCmd);
 795                 }
 796
 797                 // Verify interpolated values
 798                 {
 799                         TextureLevel                                    resolvedColor                   (interpolated.getFormat(), width, height); // For debugging
 800                         TextureLevel                                    resolvedDepthStencil    (depthStencil.getFormat(), width, height); // For debugging
 801                         TextureLevel                                    errorMask                               (TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), width, height);
 802                         const ConstPixelBufferAccess    interpAccess                    = interpolated.getAccess();
 803                         const ConstPixelBufferAccess    dsAccess                                = depthStencil.getAccess();
 804                         const PixelBufferAccess                 errorAccess                             = errorMask.getAccess();
 805                         int                                                             numCoveredSamples               = 0;
 806                         int                                                             numFailedColorSamples   = 0;
 807                         int                                                             numFailedDepthSamples   = 0;
 808                         const bool                                              verifyDepth                             = (subCase.vtx[0].z() == subCase.vtx[1].z()) &&
 809                                                                                                                                           (subCase.vtx[1].z() == subCase.vtx[2].z());
 810                         const float                                             refDepth                                = subCase.vtx[0].z()*(zf - zn)/2.0f + (zn + zf)/2.0f;
 811
 812                         rr::resolveMultisampleBuffer(resolvedColor.getAccess(), rr::MultisampleConstPixelBufferAccess::fromMultisampleAccess(interpolated.getAccess()));
 813                         rr::resolveMultisampleBuffer(resolvedDepthStencil.getAccess(), rr::MultisampleConstPixelBufferAccess::fromMultisampleAccess(depthStencil.getAccess()));
 814                         clear(errorAccess, Vec4(0.0f, 1.0f, 0.0f, 1.0f));
 815
 816                         for (int y = 0; y < height; y++)
 817                         {
 818                                 for (int x = 0; x < width; x++)
 819                                 {
 820                                         for (int sampleNdx = 0; sampleNdx < numSamples; sampleNdx++)
 821                                         {
 822                                                 if (dsAccess.getPixStencil(sampleNdx, x, y) != 0)
 823                                                 {
 824                                                         const Vec4              color           = interpAccess.getPixel(sampleNdx, x, y);
 825                                                         const UVec4             colorDiff       = ulpDiff(color, subCase.varying);
 826                                                         const bool              colorOk         = boolAll(lessThanEqual(colorDiff, tcu::UVec4(maxColorUlpDiff)));
 827
 828                                                         const float             depth           = dsAccess.getPixDepth(sampleNdx, x, y);
 829                                                         const deUint32  depthDiff       = ulpDiff(depth, refDepth);
 830                                                         const bool              depthOk         = verifyDepth && (depthDiff <= maxDepthUlpDiff);
 831
 832                                                         const int               maxMsgs         = 10;
 833
 834                                                         numCoveredSamples += 1;
 835
 836                                                         if (!colorOk)
 837                                                         {
 838                                                                 numFailedColorSamples += 1;
 839
 840                                                                 if (numFailedColorSamples <= maxMsgs)
 841                                                                         m_testCtx.getLog() << TestLog::Message
 842                                                                                                            << "FAIL: " << tcu::IVec3(x, y, sampleNdx)
 843                                                                                                            << " color ulp diff = " << colorDiff
 844                                                                                                            << TestLog::EndMessage;
 845                                                         }
 846
 847                                                         if (!depthOk)
 848                                                                 numFailedDepthSamples += 1;
 849
 850                                                         if (!colorOk || !depthOk)
 851                                                                 errorAccess.setPixel(errorAccess.getPixel(x, y) + Vec4(1.0f, -1.0f, 0.0f, 0.0f) / float(numSamples-1), x, y);
 852                                                 }
 853                                         }
 854                                 }
 855                         }
 856
 857                         m_testCtx.getLog() << TestLog::Image("ResolvedColor", "Resolved colorbuffer", resolvedColor)
 858                                                            << TestLog::Image("ResolvedDepthStencil", "Resolved depth- & stencilbuffer", resolvedDepthStencil);
 859
 860                         if (numFailedColorSamples != 0 || numFailedDepthSamples != 0)
 861                         {
 862                                 m_testCtx.getLog() << TestLog::Image("ErrorMask", "Error mask", errorMask);
 863
 864                                 if (numFailedColorSamples != 0)
 865                                         m_testCtx.getLog() << TestLog::Message << "FAIL: Found " << numFailedColorSamples << " invalid color samples!" << TestLog::EndMessage;
 866
 867                                 if (numFailedDepthSamples != 0)
 868                                         m_testCtx.getLog() << TestLog::Message << "FAIL: Found " << numFailedDepthSamples << " invalid depth samples!" << TestLog::EndMessage;
 869
 870                                 if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 871                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid samples found");
 872                         }
 873
 874                         m_testCtx.getLog() << TestLog::Message << (numCoveredSamples-numFailedColorSamples) << " / " << numCoveredSamples << " color samples passed" << TestLog::EndMessage;
 875                         m_testCtx.getLog() << TestLog::Message << (numCoveredSamples-numFailedDepthSamples) << " / " << numCoveredSamples << " depth samples passed" << TestLog::EndMessage;
 876                 }
 877         }
 878
 879         vector<SubCase>                                 m_cases;
 880         vector<SubCase>::const_iterator m_caseIter;
 881 };
 882
 883 class CommonFrameworkTests : public tcu::TestCaseGroup
 884 {
 885 public:
 886         CommonFrameworkTests (tcu::TestContext& testCtx)
 887                 : tcu::TestCaseGroup(testCtx, "common", "Tests for the common utility framework")
 888         {
 889         }
 890
 891         void init (void)
 892         {
 893                 addChild(new SelfCheckCase(m_testCtx, "float_format","tcu::FloatFormat_selfTest()",
 894                                                                    tcu::FloatFormat_selfTest));
 895                 addChild(new SelfCheckCase(m_testCtx, "either","tcu::Either_selfTest()",
 896                                                                    tcu::Either_selfTest));
 897         }
 898 };
 899
 900 class ReferenceRendererTests : public tcu::TestCaseGroup
 901 {
 902 public:
 903         ReferenceRendererTests (tcu::TestContext& testCtx)
 904                 : tcu::TestCaseGroup(testCtx, "reference_renderer", "Reference renderer tests")
 905         {
 906         }
 907
 908         void init (void)
 909         {
 910                 addChild(new ConstantInterpolationTest(m_testCtx));
 911         }
 912 };
 913
 914 } // anonymous
 915
 916 FrameworkTests::FrameworkTests (tcu::TestContext& testCtx)
 917         : tcu::TestCaseGroup(testCtx, "framework", "Miscellaneous framework tests")
 918 {
 919 }
 920
 921 FrameworkTests::~FrameworkTests (void)
 922 {
 923 }
 924
 925 void FrameworkTests::init (void)
 926 {
 927         addChild(new CommonFrameworkTests       (m_testCtx));
 928         addChild(new CaseListParserTests        (m_testCtx));
 929         addChild(new ReferenceRendererTests     (m_testCtx));
 930         addChild(createTextureFormatTests       (m_testCtx));
 931         addChild(createAstcTests                        (m_testCtx));
 932         addChild(createVulkanTests                      (m_testCtx));
 933 }
 934
 935 } // dit