execserver/tools/xsTest.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Execution Server
   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 ExecServer Tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "xsDefs.hpp"
  25
  26 #include "xsProtocol.hpp"
  27 #include "deSocket.hpp"
  28 #include "deRingBuffer.hpp"
  29 #include "deFilePath.hpp"
  30 #include "deBlockBuffer.hpp"
  31 #include "deThread.hpp"
  32 #include "deStringUtil.hpp"
  33 #include "deUniquePtr.hpp"
  34
  35 #include "deClock.h"
  36 #include "deProcess.h"
  37 #include "deString.h"
  38 #include "deRandom.h"
  39
  40 #include <memory>
  41 #include <algorithm>
  42
  43 using std::string;
  44 using std::vector;
  45
  46 namespace xs
  47 {
  48
  49 typedef de::UniquePtr<Message> ScopedMsgPtr;
  50
  51 class SocketError : public Error
  52 {
  53 public:
  54         SocketError (deSocketResult result, const char* message, const char* file, int line)
  55                 : Error         (message, deGetSocketResultName(result), file, line)
  56                 , m_result      (result)
  57         {
  58         }
  59
  60         deSocketResult getResult (void) const
  61         {
  62                 return m_result;
  63         }
  64
  65 private:
  66         deSocketResult m_result;
  67 };
  68
  69 // Helpers.
  70 void sendMessage (de::Socket& socket, const Message& message)
  71 {
  72         // Format message.
  73         vector<deUint8> buf;
  74         message.write(buf);
  75
  76         // Write to socket.
  77         size_t pos = 0;
  78         while (pos < buf.size())
  79         {
  80                 size_t                  numLeft         = buf.size() - pos;
  81                 size_t                  numSent         = 0;
  82                 deSocketResult  result          = socket.send(&buf[pos], numLeft, &numSent);
  83
  84                 if (result != DE_SOCKETRESULT_SUCCESS)
  85                         throw SocketError(result, "send() failed", __FILE__, __LINE__);
  86
  87                 pos += numSent;
  88         }
  89 }
  90
  91 void readBytes (de::Socket& socket, vector<deUint8>& dst, size_t numBytes)
  92 {
  93         size_t numRead = 0;
  94         dst.resize(numBytes);
  95         while (numRead < numBytes)
  96         {
  97                 size_t                  numLeft         = numBytes - numRead;
  98                 size_t                  curNumRead      = 0;
  99                 deSocketResult  result          = socket.receive(&dst[numRead], numLeft, &curNumRead);
 100
 101                 if (result != DE_SOCKETRESULT_SUCCESS)
 102                         throw SocketError(result, "receive() failed", __FILE__, __LINE__);
 103
 104                 numRead += curNumRead;
 105         }
 106 }
 107
 108 Message* readMessage (de::Socket& socket)
 109 {
 110         // Header.
 111         vector<deUint8> header;
 112         readBytes(socket, header, MESSAGE_HEADER_SIZE);
 113
 114         MessageType     type;
 115         size_t          messageSize;
 116         Message::parseHeader(&header[0], (int)header.size(), type, messageSize);
 117
 118         // Simple messages without any data.
 119         switch (type)
 120         {
 121                 case MESSAGETYPE_KEEPALIVE:                             return new KeepAliveMessage();
 122                 case MESSAGETYPE_PROCESS_STARTED:               return new ProcessStartedMessage();
 123                 default:
 124                         break; // Read message with data.
 125         }
 126
 127         vector<deUint8> messageBuf;
 128         readBytes(socket, messageBuf, messageSize-MESSAGE_HEADER_SIZE);
 129
 130         switch (type)
 131         {
 132                 case MESSAGETYPE_HELLO:                                 return new HelloMessage(&messageBuf[0], (int)messageBuf.size());
 133                 case MESSAGETYPE_TEST:                                  return new TestMessage(&messageBuf[0], (int)messageBuf.size());
 134                 case MESSAGETYPE_PROCESS_LOG_DATA:              return new ProcessLogDataMessage(&messageBuf[0], (int)messageBuf.size());
 135                 case MESSAGETYPE_INFO:                                  return new InfoMessage(&messageBuf[0], (int)messageBuf.size());
 136                 case MESSAGETYPE_PROCESS_LAUNCH_FAILED: return new ProcessLaunchFailedMessage(&messageBuf[0], (int)messageBuf.size());
 137                 case MESSAGETYPE_PROCESS_FINISHED:              return new ProcessFinishedMessage(&messageBuf[0], (int)messageBuf.size());
 138                 default:
 139                         XS_FAIL("Unknown message");
 140         }
 141 }
 142
 143 class TestClock
 144 {
 145 public:
 146         inline TestClock (void)
 147         {
 148                 reset();
 149         }
 150
 151         inline void reset (void)
 152         {
 153                 m_initTime = deGetMicroseconds();
 154         }
 155
 156         inline int getMilliseconds (void)
 157         {
 158                 return (int)((deGetMicroseconds() - m_initTime) / 1000);
 159         }
 160
 161 private:
 162         deUint64 m_initTime;
 163 };
 164
 165 class TestContext
 166 {
 167 public:
 168                                                 TestContext             (void) : startServer(false) {}
 169
 170         std::string                     serverPath;
 171         std::string                     testerPath;
 172         de::SocketAddress       address;
 173         bool                            startServer;
 174
 175         // Passed from execserver.
 176         std::string                     logFileName;
 177         std::string                     caseList;
 178
 179 private:
 180                                                 TestContext             (const TestContext& other);
 181         TestContext&            operator=               (const TestContext& other);
 182 };
 183
 184 class TestCase
 185 {
 186 public:
 187                                         TestCase                (TestContext& testCtx, const char* name) : m_testCtx(testCtx), m_name(name) {}
 188         virtual                 ~TestCase               (void) {}
 189
 190         const char*             getName                 (void) const { return m_name.c_str(); }
 191
 192         virtual void    runClient               (de::Socket& socket) = DE_NULL;
 193         virtual void    runProgram              (void) = DE_NULL;
 194
 195 protected:
 196         TestContext&    m_testCtx;
 197         std::string             m_name;
 198 };
 199
 200 class TestExecutor
 201 {
 202 public:
 203                                         TestExecutor    (TestContext& testCtx);
 204                                         ~TestExecutor   (void);
 205
 206         void                    runCases                (const std::vector<TestCase*>& testCases);
 207         bool                    runCase                 (TestCase* testCase);
 208
 209 private:
 210         TestContext&    m_testCtx;
 211 };
 212
 213 TestExecutor::TestExecutor (TestContext& testCtx)
 214         : m_testCtx(testCtx)
 215 {
 216 }
 217
 218 TestExecutor::~TestExecutor (void)
 219 {
 220 }
 221
 222 void TestExecutor::runCases (const std::vector<TestCase*>& testCases)
 223 {
 224         int numPassed   = 0;
 225         int numCases    = (int)testCases.size();
 226
 227         for (std::vector<TestCase*>::const_iterator i = testCases.begin(); i != testCases.end(); i++)
 228         {
 229                 if (runCase(*i))
 230                         numPassed += 1;
 231         }
 232
 233         printf("\n  %d/%d passed!\n", numPassed, numCases);
 234 }
 235
 236 class FilePrinter : public de::Thread
 237 {
 238 public:
 239         FilePrinter (void)
 240                 : m_curFile(DE_NULL)
 241         {
 242         }
 243
 244         void start (deFile* file)
 245         {
 246                 DE_ASSERT(!m_curFile);
 247                 m_curFile = file;
 248                 de::Thread::start();
 249         }
 250
 251         void run (void)
 252         {
 253                 char    buf[256];
 254                 deInt64 numRead = 0;
 255
 256                 while (deFile_read(m_curFile, &buf[0], (deInt64)sizeof(buf), &numRead) == DE_FILERESULT_SUCCESS)
 257                         fwrite(&buf[0], 1, (size_t)numRead, stdout);
 258
 259                 m_curFile = DE_NULL;
 260         }
 261
 262 private:
 263         deFile* m_curFile;
 264 };
 265
 266 bool TestExecutor::runCase (TestCase* testCase)
 267 {
 268         printf("%s\n", testCase->getName());
 269
 270         bool            success         = false;
 271         deProcess*      serverProc      = DE_NULL;
 272         FilePrinter     stdoutPrinter;
 273         FilePrinter     stderrPrinter;
 274
 275         try
 276         {
 277                 if (m_testCtx.startServer)
 278                 {
 279                         string cmdLine = m_testCtx.serverPath + " --port=" + de::toString(m_testCtx.address.getPort());
 280                         serverProc = deProcess_create();
 281                         XS_CHECK(serverProc);
 282
 283                         if (!deProcess_start(serverProc, cmdLine.c_str(), DE_NULL))
 284                         {
 285                                 string errMsg = deProcess_getLastError(serverProc);
 286                                 deProcess_destroy(serverProc);
 287                                 XS_FAIL(errMsg.c_str());
 288                         }
 289
 290                         deSleep(200); /* Give 200ms for server to start. */
 291                         XS_CHECK(deProcess_isRunning(serverProc));
 292
 293                         // Start stdout/stderr printers.
 294                         stdoutPrinter.start(deProcess_getStdOut(serverProc));
 295                         stderrPrinter.start(deProcess_getStdErr(serverProc));
 296                 }
 297
 298                 // Connect.
 299                 de::Socket socket;
 300                 socket.connect(m_testCtx.address);
 301
 302                 // Flags.
 303                 socket.setFlags(DE_SOCKET_CLOSE_ON_EXEC);
 304
 305                 // Run case.
 306                 testCase->runClient(socket);
 307
 308                 // Disconnect.
 309                 if (socket.isConnected())
 310                         socket.shutdown();
 311
 312                 // Kill server.
 313                 if (serverProc && deProcess_isRunning(serverProc))
 314                 {
 315                         XS_CHECK(deProcess_terminate(serverProc));
 316                         deSleep(100);
 317                         XS_CHECK(deProcess_waitForFinish(serverProc));
 318
 319                         stdoutPrinter.join();
 320                         stderrPrinter.join();
 321                 }
 322
 323                 success = true;
 324         }
 325         catch (const std::exception& e)
 326         {
 327                 printf("FAIL: %s\n\n", e.what());
 328         }
 329
 330         if (serverProc)
 331                 deProcess_destroy(serverProc);
 332
 333         return success;
 334 }
 335
 336 class ConnectTest : public TestCase
 337 {
 338 public:
 339         ConnectTest (TestContext& testCtx)
 340                 : TestCase(testCtx, "connect")
 341         {
 342         }
 343
 344         void runClient (de::Socket& socket)
 345         {
 346                 DE_UNREF(socket);
 347         }
 348
 349         void runProgram (void) { /* nothing */ }
 350 };
 351
 352 class HelloTest : public TestCase
 353 {
 354 public:
 355         HelloTest (TestContext& testCtx)
 356                 : TestCase(testCtx, "hello")
 357         {
 358         }
 359
 360         void runClient (de::Socket& socket)
 361         {
 362                 xs::HelloMessage msg;
 363                 sendMessage(socket, (const xs::Message&)msg);
 364         }
 365
 366         void runProgram (void) { /* nothing */ }
 367 };
 368
 369 class ExecFailTest : public TestCase
 370 {
 371 public:
 372         ExecFailTest (TestContext& testCtx)
 373                 : TestCase(testCtx, "exec-fail")
 374         {
 375         }
 376
 377         void runClient (de::Socket& socket)
 378         {
 379                 xs::ExecuteBinaryMessage execMsg;
 380                 execMsg.name            = "foobar-notfound";
 381                 execMsg.params          = "";
 382                 execMsg.caseList        = "";
 383                 execMsg.workDir         = "";
 384
 385                 sendMessage(socket, execMsg);
 386
 387                 const int               timeout         = 100; // 100ms.
 388                 TestClock               clock;
 389
 390                 for (;;)
 391                 {
 392                         if (clock.getMilliseconds() > timeout)
 393                                 XS_FAIL("Didn't receive PROCESS_LAUNCH_FAILED");
 394
 395                         ScopedMsgPtr msg(readMessage(socket));
 396
 397                         if (msg->type == MESSAGETYPE_PROCESS_LAUNCH_FAILED)
 398                                 break;
 399                         else if (msg->type == MESSAGETYPE_KEEPALIVE)
 400                                 continue;
 401                         else
 402                                 XS_FAIL("Invalid message");
 403                 }
 404         }
 405
 406         void runProgram (void) { /* nothing */ }
 407 };
 408
 409 class SimpleExecTest : public TestCase
 410 {
 411 public:
 412         SimpleExecTest (TestContext& testCtx)
 413                 : TestCase(testCtx, "simple-exec")
 414         {
 415         }
 416
 417         void runClient (de::Socket& socket)
 418         {
 419                 xs::ExecuteBinaryMessage execMsg;
 420                 execMsg.name            = m_testCtx.testerPath;
 421                 execMsg.params          = "--program=simple-exec";
 422                 execMsg.caseList        = "";
 423                 execMsg.workDir         = "";
 424
 425                 sendMessage(socket, execMsg);
 426
 427                 const int               timeout         = 5000; // 5s.
 428                 TestClock               clock;
 429
 430                 bool    gotProcessStarted       = false;
 431                 bool    gotProcessFinished      = false;
 432
 433                 for (;;)
 434                 {
 435                         if (clock.getMilliseconds() > timeout)
 436                                 break;
 437
 438                         ScopedMsgPtr msg(readMessage(socket));
 439
 440                         if (msg->type == MESSAGETYPE_PROCESS_STARTED)
 441                                 gotProcessStarted = true;
 442                         else if (msg->type == MESSAGETYPE_PROCESS_LAUNCH_FAILED)
 443                                 XS_FAIL("Got PROCESS_LAUNCH_FAILED");
 444                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_FINISHED)
 445                         {
 446                                 gotProcessFinished = true;
 447                                 break;
 448                         }
 449                         else if (msg->type == MESSAGETYPE_KEEPALIVE || msg->type == MESSAGETYPE_INFO)
 450                                 continue;
 451                         else
 452                                 XS_FAIL((string("Invalid message: ") + de::toString(msg->type)).c_str());
 453                 }
 454
 455                 if (!gotProcessStarted)
 456                         XS_FAIL("Did't get PROCESS_STARTED message");
 457
 458                 if (!gotProcessFinished)
 459                         XS_FAIL("Did't get PROCESS_FINISHED message");
 460         }
 461
 462         void runProgram (void) { /* print nothing. */ }
 463 };
 464
 465 class InfoTest : public TestCase
 466 {
 467 public:
 468         std::string infoStr;
 469
 470         InfoTest (TestContext& testCtx)
 471                 : TestCase      (testCtx, "info")
 472                 , infoStr       ("Hello, World")
 473         {
 474         }
 475
 476         void runClient (de::Socket& socket)
 477         {
 478                 xs::ExecuteBinaryMessage execMsg;
 479                 execMsg.name            = m_testCtx.testerPath;
 480                 execMsg.params          = "--program=info";
 481                 execMsg.caseList        = "";
 482                 execMsg.workDir         = "";
 483
 484                 sendMessage(socket, execMsg);
 485
 486                 const int               timeout         = 10000; // 10s.
 487                 TestClock               clock;
 488
 489                 bool                    gotProcessStarted       = false;
 490                 bool                    gotProcessFinished      = false;
 491                 std::string             receivedInfo            = "";
 492
 493                 for (;;)
 494                 {
 495                         if (clock.getMilliseconds() > timeout)
 496                                 break;
 497
 498                         ScopedMsgPtr msg(readMessage(socket));
 499
 500                         if (msg->type == MESSAGETYPE_PROCESS_STARTED)
 501                                 gotProcessStarted = true;
 502                         else if (msg->type == MESSAGETYPE_PROCESS_LAUNCH_FAILED)
 503                                 XS_FAIL("Got PROCESS_LAUNCH_FAILED");
 504                         else if (gotProcessStarted && msg->type == MESSAGETYPE_INFO)
 505                                 receivedInfo += static_cast<const InfoMessage*>(msg.get())->info;
 506                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_FINISHED)
 507                         {
 508                                 gotProcessFinished = true;
 509                                 break;
 510                         }
 511                         else if (msg->type == MESSAGETYPE_KEEPALIVE)
 512                                 continue;
 513                         else
 514                                 XS_FAIL("Invalid message");
 515                 }
 516
 517                 if (!gotProcessStarted)
 518                         XS_FAIL("Did't get PROCESS_STARTED message");
 519
 520                 if (!gotProcessFinished)
 521                         XS_FAIL("Did't get PROCESS_FINISHED message");
 522
 523                 if (receivedInfo != infoStr)
 524                         XS_FAIL("Info data doesn't match");
 525         }
 526
 527         void runProgram (void) { printf("%s", infoStr.c_str()); }
 528 };
 529
 530 class LogDataTest : public TestCase
 531 {
 532 public:
 533         LogDataTest (TestContext& testCtx)
 534                 : TestCase(testCtx, "logdata")
 535         {
 536         }
 537
 538         void runClient (de::Socket& socket)
 539         {
 540                 xs::ExecuteBinaryMessage execMsg;
 541                 execMsg.name            = m_testCtx.testerPath;
 542                 execMsg.params          = "--program=logdata";
 543                 execMsg.caseList        = "";
 544                 execMsg.workDir         = "";
 545
 546                 sendMessage(socket, execMsg);
 547
 548                 const int               timeout         = 10000; // 10s.
 549                 TestClock               clock;
 550
 551                 bool                    gotProcessStarted       = false;
 552                 bool                    gotProcessFinished      = false;
 553                 std::string             receivedData            = "";
 554
 555                 for (;;)
 556                 {
 557                         if (clock.getMilliseconds() > timeout)
 558                                 break;
 559
 560                         ScopedMsgPtr msg(readMessage(socket));
 561
 562                         if (msg->type == MESSAGETYPE_PROCESS_STARTED)
 563                                 gotProcessStarted = true;
 564                         else if (msg->type == MESSAGETYPE_PROCESS_LAUNCH_FAILED)
 565                                 XS_FAIL("Got PROCESS_LAUNCH_FAILED");
 566                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_LOG_DATA)
 567                                 receivedData += static_cast<const ProcessLogDataMessage*>(msg.get())->logData;
 568                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_FINISHED)
 569                         {
 570                                 gotProcessFinished = true;
 571                                 break;
 572                         }
 573                         else if (msg->type == MESSAGETYPE_KEEPALIVE)
 574                                 continue;
 575                         else if (msg->type == MESSAGETYPE_INFO)
 576                                 XS_FAIL(static_cast<const InfoMessage*>(msg.get())->info.c_str());
 577                         else
 578                                 XS_FAIL("Invalid message");
 579                 }
 580
 581                 if (!gotProcessStarted)
 582                         XS_FAIL("Did't get PROCESS_STARTED message");
 583
 584                 if (!gotProcessFinished)
 585                         XS_FAIL("Did't get PROCESS_FINISHED message");
 586
 587                 const char* expected = "Foo\nBar\n";
 588                 if (receivedData != expected)
 589                 {
 590                         printf("  received: '%s'\n  expected: '%s'\n", receivedData.c_str(), expected);
 591                         XS_FAIL("Log data doesn't match");
 592                 }
 593         }
 594
 595         void runProgram (void)
 596         {
 597                 deFile* file = deFile_create(m_testCtx.logFileName.c_str(), DE_FILEMODE_OPEN|DE_FILEMODE_CREATE|DE_FILEMODE_TRUNCATE|DE_FILEMODE_WRITE);
 598                 XS_CHECK(file);
 599
 600                 const char line0[] = "Foo\n";
 601                 const char line1[] = "Bar\n";
 602                 deInt64 numWritten = 0;
 603
 604                 // Write first line.
 605                 XS_CHECK(deFile_write(file, line0, sizeof(line0)-1, &numWritten) == DE_FILERESULT_SUCCESS);
 606                 XS_CHECK(numWritten == sizeof(line0)-1);
 607
 608                 // Sleep for 0.5s and write line 2.
 609                 deSleep(500);
 610                 XS_CHECK(deFile_write(file, line1, sizeof(line1)-1, &numWritten) == DE_FILERESULT_SUCCESS);
 611                 XS_CHECK(numWritten == sizeof(line1)-1);
 612
 613                 deFile_destroy(file);
 614         }
 615 };
 616
 617 class BigLogDataTest : public TestCase
 618 {
 619 public:
 620         enum
 621         {
 622                 DATA_SIZE = 100*1024*1024
 623         };
 624
 625         BigLogDataTest (TestContext& testCtx)
 626                 : TestCase(testCtx, "biglogdata")
 627         {
 628         }
 629
 630         void runClient (de::Socket& socket)
 631         {
 632                 xs::ExecuteBinaryMessage execMsg;
 633                 execMsg.name            = m_testCtx.testerPath;
 634                 execMsg.params          = "--program=biglogdata";
 635                 execMsg.caseList        = "";
 636                 execMsg.workDir         = "";
 637
 638                 sendMessage(socket, execMsg);
 639
 640                 const int               timeout         = 30000; // 30s.
 641                 TestClock               clock;
 642
 643                 bool                    gotProcessStarted       = false;
 644                 bool                    gotProcessFinished      = false;
 645                 int                             receivedBytes           = 0;
 646
 647                 for (;;)
 648                 {
 649                         if (clock.getMilliseconds() > timeout)
 650                                 break;
 651
 652                         ScopedMsgPtr msg(readMessage(socket));
 653
 654                         if (msg->type == MESSAGETYPE_PROCESS_STARTED)
 655                                 gotProcessStarted = true;
 656                         else if (msg->type == MESSAGETYPE_PROCESS_LAUNCH_FAILED)
 657                                 XS_FAIL("Got PROCESS_LAUNCH_FAILED");
 658                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_LOG_DATA)
 659                                 receivedBytes += (int)static_cast<const ProcessLogDataMessage*>(msg.get())->logData.length();
 660                         else if (gotProcessStarted && msg->type == MESSAGETYPE_PROCESS_FINISHED)
 661                         {
 662                                 gotProcessFinished = true;
 663                                 break;
 664                         }
 665                         else if (msg->type == MESSAGETYPE_KEEPALIVE)
 666                         {
 667                                 // Reply with keepalive.
 668                                 sendMessage(socket, KeepAliveMessage());
 669                                 continue;
 670                         }
 671                         else if (msg->type == MESSAGETYPE_INFO)
 672                                 printf("%s", static_cast<const InfoMessage*>(msg.get())->info.c_str());
 673                         else
 674                                 XS_FAIL("Invalid message");
 675                 }
 676
 677                 if (!gotProcessStarted)
 678                         XS_FAIL("Did't get PROCESS_STARTED message");
 679
 680                 if (!gotProcessFinished)
 681                         XS_FAIL("Did't get PROCESS_FINISHED message");
 682
 683                 if (receivedBytes != DATA_SIZE)
 684                 {
 685                         printf("  received: %d bytes\n  expected: %d bytes\n", receivedBytes, DATA_SIZE);
 686                         XS_FAIL("Log data size doesn't match");
 687                 }
 688
 689                 int timeMs = clock.getMilliseconds();
 690                 printf("  Streamed %d bytes in %d ms: %.2f MiB/s\n", DATA_SIZE, timeMs, ((float)DATA_SIZE / (float)(1024*1024)) / ((float)timeMs / 1000.0f));
 691         }
 692
 693         void runProgram (void)
 694         {
 695                 deFile* file = deFile_create(m_testCtx.logFileName.c_str(), DE_FILEMODE_OPEN|DE_FILEMODE_CREATE|DE_FILEMODE_TRUNCATE|DE_FILEMODE_WRITE);
 696                 XS_CHECK(file);
 697
 698                 deUint8 tmpBuf[1024*16];
 699                 int numWritten = 0;
 700
 701                 deMemset(&tmpBuf, 'a', sizeof(tmpBuf));
 702
 703                 while (numWritten < DATA_SIZE)
 704                 {
 705                         deInt64 numWrittenInBatch = 0;
 706                         XS_CHECK(deFile_write(file, &tmpBuf[0], de::min((int)sizeof(tmpBuf), DATA_SIZE-numWritten), &numWrittenInBatch) == DE_FILERESULT_SUCCESS);
 707                         numWritten += (int)numWrittenInBatch;
 708                 }
 709
 710                 deFile_destroy(file);
 711         }
 712 };
 713
 714 class KeepAliveTest : public TestCase
 715 {
 716 public:
 717         KeepAliveTest (TestContext& testCtx)
 718                 : TestCase(testCtx, "keepalive")
 719         {
 720         }
 721
 722         void runClient (de::Socket& socket)
 723         {
 724                 // In milliseconds.
 725                 const int       sendInterval                    = 5000;
 726                 const int       minReceiveInterval              = 10000;
 727                 const int       testTime                                = 30000;
 728                 const int       sleepTime                               = 200;
 729                 const int       expectedTimeout                 = 40000;
 730                 int                     curTime                                 = 0;
 731                 int                     lastSendTime                    = 0;
 732                 int                     lastReceiveTime                 = 0;
 733                 TestClock       clock;
 734
 735                 DE_ASSERT(sendInterval < minReceiveInterval);
 736
 737                 curTime = clock.getMilliseconds();
 738
 739                 while (curTime < testTime)
 740                 {
 741                         bool tryGetKeepalive = false;
 742
 743                         if (curTime-lastSendTime > sendInterval)
 744                         {
 745                                 printf("  %d ms: sending keepalive\n", curTime);
 746                                 sendMessage(socket, KeepAliveMessage());
 747                                 curTime = clock.getMilliseconds();
 748                                 lastSendTime = curTime;
 749                                 tryGetKeepalive = true;
 750                         }
 751
 752                         if (tryGetKeepalive)
 753                         {
 754                                 // Try to acquire keepalive.
 755                                 printf("  %d ms: waiting for keepalive\n", curTime);
 756                                 ScopedMsgPtr msg(readMessage(socket));
 757                                 int recvTime = clock.getMilliseconds();
 758
 759                                 if (msg->type != MESSAGETYPE_KEEPALIVE)
 760                                         XS_FAIL("Got invalid message");
 761
 762                                 printf("  %d ms: got keepalive\n", curTime);
 763
 764                                 if (recvTime-lastReceiveTime > minReceiveInterval)
 765                                         XS_FAIL("Server doesn't send keepalives");
 766
 767                                 lastReceiveTime = recvTime;
 768                         }
 769
 770                         deSleep(sleepTime);
 771                         curTime = clock.getMilliseconds();
 772                 }
 773
 774                 // Verify that server actually kills the connection upon timeout.
 775                 sendMessage(socket, KeepAliveMessage());
 776                 printf("  waiting %d ms for keepalive timeout...\n", expectedTimeout);
 777                 bool isClosed = false;
 778
 779                 try
 780                 {
 781                         // Reset timer.
 782                         clock.reset();
 783                         curTime = clock.getMilliseconds();
 784
 785                         while (curTime < expectedTimeout)
 786                         {
 787                                 // Try to get keepalive message.
 788                                 ScopedMsgPtr msg(readMessage(socket));
 789                                 if (msg->type != MESSAGETYPE_KEEPALIVE)
 790                                         XS_FAIL("Got invalid message");
 791
 792                                 curTime = clock.getMilliseconds();
 793                                 printf("  %d ms: got keepalive\n", curTime);
 794                         }
 795                 }
 796                 catch (const SocketError& e)
 797                 {
 798                         if (e.getResult() == DE_SOCKETRESULT_CONNECTION_CLOSED)
 799                         {
 800                                 printf("  %d ms: server closed connection", clock.getMilliseconds());
 801                                 isClosed = true;
 802                         }
 803                         else
 804                                 throw;
 805                 }
 806
 807                 if (isClosed)
 808                         printf("  ok!\n");
 809                 else
 810                         XS_FAIL("Server didn't close connection");
 811         }
 812
 813         void runProgram (void) { /* nothing */ }
 814 };
 815
 816 void printHelp (const char* binName)
 817 {
 818         printf("%s:\n", binName);
 819         printf("  --client=[name]       Run test [name]\n");
 820         printf("  --program=[name]      Run program for test [name]\n");
 821         printf("  --host=[host]         Connect to host [host]\n");
 822         printf("  --port=[name]         Use port [port]\n");
 823         printf("  --tester-cmd=[cmd]    Launch tester with [cmd]\n");
 824         printf("  --server-cmd=[cmd]    Launch server with [cmd]\n");
 825         printf("  --start-server        Start server for test execution\n");
 826 }
 827
 828 struct CompareCaseName
 829 {
 830         std::string name;
 831
 832         CompareCaseName (const string& name_) : name(name_) {}
 833
 834         bool operator() (const TestCase* testCase) const
 835         {
 836                 return name == testCase->getName();
 837         }
 838 };
 839
 840 void runExecServerTests (int argc, const char* const* argv)
 841 {
 842         // Construct test context.
 843         TestContext testCtx;
 844
 845         testCtx.serverPath      = "execserver";
 846         testCtx.testerPath      = argv[0];
 847         testCtx.startServer     = false;
 848         testCtx.address.setHost("127.0.0.1");
 849         testCtx.address.setPort(50016);
 850
 851         std::string runClient = "";
 852         std::string runProgram = "";
 853
 854         // Parse command line.
 855         for (int argNdx = 1; argNdx < argc; argNdx++)
 856         {
 857                 const char* arg = argv[argNdx];
 858
 859                 if (deStringBeginsWith(arg, "--client="))
 860                         runClient = arg+9;
 861                 else if (deStringBeginsWith(arg, "--program="))
 862                         runProgram = arg+10;
 863                 else if (deStringBeginsWith(arg, "--port="))
 864                         testCtx.address.setPort(atoi(arg+7));
 865                 else if (deStringBeginsWith(arg, "--host="))
 866                         testCtx.address.setHost(arg+7);
 867                 else if (deStringBeginsWith(arg, "--server-cmd="))
 868                         testCtx.serverPath = arg+13;
 869                 else if (deStringBeginsWith(arg, "--tester-cmd="))
 870                         testCtx.testerPath = arg+13;
 871                 else if (deStringBeginsWith(arg, "--deqp-log-filename="))
 872                         testCtx.logFileName = arg+20;
 873                 else if (deStringBeginsWith(arg, "--deqp-caselist="))
 874                         testCtx.caseList = arg+16;
 875                 else if (deStringEqual(arg, "--deqp-stdin-caselist"))
 876                 {
 877                         // \todo [pyry] This is rather brute-force solution...
 878                         char c;
 879                         while (fread(&c, 1, 1, stdin) == 1 && c != 0)
 880                                 testCtx.caseList += c;
 881                 }
 882                 else if (deStringEqual(arg, "--start-server"))
 883                         testCtx.startServer = true;
 884                 else
 885                 {
 886                         printHelp(argv[0]);
 887                         return;
 888                 }
 889         }
 890
 891         // Test case list.
 892         std::vector<TestCase*> testCases;
 893         testCases.push_back(new ConnectTest(testCtx));
 894         testCases.push_back(new HelloTest(testCtx));
 895         testCases.push_back(new ExecFailTest(testCtx));
 896         testCases.push_back(new SimpleExecTest(testCtx));
 897         testCases.push_back(new InfoTest(testCtx));
 898         testCases.push_back(new LogDataTest(testCtx));
 899         testCases.push_back(new KeepAliveTest(testCtx));
 900         testCases.push_back(new BigLogDataTest(testCtx));
 901
 902         try
 903         {
 904                 if (!runClient.empty())
 905                 {
 906                         // Run single case.
 907                         vector<TestCase*>::iterator casePos = std::find_if(testCases.begin(), testCases.end(), CompareCaseName(runClient));
 908                         XS_CHECK(casePos != testCases.end());
 909                         TestExecutor executor(testCtx);
 910                         executor.runCase(*casePos);
 911                 }
 912                 else if (!runProgram.empty())
 913                 {
 914                         // Run program part.
 915                         vector<TestCase*>::iterator casePos = std::find_if(testCases.begin(), testCases.end(), CompareCaseName(runProgram));
 916                         XS_CHECK(casePos != testCases.end());
 917                         (*casePos)->runProgram();
 918                         fflush(stdout); // Make sure handles are flushed.
 919                         fflush(stderr);
 920                 }
 921                 else
 922                 {
 923                         // Run all tests.
 924                         TestExecutor executor(testCtx);
 925                         executor.runCases(testCases);
 926                 }
 927         }
 928         catch (const std::exception& e)
 929         {
 930                 printf("ERROR: %s\n", e.what());
 931         }
 932
 933         // Destroy cases.
 934         for (std::vector<TestCase*>::const_iterator i = testCases.begin(); i != testCases.end(); i++)
 935                 delete *i;
 936 }
 937
 938 } // xs
 939
 940 #if 0
 941 void testProcFile (void)
 942 {
 943         /* Test file api. */
 944         if (deFileExists("test.txt"))
 945                 deDeleteFile("test.txt");
 946         deFile* file = deFile_create("test.txt", DE_FILEMODE_CREATE|DE_FILEMODE_WRITE);
 947         const char test[] = "Hello";
 948         XS_CHECK(deFile_write(file, test, sizeof(test), DE_NULL) == DE_FILERESULT_SUCCESS);
 949         deFile_destroy(file);
 950
 951         /* Read. */
 952         char buf[10] = { 0 };
 953         file = deFile_create("test.txt", DE_FILEMODE_OPEN|DE_FILEMODE_READ);
 954         XS_CHECK(deFile_read(file, buf, sizeof(test), DE_NULL) == DE_FILERESULT_SUCCESS);
 955         printf("buf: %s\n", buf);
 956         deFile_destroy(file);
 957
 958         /* Process test. */
 959         deProcess* proc = deProcess_create("ls -lah /Users/pyry", DE_NULL);
 960         deFile* out = deProcess_getStdOut(proc);
 961
 962         deInt64 numRead = 0;
 963         printf("ls:\n");
 964         while (deFile_read(out, buf, sizeof(buf)-1, &numRead) == DE_FILERESULT_SUCCESS)
 965         {
 966                 buf[numRead] = 0;
 967                 printf("%s", buf);
 968         }
 969         deProcess_destroy(proc);
 970 }
 971 #endif
 972
 973 #if 0
 974 void testBlockingFile (const char* filename)
 975 {
 976         deRandom        rnd;
 977         int                     dataSize        = 1024*1024;
 978         deUint8*        data            = (deUint8*)deCalloc(dataSize);
 979         deFile*         file;
 980
 981         deRandom_init(&rnd, 0);
 982
 983         if (deFileExists(filename))
 984                 DE_VERIFY(deDeleteFile(filename));
 985
 986         /* Fill in with random data. */
 987         DE_ASSERT(dataSize % sizeof(int) == 0);
 988         for (int ndx = 0; ndx < (int)(dataSize/sizeof(int)); ndx++)
 989                 ((deUint32*)data)[ndx] = deRandom_getUint32(&rnd);
 990
 991         /* Write with random-sized blocks. */
 992         file = deFile_create(filename, DE_FILEMODE_CREATE|DE_FILEMODE_WRITE);
 993         DE_VERIFY(file);
 994
 995         int curPos = 0;
 996         while (curPos < dataSize)
 997         {
 998                 int                             blockSize       = 1 + deRandom_getUint32(&rnd) % (dataSize-curPos);
 999                 deInt64                 numWritten      = 0;
1000                 deFileResult    result          = deFile_write(file, &data[curPos], blockSize, &numWritten);
1001
1002                 DE_VERIFY(result == DE_FILERESULT_SUCCESS);
1003                 DE_VERIFY(numWritten == blockSize);
1004
1005                 curPos += blockSize;
1006         }
1007
1008         deFile_destroy(file);
1009
1010         /* Read and verify file. */
1011         file    = deFile_create(filename, DE_FILEMODE_OPEN|DE_FILEMODE_READ);
1012         curPos  = 0;
1013         while (curPos < dataSize)
1014         {
1015                 deUint8                 block[1024];
1016                 int                             numToRead       = 1 + deRandom_getUint32(&rnd) % deMin(dataSize-curPos, DE_LENGTH_OF_ARRAY(block));
1017                 deInt64                 numRead         = 0;
1018                 deFileResult    result          = deFile_read(file, block, numToRead, &numRead);
1019
1020                 DE_VERIFY(result == DE_FILERESULT_SUCCESS);
1021                 DE_VERIFY((int)numRead == numToRead);
1022                 DE_VERIFY(deMemCmp(block, &data[curPos], numToRead) == 0);
1023
1024                 curPos += numToRead;
1025         }
1026         deFile_destroy(file);
1027 }
1028 #endif
1029
1030 int main (int argc, const char* const* argv)
1031 {
1032         xs::runExecServerTests(argc, argv);
1033         return 0;
1034 }