testshl2/source/testshl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: testshl.cxx,v $
  10  * $Revision: 1.25 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_testshl2.hxx"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <unistd.h>
  37
  38 #ifdef SOLARIS
  39 #include <sys/time.h>
  40 #endif
  41
  42 #ifdef WNT
  43 # include "testshl/winstuff.hxx"
  44 #endif
  45
  46 #include <iostream>
  47 #include <vector>
  48 #include <memory> /* auto_ptr */
  49 #include "sal/main.h"
  50 #include <rtl/string.hxx>
  51
  52 // #include <rtl/tres.h>
  53 #include "testshl/autoregisterhelper.hxx"
  54 // #include "cmdlinebits.hxx"
  55 #include "testshl/log.hxx"
  56 #include "testshl/filehelper.hxx"
  57 #include "testshl/getopt.hxx"
  58 #include "cppunit/result/outputter.hxx"
  59 #include "cppunit/joblist.hxx"
  60
  61 // #include <osl/time.h>
  62
  63 using namespace std;
  64
  65 #include "cppunit/result/testshlTestResult.h"
  66 #include "cppunit/result/emacsTestResult.hxx"
  67
  68 // Prototype for signal handling
  69 void setSignalFilename(GetOpt & opt);
  70 void removeSignalFile(GetOpt & opt);
  71 CmdLineBits st_nBits;
  72
  73 void initTPrint(GetOpt & _aOptions)
  74 {
  75     st_nBits = FileHelper::createFlags(_aOptions);
  76 }
  77
  78 void my_sleep(int nCount)
  79 {
  80 #ifdef WNT
  81     WinSleep(nCount * 2);
  82 #else
  83     usleep(nCount * 2000);
  84 #endif
  85 }
  86
  87 // -----------------------------------------------------------------------------
  88 class ProcessHandler
  89 {
  90     std::string m_sProcessIDFilename;
  91     void write(int);
  92     int  getPID();
  93 public:
  94     ProcessHandler();
  95     void setName(std::string const& _sFilename);
  96     ~ProcessHandler();
  97 };
  98
  99 // ------------------------------- ProcessHelper -------------------------------
 100 ProcessHandler::ProcessHandler() {}
 101
 102 void ProcessHandler::setName(std::string const& _sPIDFilename)
 103 {
 104     m_sProcessIDFilename = _sPIDFilename;
 105     write(getPID());
 106 }
 107
 108 int ProcessHandler::getPID()
 109 {
 110     int nPID = 0;
 111 #ifdef WNT
 112     nPID = WinGetCurrentProcessId();
 113 #else
 114     nPID = getpid();
 115 #endif
 116
 117     return nPID;
 118 }
 119
 120 void ProcessHandler::write(int _nPID)
 121 {
 122     // get own PID
 123
 124     if (m_sProcessIDFilename.size() > 0)
 125     {
 126         FILE* out;
 127         out = fopen(m_sProcessIDFilename.c_str(), "w");
 128         if (!out)
 129         {
 130             fprintf(stderr, "warning: (testshl.cxx) can't write own pid.\n");
 131             return;
 132             // exit(0);
 133         }
 134         fprintf(out, "%d", _nPID);
 135         fclose(out);
 136         my_sleep(2); // short wait, so testshl2_timeout can find this pid.
 137     }
 138     else
 139     {
 140         fprintf(stderr, "warning: (testshl.cxx) PID Filename empty, must set.\n");
 141     }
 142 }
 143
 144 ProcessHandler::~ProcessHandler()
 145 {
 146     if (m_sProcessIDFilename.size() > 0)
 147     {
 148         write(0);
 149         my_sleep(2);
 150         fprintf(stderr, "hint: it is save to remove PID file.\n");
 151     }
 152 }
 153
 154 // -----------------------------------------------------------------------------
 155 std::auto_ptr<CppUnit::TestResult> initResult(GetOpt & _aOptions)
 156 {
 157     std::auto_ptr<CppUnit::TestResult> pResult;
 158     if (_aOptions.hasOpt("-mode"))
 159     {
 160         if (_aOptions.getOpt("-mode").equals("emacs") == sal_True)
 161         {
 162             pResult.reset(new CppUnit::emacsTestResult(_aOptions));
 163         }
 164     }
 165     else
 166     {
 167         pResult.reset(new CppUnit::testshlTestResult(_aOptions));
 168     }
 169     return pResult;
 170 }
 171
 172 // -----------------------------------------------------------------------------
 173
 174 std::auto_ptr<Outputter> initOutputter(GetOpt & _aOptions)
 175 {
 176     std::auto_ptr<Outputter> pOutputter;
 177
 178     if (_aOptions.hasOpt("-log"))
 179     {
 180         rtl::OString sLogFile = _aOptions.getOpt("-log");
 181
 182         Log* pLog = new Log( FileHelper::convertPath( sLogFile ) );
 183         if ( pLog->open() != osl::FileBase::E_None )
 184         {
 185             // cerr << "could not open LogFile: " << pLog->getName().getStr() << endl;
 186             fprintf(stderr, "could not open LogFile: %s\n", pLog->getName().getStr());
 187             exit(1);
 188         }
 189         pOutputter.reset(new Outputter(pLog));
 190     }
 191     else
 192     {
 193         pOutputter.reset(new Outputter(std::cout));
 194     }
 195
 196     return pOutputter;
 197 }
 198
 199 int starttest(GetOpt & opt, AutomaticRegisterHelper const& aHelper);
 200
 201 void makeslow()
 202 {
 203     sal_Int32 n = 0;
 204     for (sal_Int32 i=0;i<1024 * 1024;i++)
 205     {
 206         ++n;
 207     }
 208 }
 209 //      void endless()
 210 //      {
 211 //              sal_Int64 n = 0;
 212 //              while(1)
 213 //              {
 214 //                      n++;
 215 //                      makeslow();
 216 //                      my_sleep(1);
 217 //              }
 218 //      }
 219
 220 // ----------------------------------- Main -----------------------------------
 221
 222 SAL_IMPLEMENT_MAIN_WITH_ARGS(, argv)
 223 {
 224     static char const * optionSet[] = {
 225         "-boom,         stop near error position, exception only",
 226         "-mode=s,       the output mode, emacs, xml, old. Default is -mode old",
 227         "-log=s,        destination file for logging",
 228         "-noerrors,     shows all tests, but not it's errors.",
 229         "-onlyerrors,   shows only the failed test functions",
 230 /*      "-tc=s@,        name(s) of testcase(s) to generate", */
 231         "-sf=s,         absolute path and name to the signal file.",
 232 //! new (helpful if at debug time)
 233         "-dntsf,        if given, do not touch signal file, also if one exist.",
 234         "-dnrmsf,       do not remove signalfile. ",
 235         "-jobonly=s,    job control file, these jobs should only executed.",
 236         "-jobexclude=s, job control file, but contains only job, they not execute.",
 237         "-jobfilter=s,  use a filter for just some tests.",
 238         "-onlyshowjobs, show only all jobs, do no tests.",
 239         "-forward=s,    this string will forwarded to the test libraries.",
 240         "-projectid=s,  this text is added to the date output line.",
 241         "-buildid=s,    this text is added to the date output line.",
 242         "-waitforkey,   wait until key pressed.",
 243         "-verbose,      be verbose.",
 244         "-quiet,        be quiet. No t_print(...) will create output.",
 245         "-pid=s,        write current process id to file",
 246         "-endless,      testshl runs endless, for test only!!!",
 247         "-whereami,     shows at runtime, which function is tested next.",
 248         "-noerroronexit, if this is given the program exits with return code 0 even if runtime errors occurs.",
 249         "-hardexit,     Exit the tests without call any dtor.",
 250         "-absolutepath, Use the given absolute path to local the test library.",
 251         "-localpath,    Make a chdir() to the test library path, then try to load the library without given path.",
 252         "-h:s,          display help or help on option",
 253         "-help:s,       see -h",
 254         NULL
 255     };
 256
 257     ProcessHandler aCurrentProcess;
 258
 259     GetOpt opt( argv, optionSet );
 260     initTPrint(opt);
 261
 262     if ( opt.hasOpt("-pid") )
 263     {
 264         aCurrentProcess.setName(opt.getOpt("-pid").getStr());
 265     }
 266
 267     if ( opt.hasOpt("-verbose") )
 268     {
 269         fprintf(stderr, "testshl2 $Revision: 1.25 $\n");
 270     }
 271
 272     if ( opt.hasOpt("-endless"))                 // this exists only for self test issues
 273     {
 274 //        endless();
 275
 276 // With parameter -endless a test is attachable by debuggers
 277 // Attach to testshl2.exe set a breakpoint in this while (1) loop
 278
 279 // Then you have to set the process pointer (Set next Statement) to
 280 // the next line outside the while loop.
 281 // Now it is possible to debug the whole code.
 282 // Never source this code to a function, because you will
 283 // lost the variables like opt.
 284
 285         sal_Int64 n = 0;
 286         while(1)
 287         {
 288             n++;
 289             makeslow();
 290             my_sleep(1);
 291         }
 292     }
 293
 294     int  nExitCode = 0;
 295     bool bLibrary = true;
 296
 297     // someone indicates that he needs help
 298     if ( opt.hasOpt( "-h" ) || opt.hasOpt( "-help" ) )
 299     {
 300         opt.showUsage();
 301         nExitCode = 0;
 302     }
 303     else
 304     {
 305         if (opt.getParams().empty())
 306         {
 307             // no library is given, but if a jobonly list is given, we should generate UNKNOWN errors.
 308             if (! opt.hasOpt("-jobonly"))
 309             {
 310                 // std::cerr << "error: At least a library or a job file should given." << std::endl;
 311                 fprintf(stderr, "error: At least a library or a job file should given.\n");
 312                 opt.showUsage();
 313                 nExitCode = 2;
 314             }
 315             else
 316             {
 317                 bLibrary = false;
 318             }
 319         }
 320         else
 321         {
 322             setSignalFilename(opt);
 323
 324             rtl::OUString suLibraryName;
 325             if (bLibrary)
 326             {
 327                 suLibraryName = rtl::OStringToOUString(opt.getFirstParam(), osl_getThreadTextEncoding() /* RTL_TEXTENCODING_ASCII_US */ );
 328             }
 329
 330             AutomaticRegisterHelper aHelper(suLibraryName, opt /*, &aJobs*/);
 331
 332             if (aHelper.isOkToStartTests())
 333             {
 334                 // start the tests
 335                 nExitCode = starttest(opt, aHelper);
 336             }
 337             else
 338             {
 339
 340                 fprintf(stderr, "error: The library '%s' can't initialised, must quit.\n", opt.getFirstParam().getStr());
 341                 nExitCode = 1;
 342             }
 343         }
 344     }
 345
 346     if (opt.hasOpt("-noerroronexit"))
 347     {
 348         nExitCode = 0;
 349     }
 350     return nExitCode;
 351 }
 352
 353 // -----------------------------------------------------------------------------
 354 // this function is only inserted to give a better startpoint for breakpoints
 355
 356 int starttest(GetOpt & _opt, AutomaticRegisterHelper const& aHelper)
 357 {
 358     // create a TestResult
 359     std::auto_ptr<CppUnit::TestResult> pResult = initResult(_opt);
 360
 361     // call all test functions
 362     aHelper.CallAll(pResult.get());
 363
 364     // create and open log
 365     std::auto_ptr<Outputter> pOutput = initOutputter(_opt);
 366
 367     // give the output
 368     pResult->print(*pOutput.get());
 369
 370     // this is a debug extension, so you can read the output and after a key is pressed the program will end.
 371     if (_opt.hasOpt("-waitforkey"))
 372     {
 373         fprintf(stderr, "Press return key.");
 374         fflush(stderr);
 375         getchar();
 376     }
 377
 378     if (_opt.hasOpt("-verbose"))
 379     {
 380         fprintf(stderr, "Remove signal handlers");
 381     }
 382
 383     removeSignalFile(_opt);
 384
 385     if (_opt.hasOpt("-verbose"))
 386     {
 387         fprintf(stderr, " [done]\n");
 388     }
 389
 390     if (_opt.hasOpt("-hardexit"))
 391     {
 392         fprintf(stderr, "Hardexit forced.\n");
 393         abort();
 394     }
 395
 396     int nExit = pResult->getExitValue();
 397     return nExit;
 398 }
 399