ditFrameworkTests.cpp revision f824ffe1538233bb05416cb5c7bd7167756c7314
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 30namespace dit 31{ 32 33namespace 34{ 35 36using std::string; 37using std::vector; 38using tcu::TestLog; 39 40struct MatchCase 41{ 42 enum Expected { NO_MATCH, MATCH_GROUP, MATCH_CASE, EXPECTED_LAST }; 43 44 const char* path; 45 Expected expected; 46}; 47 48const char* getMatchCaseExpectedDesc (MatchCase::Expected expected) 49{ 50 static const char* descs[] = 51 { 52 "no match", 53 "group to match", 54 "case to match" 55 }; 56 return de::getSizedArrayElement<MatchCase::EXPECTED_LAST>(descs, expected); 57} 58 59class CaseListParserCase : public tcu::TestCase 60{ 61public: 62 CaseListParserCase (tcu::TestContext& testCtx, const char* name, const char* caseList, const MatchCase* subCases, int numSubCases) 63 : tcu::TestCase (testCtx, name, "") 64 , m_caseList (caseList) 65 , m_subCases (subCases) 66 , m_numSubCases (numSubCases) 67 { 68 } 69 70 IterateResult iterate (void) 71 { 72 TestLog& log = m_testCtx.getLog(); 73 tcu::CommandLine cmdLine; 74 int numPass = 0; 75 76 log << TestLog::Message << "Input:\n\"" << m_caseList << "\"" << TestLog::EndMessage; 77 78 { 79 const char* argv[] = 80 { 81 "deqp", 82 "--deqp-caselist", 83 m_caseList 84 }; 85 86 if (!cmdLine.parse(DE_LENGTH_OF_ARRAY(argv), argv)) 87 TCU_FAIL("Failed to parse case list"); 88 } 89 90 for (int subCaseNdx = 0; subCaseNdx < m_numSubCases; subCaseNdx++) 91 { 92 const MatchCase& curCase = m_subCases[subCaseNdx]; 93 bool matchGroup; 94 bool matchCase; 95 96 log << TestLog::Message << "Checking \"" << curCase.path << "\"" 97 << ", expecting " << getMatchCaseExpectedDesc(curCase.expected) 98 << TestLog::EndMessage; 99 100 matchGroup = cmdLine.checkTestGroupName(curCase.path); 101 matchCase = cmdLine.checkTestCaseName(curCase.path); 102 103 if ((matchGroup == (curCase.expected == MatchCase::MATCH_GROUP)) && 104 (matchCase == (curCase.expected == MatchCase::MATCH_CASE))) 105 { 106 log << TestLog::Message << " pass" << TestLog::EndMessage; 107 numPass += 1; 108 } 109 else 110 log << TestLog::Message << " FAIL!" << TestLog::EndMessage; 111 } 112 113 m_testCtx.setTestResult((numPass == m_numSubCases) ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 114 (numPass == m_numSubCases) ? "All passed" : "Unexpected match result"); 115 116 return STOP; 117 } 118 119private: 120 const char* const m_caseList; 121 const MatchCase* const m_subCases; 122 const int m_numSubCases; 123}; 124 125class NegativeCaseListCase : public tcu::TestCase 126{ 127public: 128 NegativeCaseListCase (tcu::TestContext& testCtx, const char* name, const char* caseList) 129 : tcu::TestCase (testCtx, name, "") 130 , m_caseList (caseList) 131 { 132 } 133 134 IterateResult iterate (void) 135 { 136 TestLog& log = m_testCtx.getLog(); 137 tcu::CommandLine cmdLine; 138 139 log << TestLog::Message << "Input:\n\"" << m_caseList << "\"" << TestLog::EndMessage; 140 141 { 142 const char* argv[] = 143 { 144 "deqp", 145 "--deqp-caselist", 146 m_caseList 147 }; 148 149 if (cmdLine.parse(DE_LENGTH_OF_ARRAY(argv), argv)) 150 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Parsing passed, should have failed"); 151 else 152 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Parsing failed as expected"); 153 } 154 155 return STOP; 156 } 157 158private: 159 const char* const m_caseList; 160}; 161 162class TrieParserTests : public tcu::TestCaseGroup 163{ 164public: 165 TrieParserTests (tcu::TestContext& testCtx) 166 : tcu::TestCaseGroup(testCtx, "trie", "Test case trie parser tests") 167 { 168 } 169 170 void init (void) 171 { 172 { 173 static const char* const caseList = "{test}"; 174 static const MatchCase subCases[] = 175 { 176 { "test", MatchCase::MATCH_CASE }, 177 { "test.cd", MatchCase::NO_MATCH }, 178 }; 179 addChild(new CaseListParserCase(m_testCtx, "single_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 180 } 181 { 182 static const char* const caseList = "{a{b}}"; 183 static const MatchCase subCases[] = 184 { 185 { "a", MatchCase::MATCH_GROUP }, 186 { "b", MatchCase::NO_MATCH }, 187 { "a.b", MatchCase::MATCH_CASE }, 188 { "a.a", MatchCase::NO_MATCH }, 189 }; 190 addChild(new CaseListParserCase(m_testCtx, "simple_group_1", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 191 } 192 { 193 static const char* const caseList = "{a{b,c}}"; 194 static const MatchCase subCases[] = 195 { 196 { "a", MatchCase::MATCH_GROUP }, 197 { "b", MatchCase::NO_MATCH }, 198 { "a.b", MatchCase::MATCH_CASE }, 199 { "a.a", MatchCase::NO_MATCH }, 200 { "a.c", MatchCase::MATCH_CASE }, 201 }; 202 addChild(new CaseListParserCase(m_testCtx, "simple_group_2", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 203 } 204 { 205 static const char* const caseList = "{a{b},c{d,e}}"; 206 static const MatchCase subCases[] = 207 { 208 { "a", MatchCase::MATCH_GROUP }, 209 { "b", MatchCase::NO_MATCH }, 210 { "a.b", MatchCase::MATCH_CASE }, 211 { "a.c", MatchCase::NO_MATCH }, 212 { "a.d", MatchCase::NO_MATCH }, 213 { "a.e", MatchCase::NO_MATCH }, 214 { "c", MatchCase::MATCH_GROUP }, 215 { "c.b", MatchCase::NO_MATCH }, 216 { "c.d", MatchCase::MATCH_CASE }, 217 { "c.e", MatchCase::MATCH_CASE }, 218 }; 219 addChild(new CaseListParserCase(m_testCtx, "two_groups", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 220 } 221 { 222 static const char* const caseList = "{a,c{d,e}}"; 223 static const MatchCase subCases[] = 224 { 225 { "a", MatchCase::MATCH_CASE }, 226 { "b", MatchCase::NO_MATCH }, 227 { "a.b", MatchCase::NO_MATCH }, 228 { "a.c", MatchCase::NO_MATCH }, 229 { "a.d", MatchCase::NO_MATCH }, 230 { "a.e", MatchCase::NO_MATCH }, 231 { "c", MatchCase::MATCH_GROUP }, 232 { "c.b", MatchCase::NO_MATCH }, 233 { "c.d", MatchCase::MATCH_CASE }, 234 { "c.e", MatchCase::MATCH_CASE }, 235 }; 236 addChild(new CaseListParserCase(m_testCtx, "case_group", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 237 } 238 { 239 static const char* const caseList = "{c{d,e},a}"; 240 static const MatchCase subCases[] = 241 { 242 { "a", MatchCase::MATCH_CASE }, 243 { "b", MatchCase::NO_MATCH }, 244 { "a.b", MatchCase::NO_MATCH }, 245 { "a.c", MatchCase::NO_MATCH }, 246 { "a.d", MatchCase::NO_MATCH }, 247 { "a.e", MatchCase::NO_MATCH }, 248 { "c", MatchCase::MATCH_GROUP }, 249 { "c.b", MatchCase::NO_MATCH }, 250 { "c.d", MatchCase::MATCH_CASE }, 251 { "c.e", MatchCase::MATCH_CASE }, 252 }; 253 addChild(new CaseListParserCase(m_testCtx, "group_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 254 } 255 { 256 static const char* const caseList = "{test}\r"; 257 static const MatchCase subCases[] = 258 { 259 { "test", MatchCase::MATCH_CASE }, 260 { "test.cd", MatchCase::NO_MATCH }, 261 }; 262 addChild(new CaseListParserCase(m_testCtx, "trailing_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 263 } 264 { 265 static const char* const caseList = "{test}\n"; 266 static const MatchCase subCases[] = 267 { 268 { "test", MatchCase::MATCH_CASE }, 269 { "test.cd", MatchCase::NO_MATCH }, 270 }; 271 addChild(new CaseListParserCase(m_testCtx, "trailing_lf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 272 } 273 { 274 static const char* const caseList = "{test}\r\n"; 275 static const MatchCase subCases[] = 276 { 277 { "test", MatchCase::MATCH_CASE }, 278 { "test.cd", MatchCase::NO_MATCH }, 279 }; 280 addChild(new CaseListParserCase(m_testCtx, "trailing_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 281 } 282 283 // Negative tests 284 addChild(new NegativeCaseListCase(m_testCtx, "empty_string", "")); 285 addChild(new NegativeCaseListCase(m_testCtx, "empty_line", "\n")); 286 addChild(new NegativeCaseListCase(m_testCtx, "empty_root", "{}")); 287 addChild(new NegativeCaseListCase(m_testCtx, "empty_group", "{test{}}")); 288 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name_1", "{{}}")); 289 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name_2", "{{test}}")); 290 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_1", "{")); 291 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_2", "{test")); 292 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_3", "{test,")); 293 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_4", "{test{a}")); 294 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_root_5", "{a,b")); 295 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_1", "{test{")); 296 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_2", "{test{a")); 297 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_3", "{test{a,")); 298 addChild(new NegativeCaseListCase(m_testCtx, "unterminated_group_4", "{test{a,b")); 299 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_1", "{a,,b}")); 300 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_2", "{,b}")); 301 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name_3", "{a,}")); 302 addChild(new NegativeCaseListCase(m_testCtx, "no_separator", "{a{b}c}")); 303 addChild(new NegativeCaseListCase(m_testCtx, "invalid_char_1", "{a.b}")); 304 addChild(new NegativeCaseListCase(m_testCtx, "invalid_char_2", "{a[]}")); 305 addChild(new NegativeCaseListCase(m_testCtx, "trailing_char_1", "{a}}")); 306 addChild(new NegativeCaseListCase(m_testCtx, "trailing_char_2", "{a}x")); 307 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_1", "{\na}")); 308 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_2", "{a\n,b}")); 309 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_3", "{a,\nb}")); 310 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_4", "{a{b\n}}")); 311 addChild(new NegativeCaseListCase(m_testCtx, "embedded_newline_5", "{a{b}\n}")); 312 } 313}; 314 315class ListParserTests : public tcu::TestCaseGroup 316{ 317public: 318 ListParserTests (tcu::TestContext& testCtx) 319 : tcu::TestCaseGroup(testCtx, "list", "Test case list parser tests") 320 { 321 } 322 323 void init (void) 324 { 325 { 326 static const char* const caseList = "test"; 327 static const MatchCase subCases[] = 328 { 329 { "test", MatchCase::MATCH_CASE }, 330 { "test.cd", MatchCase::NO_MATCH }, 331 }; 332 addChild(new CaseListParserCase(m_testCtx, "single_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 333 } 334 { 335 static const char* const caseList = "a.b"; 336 static const MatchCase subCases[] = 337 { 338 { "a", MatchCase::MATCH_GROUP }, 339 { "b", MatchCase::NO_MATCH }, 340 { "a.b", MatchCase::MATCH_CASE }, 341 { "a.a", MatchCase::NO_MATCH }, 342 }; 343 addChild(new CaseListParserCase(m_testCtx, "simple_group_1", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 344 } 345 { 346 static const char* const caseList = "a.b\na.c"; 347 static const MatchCase subCases[] = 348 { 349 { "a", MatchCase::MATCH_GROUP }, 350 { "b", MatchCase::NO_MATCH }, 351 { "a.b", MatchCase::MATCH_CASE }, 352 { "a.a", MatchCase::NO_MATCH }, 353 { "a.c", MatchCase::MATCH_CASE }, 354 }; 355 addChild(new CaseListParserCase(m_testCtx, "simple_group_2", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 356 } 357 { 358 static const char* const caseList = "a.b\na.c"; 359 static const MatchCase subCases[] = 360 { 361 { "a", MatchCase::MATCH_GROUP }, 362 { "b", MatchCase::NO_MATCH }, 363 { "a.b", MatchCase::MATCH_CASE }, 364 { "a.a", MatchCase::NO_MATCH }, 365 { "a.c", MatchCase::MATCH_CASE }, 366 }; 367 addChild(new CaseListParserCase(m_testCtx, "separator_ln", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 368 } 369 { 370 static const char* const caseList = "a.b\ra.c"; 371 static const MatchCase subCases[] = 372 { 373 { "a", MatchCase::MATCH_GROUP }, 374 { "b", MatchCase::NO_MATCH }, 375 { "a.b", MatchCase::MATCH_CASE }, 376 { "a.a", MatchCase::NO_MATCH }, 377 { "a.c", MatchCase::MATCH_CASE }, 378 }; 379 addChild(new CaseListParserCase(m_testCtx, "separator_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 380 } 381 { 382 static const char* const caseList = "a.b\r\na.c"; 383 static const MatchCase subCases[] = 384 { 385 { "a", MatchCase::MATCH_GROUP }, 386 { "b", MatchCase::NO_MATCH }, 387 { "a.b", MatchCase::MATCH_CASE }, 388 { "a.a", MatchCase::NO_MATCH }, 389 { "a.c", MatchCase::MATCH_CASE }, 390 }; 391 addChild(new CaseListParserCase(m_testCtx, "separator_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 392 } 393 { 394 static const char* const caseList = "a.b\na.c\n"; 395 static const MatchCase subCases[] = 396 { 397 { "a", MatchCase::MATCH_GROUP }, 398 { "b", MatchCase::NO_MATCH }, 399 { "a.b", MatchCase::MATCH_CASE }, 400 { "a.a", MatchCase::NO_MATCH }, 401 { "a.c", MatchCase::MATCH_CASE }, 402 }; 403 addChild(new CaseListParserCase(m_testCtx, "end_ln", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 404 } 405 { 406 static const char* const caseList = "a.b\na.c\r"; 407 static const MatchCase subCases[] = 408 { 409 { "a", MatchCase::MATCH_GROUP }, 410 { "b", MatchCase::NO_MATCH }, 411 { "a.b", MatchCase::MATCH_CASE }, 412 { "a.a", MatchCase::NO_MATCH }, 413 { "a.c", MatchCase::MATCH_CASE }, 414 }; 415 addChild(new CaseListParserCase(m_testCtx, "end_cr", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 416 } 417 { 418 static const char* const caseList = "a.b\na.c\r\n"; 419 static const MatchCase subCases[] = 420 { 421 { "a", MatchCase::MATCH_GROUP }, 422 { "b", MatchCase::NO_MATCH }, 423 { "a.b", MatchCase::MATCH_CASE }, 424 { "a.a", MatchCase::NO_MATCH }, 425 { "a.c", MatchCase::MATCH_CASE }, 426 }; 427 addChild(new CaseListParserCase(m_testCtx, "end_crlf", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 428 } 429 { 430 static const char* const caseList = "a.b\nc.d\nc.e"; 431 static const MatchCase subCases[] = 432 { 433 { "a", MatchCase::MATCH_GROUP }, 434 { "b", MatchCase::NO_MATCH }, 435 { "a.b", MatchCase::MATCH_CASE }, 436 { "a.c", MatchCase::NO_MATCH }, 437 { "a.d", MatchCase::NO_MATCH }, 438 { "a.e", MatchCase::NO_MATCH }, 439 { "c", MatchCase::MATCH_GROUP }, 440 { "c.b", MatchCase::NO_MATCH }, 441 { "c.d", MatchCase::MATCH_CASE }, 442 { "c.e", MatchCase::MATCH_CASE }, 443 }; 444 addChild(new CaseListParserCase(m_testCtx, "two_groups", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 445 } 446 { 447 static const char* const caseList = "a\nc.d\nc.e"; 448 static const MatchCase subCases[] = 449 { 450 { "a", MatchCase::MATCH_CASE }, 451 { "b", MatchCase::NO_MATCH }, 452 { "a.b", MatchCase::NO_MATCH }, 453 { "a.c", MatchCase::NO_MATCH }, 454 { "a.d", MatchCase::NO_MATCH }, 455 { "a.e", MatchCase::NO_MATCH }, 456 { "c", MatchCase::MATCH_GROUP }, 457 { "c.b", MatchCase::NO_MATCH }, 458 { "c.d", MatchCase::MATCH_CASE }, 459 { "c.e", MatchCase::MATCH_CASE }, 460 }; 461 addChild(new CaseListParserCase(m_testCtx, "case_group", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 462 } 463 { 464 static const char* const caseList = "c.d\nc.e\na"; 465 static const MatchCase subCases[] = 466 { 467 { "a", MatchCase::MATCH_CASE }, 468 { "b", MatchCase::NO_MATCH }, 469 { "a.b", MatchCase::NO_MATCH }, 470 { "a.c", MatchCase::NO_MATCH }, 471 { "a.d", MatchCase::NO_MATCH }, 472 { "a.e", MatchCase::NO_MATCH }, 473 { "c", MatchCase::MATCH_GROUP }, 474 { "c.b", MatchCase::NO_MATCH }, 475 { "c.d", MatchCase::MATCH_CASE }, 476 { "c.e", MatchCase::MATCH_CASE }, 477 }; 478 addChild(new CaseListParserCase(m_testCtx, "group_case", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 479 } 480 { 481 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"; 482 static const MatchCase subCases[] = 483 { 484 { "a", MatchCase::MATCH_GROUP }, 485 { "b", MatchCase::NO_MATCH }, 486 { "a.b", MatchCase::MATCH_GROUP }, 487 { "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 }, 488 }; 489 addChild(new CaseListParserCase(m_testCtx, "long_name", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 490 } 491 { 492 static const char* const caseList = 493 "a.b.c.d.e\n" 494 "a.b.c.f\n" 495 "x.y.z\n" 496 "a.b.c.d.g\n" 497 "a.b.c.x\n"; 498 static const MatchCase subCases[] = 499 { 500 { "a", MatchCase::MATCH_GROUP }, 501 { "a.b", MatchCase::MATCH_GROUP }, 502 { "a.b.c.d.e", MatchCase::MATCH_CASE }, 503 { "a.b.c.d.g", MatchCase::MATCH_CASE }, 504 { "x.y", MatchCase::MATCH_GROUP }, 505 { "x.y.z", MatchCase::MATCH_CASE }, 506 { "a.b.c.f", MatchCase::MATCH_CASE }, 507 { "a.b.c.x", MatchCase::MATCH_CASE }, 508 }; 509 addChild(new CaseListParserCase(m_testCtx, "partial_prefix", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 510 } 511 { 512 static const char* const caseList = 513 "a.a.c.d\n" 514 "a.b.c.d\n"; 515 static const MatchCase subCases[] = 516 { 517 { "a", MatchCase::MATCH_GROUP }, 518 { "a.a", MatchCase::MATCH_GROUP }, 519 { "a.b.c.d", MatchCase::MATCH_CASE }, 520 { "a.b.c.d", MatchCase::MATCH_CASE }, 521 }; 522 addChild(new CaseListParserCase(m_testCtx, "reparenting", caseList, subCases, DE_LENGTH_OF_ARRAY(subCases))); 523 } 524 525 // Negative tests 526 addChild(new NegativeCaseListCase(m_testCtx, "empty_string", "")); 527 addChild(new NegativeCaseListCase(m_testCtx, "empty_line", "\n")); 528 addChild(new NegativeCaseListCase(m_testCtx, "empty_group_name", ".test")); 529 addChild(new NegativeCaseListCase(m_testCtx, "empty_case_name", "test.")); 530 } 531}; 532 533class CaseListParserTests : public tcu::TestCaseGroup 534{ 535public: 536 CaseListParserTests (tcu::TestContext& testCtx) 537 : tcu::TestCaseGroup(testCtx, "case_list_parser", "Test case list parser tests") 538 { 539 } 540 541 void init (void) 542 { 543 addChild(new TrieParserTests(m_testCtx)); 544 addChild(new ListParserTests(m_testCtx)); 545 } 546}; 547 548class CommonFrameworkTests : public tcu::TestCaseGroup 549{ 550public: 551 CommonFrameworkTests (tcu::TestContext& testCtx) 552 : tcu::TestCaseGroup(testCtx, "common", "Tests for the common utility framework") 553 { 554 } 555 556 void init (void) 557 { 558 addChild(new SelfCheckCase(m_testCtx, "float_format","tcu::FloatFormat_selfTest()", 559 tcu::FloatFormat_selfTest)); 560 addChild(new SelfCheckCase(m_testCtx, "either","tcu::Either_selfTest()", 561 tcu::Either_selfTest)); 562 } 563}; 564 565} // anonymous 566 567FrameworkTests::FrameworkTests (tcu::TestContext& testCtx) 568 : tcu::TestCaseGroup(testCtx, "framework", "Miscellaneous framework tests") 569{ 570} 571 572FrameworkTests::~FrameworkTests (void) 573{ 574} 575 576void FrameworkTests::init (void) 577{ 578 addChild(new CommonFrameworkTests (m_testCtx)); 579 addChild(new CaseListParserTests (m_testCtx)); 580} 581 582} 583