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