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 _WIN32
  21 #if !defined WIN32_LEAN_AND_MEAN
  22 # define WIN32_LEAN_AND_MEAN
  23 #endif
  24 #include <windows.h>
  25 #endif
  26 #if defined(_WIN32) && defined(_DEBUG)
  27 #include <dbghelp.h>
  28 #include <sal/backtrace.hxx>
  29 #include <signal.h>
  30 #endif
  31
  32 #ifdef UNX
  33 #include <sys/time.h>
  34 #include <sys/resource.h>
  35 #endif
  36
  37 #include <stdlib.h>
  38 #include <cstdlib>
  39 #include <iostream>
  40 #include <string>
  41 #include <sal/log.hxx>
  42 #include <sal/types.h>
  43 #include <cppunittester/protectorfactory.hxx>
  44 #include <osl/module.h>
  45 #include <osl/module.hxx>
  46 #include <osl/thread.h>
  47 #include <rtl/character.hxx>
  48 #include <rtl/process.h>
  49 #include <rtl/string.h>
  50 #include <rtl/string.hxx>
  51 #include <rtl/strbuf.hxx>
  52 #include <rtl/textcvt.h>
  53 #include <rtl/ustring.hxx>
  54 #include <sal/main.h>
  55
  56 #include <cppunit/CompilerOutputter.h>
  57 #include <cppunit/Exception.h>
  58 #include <cppunit/TestFailure.h>
  59 #include <cppunit/TestResult.h>
  60 #include <cppunit/TestResultCollector.h>
  61 #include <cppunit/TestRunner.h>
  62 #include <cppunit/extensions/TestFactoryRegistry.h>
  63 #include <cppunit/plugin/PlugInManager.h>
  64 #include <cppunit/plugin/DynamicLibraryManagerException.h>
  65 #include <cppunit/portability/Stream.h>
  66
  67 #include <memory>
  68 #include <boost/algorithm/string.hpp>
  69
  70 #include <algorithm>
  71 #include <string_view>
  72 #include <utility>
  73
  74 namespace {
  75
  76 void usageFailure() {
  77     std::cerr
  78         << ("Usage: cppunittester (--protector <shared-library-path>"
  79             " <function-symbol>)* <shared-library-path>")
  80         << std::endl;
  81     std::exit(EXIT_FAILURE);
  82 }
  83
  84 OUString getArgument(sal_Int32 index) {
  85     OUString arg;
  86     osl_getCommandArg(index, &arg.pData);
  87     return arg;
  88 }
  89
  90 std::string convertLazy(std::u16string_view s16) {
  91     OString s8(OUStringToOString(s16, osl_getThreadTextEncoding()));
  92     static_assert(sizeof (sal_Int32) <= sizeof (std::string::size_type), "must be at least the same size");
  93         // ensure following cast is legitimate
  94     return std::string(s8);
  95 }
  96
  97 //Output how long each test took
  98 class TimingListener
  99     : public CppUnit::TestListener
 100 {
 101 public:
 102     TimingListener()
 103         : m_nStartTime(0)
 104     {
 105     }
 106     TimingListener(const TimingListener&) = delete;
 107     TimingListener& operator=(const TimingListener&) = delete;
 108
 109     void startTest( CppUnit::Test *test) override
 110     {
 111         std::cout << "[_RUN_____] " << test->getName() << std::endl;
 112         m_nStartTime = osl_getGlobalTimer();
 113     }
 114
 115     void endTest( CppUnit::Test *test ) override
 116     {
 117         sal_uInt32 nEndTime = osl_getGlobalTimer();
 118         std::cout << test->getName() << " finished in: "
 119             << nEndTime-m_nStartTime << "ms" << std::endl;
 120     }
 121
 122 private:
 123     sal_uInt32 m_nStartTime;
 124 };
 125
 126 // Setup an env variable so that temp file (or other) can
 127 // have a useful value to identify the source
 128 class EyecatcherListener
 129     : public CppUnit::TestListener
 130 {
 131 public:
 132     EyecatcherListener() = default;
 133     EyecatcherListener(const EyecatcherListener&) = delete;
 134     EyecatcherListener& operator=(const EyecatcherListener&) = delete;
 135     void startTest( CppUnit::Test* test) override
 136     {
 137         rtl::OStringBuffer tn(test->getName());
 138         for(int i = 0; i < tn.getLength(); i++)
 139         {
 140             if(!rtl::isAsciiAlphanumeric(static_cast<unsigned char>(tn[i])))
 141             {
 142                 tn[i] = '_';
 143             }
 144         }
 145         tn.append('_');
 146 #ifdef WIN32
 147         _putenv_s("LO_TESTNAME", tn.getStr());
 148 #else
 149         setenv("LO_TESTNAME", tn.getStr(), true);
 150 #endif
 151     }
 152
 153     void endTest( CppUnit::Test* /* test */ ) override
 154     {
 155     }
 156 };
 157
 158 class LogFailuresAsTheyHappen : public CppUnit::TestListener
 159 {
 160 public:
 161     virtual void addFailure( const CppUnit::TestFailure &failure ) override
 162     {
 163         printFailureLocation( failure.sourceLine() );
 164         printFailedTestName( failure );
 165         printFailureMessage( failure );
 166     }
 167
 168 private:
 169     static void printFailureLocation( const CppUnit::SourceLine &sourceLine )
 170     {
 171         if ( !sourceLine.isValid() )
 172             std::cerr << "unknown:0:";
 173         else
 174             std::cerr << sourceLine.fileName() << ":" << sourceLine.lineNumber() << ":";
 175     }
 176
 177     static void printFailedTestName( const CppUnit::TestFailure &failure )
 178     {
 179         std::cerr << failure.failedTestName() << std::endl;
 180     }
 181
 182     static void printFailureMessage( const CppUnit::TestFailure &failure )
 183     {
 184         std::cerr << failure.thrownException()->message().shortDescription() << std::endl;
 185         std::cerr << failure.thrownException()->message().details() << std::endl;
 186     }
 187 };
 188
 189 struct test_name_compare
 190 {
 191     explicit test_name_compare(std::string aName):
 192         maName(std::move(aName))
 193     {
 194     }
 195
 196     bool operator()(const std::string& rCmp)
 197     {
 198         size_t nPos = maName.find(rCmp);
 199         if (nPos == std::string::npos)
 200             return false;
 201
 202         size_t nEndPos = nPos + rCmp.size();
 203         return nEndPos == maName.size();
 204     }
 205
 206     std::string maName;
 207 };
 208
 209 bool addRecursiveTests(const std::vector<std::string>& test_names, CppUnit::Test* pTest, CppUnit::TestRunner& rRunner)
 210 {
 211     bool ret(false);
 212     for (int i = 0; i < pTest->getChildTestCount(); ++i)
 213     {
 214         CppUnit::Test* pNewTest = pTest->getChildTestAt(i);
 215         ret |= addRecursiveTests(test_names, pNewTest, rRunner);
 216         if (std::any_of(test_names.begin(), test_names.end(), test_name_compare(pNewTest->getName())))
 217         {
 218             rRunner.addTest(pNewTest);
 219             ret = true;
 220         }
 221     }
 222     return ret;
 223 }
 224
 225 //Allow the whole uniting testing framework to be run inside a "Protector"
 226 //which knows about uno exceptions, so it can print the content of the
 227 //exception before falling over and dying
 228 class CPPUNIT_API ProtectedFixtureFunctor
 229     : public CppUnit::Functor
 230 {
 231 private:
 232     const std::string &testlib;
 233     const std::string &args;
 234     std::vector<CppUnit::Protector *> &protectors;
 235     CppUnit::TestResult &result;
 236 public:
 237     ProtectedFixtureFunctor(const std::string& testlib_, const std::string &args_, std::vector<CppUnit::Protector*> &protectors_, CppUnit::TestResult &result_)
 238         : testlib(testlib_)
 239         , args(args_)
 240         , protectors(protectors_)
 241         , result(result_)
 242     {
 243     }
 244     ProtectedFixtureFunctor(const ProtectedFixtureFunctor&) = delete;
 245     ProtectedFixtureFunctor& operator=(const ProtectedFixtureFunctor&) = delete;
 246     bool run() const
 247     {
 248 #ifdef DISABLE_DYNLOADING
 249
 250         // NOTE: Running cppunit unit tests on iOS was something I did
 251         // only very early (several years ago) when starting porting
 252         // this stuff to iOS. The complicated mechanisms to do build
 253         // such unit test single executables have surely largely
 254         // bit-rotted or been semi-intentionally broken since. This
 255         // stuff here left for information only. --tml 2014.
 256
 257         // For iOS cppunit plugins aren't really "plugins" (shared
 258         // libraries), but just static archives. In the real main
 259         // program of a cppunit app, which calls the lo_main() that
 260         // the SAL_IMPLEMENT_MAIN() below expands to, we specifically
 261         // call the initialize methods of the CppUnitTestPlugIns that
 262         // we statically link to the app executable.
 263 #else
 264         // The PlugInManager instance is deliberately leaked, so that the dynamic libraries it loads
 265         // are never unloaded (which could make e.g. pointers from other libraries' static data
 266         // structures to const data in those libraries, like some static OUString cache pointing at
 267         // a const OUStringLiteral, become dangling by the time those static data structures are
 268         // destroyed during exit):
 269         auto manager = new CppUnit::PlugInManager;
 270         try {
 271             manager->load(testlib, args);
 272         } catch (const CppUnit::DynamicLibraryManagerException &e) {
 273             std::cerr << "DynamicLibraryManagerException: \"" << e.what() << "\"\n";
 274             const char *pPath = getenv ("PATH");
 275             const size_t nPathLen = pPath ? strlen(pPath) : 0;
 276 #ifdef _WIN32
 277             if (nPathLen > 256)
 278             {
 279                 std::cerr << "Windows has significant build problems with long PATH variables ";
 280                 std::cerr << "please check your PATH variable and re-autogen.\n";
 281             }
 282 #endif
 283             std::cerr << "Path (length: " << nPathLen << ") is '" << pPath << "'\n";
 284             return false;
 285         }
 286 #endif
 287
 288         for (size_t i = 0; i < protectors.size(); ++i)
 289             result.pushProtector(protectors[i]);
 290
 291         bool success;
 292         {
 293             CppUnit::TestResultCollector collector;
 294             result.addListener(&collector);
 295
 296             LogFailuresAsTheyHappen logger;
 297             result.addListener(&logger);
 298
 299             TimingListener timer;
 300             result.addListener(&timer);
 301
 302             EyecatcherListener eye;
 303             result.addListener(&eye);
 304
 305             // set this to track down files created before first test method
 306             std::string lib = testlib.substr(testlib.rfind('/')+1);
 307 #ifdef WIN32
 308             _putenv_s("LO_TESTNAME", lib.c_str());
 309 #else
 310             setenv("LO_TESTNAME", lib.c_str(), true);
 311 #endif
 312             const char* pVal = getenv("CPPUNIT_TEST_NAME");
 313
 314             CppUnit::TestRunner runner;
 315             if (pVal)
 316             {
 317                 std::vector<std::string> test_names;
 318                 boost::split(test_names, pVal, boost::is_any_of("\t "));
 319                 CppUnit::Test* pTest = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
 320                 bool const added(addRecursiveTests(test_names, pTest, runner));
 321                 if (!added)
 322                 {
 323                     std::cerr << "\nFatal error: CPPUNIT_TEST_NAME contains no valid tests\n";
 324                     // coverity[leaked_storage] - `manager` leaked on purpose
 325                     return false;
 326                 }
 327             }
 328             else
 329             {
 330                 runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
 331             }
 332             runner.run(result);
 333
 334             CppUnit::CompilerOutputter outputter(&collector, CppUnit::stdCErr());
 335             outputter.setNoWrap();
 336             outputter.write();
 337             success = collector.wasSuccessful();
 338         }
 339
 340         for (size_t i = 0; i < protectors.size(); ++i)
 341             result.popProtector();
 342
 343         return success;
 344     }
 345     virtual bool operator()() const override
 346     {
 347         return run();
 348     }
 349 };
 350
 351 #ifdef UNX
 352
 353 double get_time(timeval* time)
 354 {
 355     double nTime = static_cast<double>(time->tv_sec);
 356     nTime += static_cast<double>(time->tv_usec)/1000000.0;
 357     return nTime;
 358 }
 359
 360 OString generateTestName(std::u16string_view rPath)
 361 {
 362     size_t nPathSep = rPath.rfind('/');
 363     std::u16string_view aTestName = rPath.substr(nPathSep+1);
 364     return OUStringToOString(aTestName, RTL_TEXTENCODING_UTF8);
 365 }
 366
 367 void reportResourceUsage(std::u16string_view rPath)
 368 {
 369     OUString aFullPath = OUString::Concat(rPath) + ".resource.log";
 370     rusage resource_usage;
 371     getrusage(RUSAGE_SELF, &resource_usage);
 372
 373     OString aPath = OUStringToOString(aFullPath, RTL_TEXTENCODING_UTF8);
 374     std::ofstream resource_file(aPath.getStr());
 375     resource_file << "Name = " << generateTestName(rPath) << std::endl;
 376     double nUserSpace = get_time(&resource_usage.ru_utime);
 377     double nKernelSpace = get_time(&resource_usage.ru_stime);
 378     resource_file << "UserSpace = " << nUserSpace << std::endl;
 379     resource_file << "KernelSpace = " << nKernelSpace << std::endl;
 380 }
 381 #else
 382 void reportResourceUsage([[maybe_unused]] const OUString& /*rPath*/)
 383 {
 384 }
 385 #endif
 386
 387 }
 388
 389 static bool main2()
 390 {
 391     bool ok = false;
 392     OUString path;
 393
 394 #ifdef _WIN32
 395     //Disable Dr-Watson in order to crash simply without popup dialogs under
 396     //windows
 397     DWORD dwMode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
 398     SetErrorMode(SEM_NOGPFAULTERRORBOX|dwMode);
 399 #ifdef _DEBUG // These functions are present only in the debugging runtime
 400     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 401     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
 402     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 403     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
 404     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE);
 405     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 406 #endif
 407     // Create a desktop, to avoid popups interfering with active user session,
 408     // because on Windows, we don't use svp vcl plugin for unit testing
 409     if (getenv("CPPUNIT_DEFAULT_DESKTOP") == nullptr)
 410     {
 411         if (HDESK hDesktop
 412             = CreateDesktopW(L"LO_CPPUNIT_DESKTOP", nullptr, nullptr, 0, GENERIC_ALL, nullptr))
 413             SetThreadDesktop(hDesktop);
 414     }
 415 #endif
 416
 417     std::vector<CppUnit::Protector *> protectors;
 418     CppUnit::TestResult result;
 419     std::string args;
 420     std::string testlib;
 421     sal_uInt32 index = 0;
 422     while (index < osl_getCommandArgCount())
 423     {
 424         OUString arg = getArgument(index);
 425         if (arg.startsWith("-env:CPPUNITTESTTARGET=", &path))
 426         {
 427             ++index;
 428             continue;
 429         }
 430         if (arg.startsWith("-env:"))
 431         {
 432             ++index;
 433             continue; // ignore it here - will be read later
 434         }
 435         if ( arg != "--protector" )
 436         {
 437             if (testlib.empty())
 438             {
 439                 testlib = OUStringToOString(arg, osl_getThreadTextEncoding()).getStr();
 440                 args += testlib;
 441             }
 442             else
 443             {
 444                 args += ' ';
 445                 args += OUStringToOString(arg, osl_getThreadTextEncoding()).getStr();
 446             }
 447             ++index;
 448             continue;
 449         }
 450         if (osl_getCommandArgCount() - index < 3) {
 451             usageFailure();
 452         }
 453         OUString lib(getArgument(index + 1));
 454         OUString sym(getArgument(index + 2));
 455 #ifndef DISABLE_DYNLOADING
 456         osl::Module mod(lib, SAL_LOADMODULE_GLOBAL);
 457         oslGenericFunction fn = mod.getFunctionSymbol(sym);
 458         mod.release();
 459 #else
 460         oslGenericFunction fn = 0;
 461         if (sym == "unoexceptionprotector")
 462             fn = (oslGenericFunction) unoexceptionprotector;
 463         else if (sym == "unobootstrapprotector")
 464             fn = (oslGenericFunction) unobootstrapprotector;
 465         else if (sym == "vclbootstrapprotector")
 466             fn = (oslGenericFunction) vclbootstrapprotector;
 467         else
 468         {
 469             std::cerr
 470                 << "Only unoexceptionprotector or unobootstrapprotector protectors allowed"
 471                 << std::endl;
 472             std::exit(EXIT_FAILURE);
 473         }
 474 #endif
 475         if (fn == nullptr) {
 476             std::cerr
 477                 << "Failure instantiating protector \"" << convertLazy(lib)
 478                 << "\", \"" << convertLazy(sym) << '"' << std::endl;
 479             std::exit(EXIT_FAILURE);
 480         }
 481         CppUnit::Protector *protector =
 482             (*reinterpret_cast< cppunittester::ProtectorFactory * >(fn))();
 483         if (protector != nullptr) {
 484             protectors.push_back(protector);
 485         }
 486         index+=3;
 487     }
 488
 489     ProtectedFixtureFunctor tests(testlib, args, protectors, result);
 490     ok = tests.run();
 491
 492     reportResourceUsage(path);
 493
 494     return ok;
 495 }
 496
 497 #if defined(_WIN32) && defined(_DEBUG)
 498
 499 //Prints stack trace based on exception context record
 500 static void printStack( PCONTEXT ctx )
 501 {
 502     HANDLE process = GetCurrentProcess();
 503     HANDLE thread = GetCurrentThread();
 504
 505     STACKFRAME64        stack {};
 506     stack.AddrPC.Mode      = AddrModeFlat;
 507     stack.AddrStack.Mode   = AddrModeFlat;
 508     stack.AddrFrame.Mode   = AddrModeFlat;
 509 #ifdef _M_AMD64
 510     stack.AddrPC.Offset    = ctx->Rip;
 511     stack.AddrStack.Offset = ctx->Rsp;
 512     stack.AddrFrame.Offset = ctx->Rsp;
 513 #elif defined _M_ARM64
 514     stack.AddrPC.Offset    = ctx->Pc;
 515     stack.AddrStack.Offset = ctx->Sp;
 516     stack.AddrFrame.Offset = ctx->Fp;
 517 #else
 518     stack.AddrPC.Offset    = ctx->Eip;
 519     stack.AddrStack.Offset = ctx->Esp;
 520     stack.AddrFrame.Offset = ctx->Ebp;
 521 #endif
 522
 523     DWORD symOptions = SymGetOptions();
 524     symOptions |= SYMOPT_LOAD_LINES;
 525     symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;
 526     symOptions = SymSetOptions(symOptions);
 527
 528     SymInitialize( process, nullptr, TRUE ); //load symbols
 529
 530     IMAGEHLP_LINE64 line{};
 531     line.SizeOfStruct = sizeof(line);
 532
 533     char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
 534     PSYMBOL_INFO pSymbol = reinterpret_cast<PSYMBOL_INFO>(buffer);
 535
 536     for (;;)
 537     {
 538         //get next call from stack
 539         bool result = StackWalk64
 540         (
 541 #ifdef _M_AMD64
 542             IMAGE_FILE_MACHINE_AMD64,
 543 #elif defined _M_ARM64
 544             IMAGE_FILE_MACHINE_ARM64,
 545 #else
 546             IMAGE_FILE_MACHINE_I386,
 547 #endif
 548             process,
 549             thread,
 550             &stack,
 551             ctx,
 552             nullptr,
 553             SymFunctionTableAccess64,
 554             SymGetModuleBase64,
 555             nullptr
 556         );
 557
 558         if( !result )
 559             break;
 560
 561         //get symbol name for address
 562         pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
 563         pSymbol->MaxNameLen = MAX_SYM_NAME + 1;
 564         if (SymFromAddr(process, stack.AddrPC.Offset, nullptr, pSymbol))
 565             printf("\tat %s", pSymbol->Name);
 566         else
 567             printf("\tat unknown (Error in SymFromAddr=%#08lx)", GetLastError());
 568
 569         DWORD disp;
 570         //try to get line
 571         if (SymGetLineFromAddr64(process, stack.AddrPC.Offset, &disp, &line))
 572         {
 573             printf(" in %s: line: %lu:\n", line.FileName, line.LineNumber);
 574         }
 575         else
 576         {
 577             //failed to get line
 578             printf(", address 0x%0I64X", stack.AddrPC.Offset);
 579             HMODULE hModule = nullptr;
 580             GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
 581                 reinterpret_cast<LPCTSTR>(stack.AddrPC.Offset), &hModule);
 582
 583             char sModule[256];
 584             //at least print module name
 585             if (hModule != nullptr)
 586                 GetModuleFileNameA(hModule, sModule, std::size(sModule));
 587
 588             printf (" in %s\n", sModule);
 589         }
 590     }
 591 }
 592
 593 // The exception filter function:
 594 static LONG WINAPI ExpFilter(EXCEPTION_POINTERS* ex)
 595 {
 596     // we only want this active on the Jenkins tinderboxes
 597     printf("*** Exception 0x%lx occurred ***\n\n",ex->ExceptionRecord->ExceptionCode);
 598     printStack(ex->ContextRecord);
 599     return EXCEPTION_EXECUTE_HANDLER;
 600 }
 601
 602 static void AbortSignalHandler(int signal)
 603 {
 604     if (signal == SIGABRT) {
 605         std::unique_ptr<sal::BacktraceState> bs = sal::backtrace_get(50);
 606         SAL_WARN("sal.cppunittester", "CAUGHT SIGABRT:\n" << sal::backtrace_to_string(bs.get()));
 607     }
 608 }
 609
 610 SAL_IMPLEMENT_MAIN()
 611 {
 612     // catch the kind of signal that is thrown when an assert fails, and log a stacktrace
 613     signal(SIGABRT, AbortSignalHandler);
 614
 615     bool ok = false;
 616     // This magic kind of Windows-specific exception handling has to be in its own function
 617     // because it cannot be in a function that has objects with destructors.
 618     __try
 619     {
 620         ok = main2();
 621     }
 622     __except (ExpFilter(GetExceptionInformation()))
 623     {
 624     }
 625     return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 626 }
 627
 628 #else
 629
 630 SAL_IMPLEMENT_MAIN()
 631 {
 632     bool ok = false;
 633     try
 634     {
 635         ok = main2();
 636     }
 637     catch (const std::exception& e)
 638     {
 639         SAL_WARN("vcl.app", "Fatal exception: " << e.what());
 640     }
 641     return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 642 }
 643
 644 #endif
 645
 646 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */