sal/cppunittester/cppunittester.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifdef WNT
  21 #include <windows.h>
  22 #endif
  23
  24 #include <cstdlib>
  25 #include <iostream>
  26 #include <string>
  27 #include <sal/types.h>
  28 #include "cppunittester/protectorfactory.hxx"
  29 #include "osl/module.h"
  30 #include "osl/module.hxx"
  31 #include "osl/thread.h"
  32 #include "rtl/process.h"
  33 #include "rtl/string.h"
  34 #include "rtl/string.hxx"
  35 #include "rtl/textcvt.h"
  36 #include "rtl/ustring.hxx"
  37 #include "sal/main.h"
  38
  39 #include "cppunit/CompilerOutputter.h"
  40 #include "cppunit/Exception.h"
  41 #include "cppunit/TestFailure.h"
  42 #include "cppunit/TestResult.h"
  43 #include "cppunit/TestResultCollector.h"
  44 #include "cppunit/TestRunner.h"
  45 #include "cppunit/extensions/TestFactoryRegistry.h"
  46 #include "cppunit/plugin/PlugInManager.h"
  47 #include "cppunit/plugin/DynamicLibraryManagerException.h"
  48 #include "cppunit/portability/Stream.h"
  49
  50 #include "boost/noncopyable.hpp"
  51 #include <boost/scoped_array.hpp>
  52 #include <boost/algorithm/string.hpp>
  53
  54 #include <algorithm>
  55
  56 namespace {
  57
  58 void usageFailure() {
  59     std::cerr
  60         << ("Usage: cppunittester (--protector <shared-library-path>"
  61             " <function-symbol>)* <shared-library-path>")
  62         << std::endl;
  63     std::exit(EXIT_FAILURE);
  64 }
  65
  66 rtl::OUString getArgument(sal_Int32 index) {
  67     rtl::OUString arg;
  68     rtl_getAppCommandArg(index, &arg.pData);
  69     return arg;
  70 }
  71
  72 std::string convertLazy(rtl::OUString const & s16) {
  73     rtl::OString s8(rtl::OUStringToOString(s16, osl_getThreadTextEncoding()));
  74     static_assert(sizeof (sal_Int32) <= sizeof (std::string::size_type), "must be at least the same size");
  75         // ensure following cast is legitimate
  76     return std::string(
  77         s8.getStr(), static_cast< std::string::size_type >(s8.getLength()));
  78 }
  79
  80 #if defined TIMETESTS
  81 //Output how long each test took
  82 class TimingListener
  83     : public CppUnit::TestListener
  84     , private boost::noncopyable
  85 {
  86 public:
  87     void startTest( CppUnit::Test *) SAL_OVERRIDE
  88     {
  89         m_nStartTime = osl_getGlobalTimer();
  90     }
  91
  92     void endTest( CppUnit::Test *test ) SAL_OVERRIDE
  93     {
  94         sal_uInt32 nEndTime = osl_getGlobalTimer();
  95         std::cout << test->getName() << ": " << nEndTime-m_nStartTime
  96             << "ms" << std::endl;
  97     }
  98
  99 private:
 100     sal_uInt32 m_nStartTime;
 101 };
 102 #endif
 103
 104 #ifdef UNX
 105 #include <stdlib.h>
 106 // Setup an env variable so that temp file (or other) can
 107 // have a useful value to identify the source
 108 class EyecatcherListener
 109     : public CppUnit::TestListener
 110     , private boost::noncopyable
 111 {
 112 public:
 113     void startTest( CppUnit::Test* test) SAL_OVERRIDE
 114     {
 115         boost::scoped_array<char> tn(new char [ test->getName().length() + 2 ]);
 116         strcpy(tn.get(), test->getName().c_str());
 117         int len = strlen(tn.get());
 118         for(int i = 0; i < len; i++)
 119         {
 120             if(!isalnum(tn[i]))
 121             {
 122                 tn[i] = '_';
 123             }
 124         }
 125         tn[len] = '_';
 126         tn[len + 1] = 0;
 127         setenv("LO_TESTNAME", tn.get(), true);
 128     }
 129
 130     void endTest( CppUnit::Test* /* test */ ) SAL_OVERRIDE
 131     {
 132     }
 133 };
 134 #endif
 135
 136 class LogFailuresAsTheyHappen : public CppUnit::TestListener
 137 {
 138 public:
 139     virtual void addFailure( const CppUnit::TestFailure &failure ) SAL_OVERRIDE
 140     {
 141         printFailureLocation( failure.sourceLine() );
 142         printFailedTestName( failure );
 143         printFailureMessage( failure );
 144     }
 145
 146 private:
 147     static void printFailureLocation( const CppUnit::SourceLine &sourceLine )
 148     {
 149         if ( !sourceLine.isValid() )
 150             std::cerr << "unknown:0:";
 151         else
 152             std::cerr << sourceLine.fileName() << ":" << sourceLine.lineNumber() << ":";
 153     }
 154
 155     static void printFailedTestName( const CppUnit::TestFailure &failure )
 156     {
 157         std::cerr << failure.failedTestName() << std::endl;
 158     }
 159
 160     static void printFailureMessage( const CppUnit::TestFailure &failure )
 161     {
 162         std::cerr << failure.thrownException()->message().shortDescription() << std::endl;
 163         std::cerr << failure.thrownException()->message().details() << std::endl;
 164     }
 165 };
 166
 167 namespace {
 168
 169 void addRecursiveTests(const std::vector<std::string>& test_names, CppUnit::Test* pTest, CppUnit::TestRunner& rRunner)
 170 {
 171     for (int i = 0; i < pTest->getChildTestCount(); ++i)
 172     {
 173         CppUnit::Test* pNewTest = pTest->getChildTestAt(i);
 174         addRecursiveTests(test_names, pNewTest, rRunner);
 175         if (std::find(test_names.begin(), test_names.end(), pNewTest->getName()) != test_names.end())
 176             rRunner.addTest(pNewTest);
 177     }
 178 }
 179
 180 }
 181
 182 //Allow the whole uniting testing framework to be run inside a "Protector"
 183 //which knows about uno exceptions, so it can print the content of the
 184 //exception before falling over and dying
 185 class CPPUNIT_API ProtectedFixtureFunctor
 186     : public CppUnit::Functor
 187     , private boost::noncopyable
 188 {
 189 private:
 190     const std::string &testlib;
 191     const std::string &args;
 192     std::vector<CppUnit::Protector *> &protectors;
 193     CppUnit::TestResult &result;
 194 public:
 195     ProtectedFixtureFunctor(const std::string& testlib_, const std::string &args_, std::vector<CppUnit::Protector*> &protectors_, CppUnit::TestResult &result_)
 196         : testlib(testlib_)
 197         , args(args_)
 198         , protectors(protectors_)
 199         , result(result_)
 200     {
 201     }
 202     bool run() const
 203     {
 204 #ifdef DISABLE_DYNLOADING
 205
 206         // NOTE: Running cppunit unit tests on iOS was something I did
 207         // only very early (several years ago) when starting porting
 208         // this stuff to iOS. The complicated mechanisms to do build
 209         // such unit test single executables have surely largely
 210         // bit-rotted or been semi-intentionally broken since. This
 211         // stuff here left for information only. --tml 2014.
 212
 213         // For iOS cppunit plugins aren't really "plugins" (shared
 214         // libraries), but just static archives. In the real main
 215         // program of a cppunit app, which calls the lo_main() that
 216         // the SAL_IMPLEMENT_MAIN() below expands to, we specifically
 217         // call the initialize methods of the CppUnitTestPlugIns that
 218         // we statically link to the app executable.
 219 #else
 220         CppUnit::PlugInManager manager;
 221         try {
 222             manager.load(testlib, args);
 223         } catch (const CppUnit::DynamicLibraryManagerException &e) {
 224             std::cerr << "DynamicLibraryManagerException: \"" << e.what() << "\"\n";
 225 #ifdef WIN32
 226             const char *pPath = getenv ("PATH");
 227             if (pPath && strlen (pPath) > 256)
 228             {
 229                 std::cerr << "Windows has significant build problems with long PATH variables ";
 230                 std::cerr << "please check your PATH variable and re-autogen.\n";
 231             }
 232 #endif
 233             std::cerr << "Path is '" << getenv("PATH") << "'\n";
 234             return false;
 235         }
 236 #endif
 237
 238         for (size_t i = 0; i < protectors.size(); ++i)
 239             result.pushProtector(protectors[i]);
 240
 241         bool success;
 242         {
 243             CppUnit::TestResultCollector collector;
 244             result.addListener(&collector);
 245
 246             LogFailuresAsTheyHappen logger;
 247             result.addListener(&logger);
 248
 249 #ifdef TIMETESTS
 250             TimingListener timer;
 251             result.addListener(&timer);
 252 #endif
 253
 254 #ifdef UNX
 255             EyecatcherListener eye;
 256             result.addListener(&eye);
 257             // set this to track down files created before first test method
 258             std::string lib(testlib.substr(testlib.rfind('/')+1));
 259             setenv("LO_TESTNAME", lib.c_str(), true);
 260 #endif
 261
 262             const char* pVal = getenv("CPPUNIT_TEST_NAME");
 263
 264             CppUnit::TestRunner runner;
 265             if (pVal)
 266             {
 267                 std::vector<std::string> test_names;
 268                 boost::split(test_names, pVal, boost::is_any_of("\t "));
 269                 CppUnit::Test* pTest = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
 270                 addRecursiveTests(test_names, pTest, runner);
 271             }
 272             else
 273             {
 274                 runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
 275             }
 276             runner.run(result);
 277
 278             CppUnit::CompilerOutputter outputter(&collector, CppUnit::stdCErr());
 279             outputter.setNoWrap();
 280             outputter.write();
 281             success = collector.wasSuccessful();
 282         }
 283
 284         for (size_t i = 0; i < protectors.size(); ++i)
 285             result.popProtector();
 286
 287         return success;
 288     }
 289     virtual bool operator()() const SAL_OVERRIDE
 290     {
 291         return run();
 292     }
 293 };
 294
 295 }
 296
 297 SAL_IMPLEMENT_MAIN()
 298 {
 299     bool ok = false;
 300     try
 301     {
 302 #ifdef WNT
 303         //Disable Dr-Watson in order to crash simply without popup dialogs under
 304         //windows
 305         DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
 306         SetErrorMode(SEM_NOGPFAULTERRORBOX|dwMode);
 307 #ifdef _DEBUG // These functions are present only in the debgging runtime
 308         _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 309         _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
 310         _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 311         _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
 312         _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 313         _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 314 #endif
 315 #endif
 316
 317         std::vector<CppUnit::Protector *> protectors;
 318         CppUnit::TestResult result;
 319         std::string args;
 320         std::string testlib;
 321         sal_uInt32 index = 0;
 322         while (index < rtl_getAppCommandArgCount())
 323         {
 324             rtl::OUString arg = getArgument(index);
 325             if ( arg != "--protector" )
 326             {
 327                 if (testlib.empty())
 328                 {
 329                     testlib = rtl::OUStringToOString(arg, osl_getThreadTextEncoding()).getStr();
 330                     args += testlib;
 331                 }
 332                 else
 333                 {
 334                     args += ' ';
 335                     args += rtl::OUStringToOString(arg, osl_getThreadTextEncoding()).getStr();
 336                 }
 337                 ++index;
 338                 continue;
 339             }
 340             if (rtl_getAppCommandArgCount() - index < 3) {
 341                 usageFailure();
 342             }
 343             rtl::OUString lib(getArgument(index + 1));
 344             rtl::OUString sym(getArgument(index + 2));
 345 #ifndef DISABLE_DYNLOADING
 346             osl::Module mod(lib, SAL_LOADMODULE_GLOBAL);
 347             oslGenericFunction fn = mod.getFunctionSymbol(sym);
 348             mod.release();
 349 #else
 350             oslGenericFunction fn = 0;
 351             if (sym == "unoexceptionprotector")
 352                 fn = (oslGenericFunction) unoexceptionprotector;
 353             else if (sym == "unobootstrapprotector")
 354                 fn = (oslGenericFunction) unobootstrapprotector;
 355             else if (sym == "vclbootstrapprotector")
 356                 fn = (oslGenericFunction) vclbootstrapprotector;
 357             else
 358             {
 359                 std::cerr
 360                     << "Only unoexceptionprotector or unobootstrapprotector protectors allowed"
 361                     << std::endl;
 362                 std::exit(EXIT_FAILURE);
 363             }
 364 #endif
 365             CppUnit::Protector *protector = fn == 0
 366                 ? 0
 367                 : (*reinterpret_cast< cppunittester::ProtectorFactory * >(fn))();
 368             if (protector == 0) {
 369                 std::cerr
 370                     << "Failure instantiating protector \"" << convertLazy(lib)
 371                     << "\", \"" << convertLazy(sym) << '"' << std::endl;
 372                 std::exit(EXIT_FAILURE);
 373             }
 374             protectors.push_back(protector);
 375             index+=3;
 376         }
 377
 378         ProtectedFixtureFunctor tests(testlib, args, protectors, result);
 379         ok = tests.run();
 380     }
 381     catch (const std::exception& e)
 382     {
 383         SAL_WARN("vcl.app", "Fatal exception: " << e.what());
 384     }
 385
 386     return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 387 }
 388
 389 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */