configmgr/workben/memory/memorytests.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: memorytests.cxx,v $
  10  * $Revision: 1.7 $
  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_configmgr.hxx"
  33 #define _PRIVATE_TEST_
  34
  35 #include <iostream>
  36 #include <vector>
  37 #include "treeload.hxx"
  38
  39 #include <fstream>
  40
  41 #define ENABLE_MEMORYMEASURE
  42 #define ENABLE_LOGMECHANISM
  43
  44 // If you wish to enable this memory measure macros ... you need "windows.h"
  45 // But it's not agood idea to include it in your header!!! Because it's not compatible to VCL header .-(
  46 // So you must include it here ... in cxx, where you whish to use it.
  47 #ifdef ENABLE_MEMORYMEASURE
  48     #define VCL_NEED_BASETSD
  49     #include <tools/presys.h>
  50     #include <windows.h>
  51     #include <tools/postsys.h>
  52     #undef  VCL_NEED_BASETSD
  53 #endif
  54 #include "memorymeasure.hxx"
  55
  56 #include "logmechanism.hxx"
  57
  58 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  59 #include <com/sun/star/uno/Type.hxx>
  60 #include <com/sun/star/uno/TypeClass.hpp>
  61
  62 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  63 #include <com/sun/star/container/XNameAccess.hpp>
  64 #include <com/sun/star/container/XHierarchicalName.hpp>
  65 #include <com/sun/star/container/XNamed.hpp>
  66 #include <com/sun/star/container/XNameReplace.hpp>
  67 #include <com/sun/star/container/XChild.hpp>
  68 #include <com/sun/star/beans/XExactName.hpp>
  69 #include <com/sun/star/util/XChangesBatch.hpp>
  70 #include <com/sun/star/lang/XComponent.hpp>
  71
  72 #include <rtl/ustring.hxx>
  73 #include <rtl/string.hxx>
  74 #include <cppuhelper/servicefactory.hxx>
  75 #include <com/sun/star/uno/Sequence.h>
  76 #include <com/sun/star/uno/Any.h>
  77 #include <osl/profile.hxx>
  78 #include <osl/process.h>
  79 #include <osl/file.h>
  80
  81 #include <conio.h>
  82
  83 #include "createpropertyvalue.hxx"
  84
  85 #include "typeconverter.hxx"
  86
  87 #include "testmodules.hxx"
  88
  89 #include "valuenode.hxx"
  90
  91 namespace configmgr
  92 {
  93
  94 using namespace std;
  95
  96 namespace css = com::sun::star;
  97 namespace uno = css::uno;
  98 namespace lang = css::lang;
  99
 100 using namespace uno;
 101 using namespace lang;
 102
 103 using namespace ::com::sun::star::container;
 104 using namespace ::com::sun::star::beans;
 105 using namespace ::com::sun::star::util;
 106
 107 using ::rtl::OUString;
 108 using ::rtl::OString;
 109
 110 using namespace ::cppu;
 111
 112 #define ASCII(x) ::rtl::OUString::createFromAscii(x)
 113
 114 ostream& operator << (ostream& out, rtl::OUString const& aStr)
 115 {
 116     sal_Unicode const* const pStr = aStr.getStr();
 117     sal_Unicode const* const pEnd = pStr + aStr.getLength();
 118     for (sal_Unicode const* p = pStr; p < pEnd; ++p)
 119         if (0 < *p && *p < 127) // ASCII
 120             out << char(*p);
 121         else
 122             out << "[\\u" << hex << *p << "]";
 123     return out;
 124 }
 125
 126 void showSequence(const Sequence<OUString> &aSeq)
 127 {
 128     OUString aArray;
 129     const OUString *pStr = aSeq.getConstArray();
 130     for (int i=0;i<aSeq.getLength();i++)
 131     {
 132         OUString aStr = pStr[i];
 133         // aArray += aStr + ASCII(", ");
 134         cout << aStr << endl;
 135     }
 136     volatile int dummy = 0;
 137 }
 138
 139 //=============================================================================
 140
 141 inline void operator <<= (::rtl::OUString& _rUnicodeString, const sal_Char* _pAsciiString)
 142 {
 143     _rUnicodeString = ::rtl::OUString::createFromAscii(_pAsciiString);
 144 }
 145
 146 inline void operator <<= (::rtl::OUString& _rUnicodeString, const ::rtl::OString& _rAsciiString)
 147 {
 148     _rUnicodeString <<= _rAsciiString.getStr();
 149 }
 150
 151 inline void operator <<= (Any& _rUnoValue, const sal_Char* _pAsciiString)
 152 {
 153     _rUnoValue <<= ::rtl::OUString::createFromAscii(_pAsciiString);
 154 }
 155
 156 inline void operator <<= (Any& _rUnoValue, const ::rtl::OString& _rAsciiString)
 157 {
 158     _rUnoValue <<= _rAsciiString.getStr();
 159 }
 160
 161 inline void operator <<= (::rtl::OString& _rAsciiString, ::rtl::OUString const& _rUnicodeString )
 162 {
 163     _rAsciiString = rtl::OUStringToOString(_rUnicodeString, RTL_TEXTENCODING_ASCII_US).getStr();
 164 }
 165
 166 // -----------------------------------------------------------------------------
 167
 168 rtl::OString input(const char* pDefaultText, char cEcho)
 169 {
 170     // PRE: a Default Text would be shown, cEcho is a Value which will show if a key is pressed.
 171     const int MAX_INPUT_LEN = 500;
 172     char aBuffer[MAX_INPUT_LEN];
 173
 174     strcpy(aBuffer, pDefaultText);
 175     int nLen = strlen(aBuffer);
 176
 177 #ifdef WNT
 178     char ch = '\0';
 179
 180     cout << aBuffer;
 181     cout.flush();
 182
 183     while(ch != 13)
 184     {
 185         ch = getch();
 186         if (ch == 8)
 187         {
 188             if (nLen > 0)
 189             {
 190                 cout << "\b \b";
 191                 cout.flush();
 192                 --nLen;
 193                 aBuffer[nLen] = '\0';
 194             }
 195             else
 196             {
 197                 cout << "\a";
 198                 cout.flush();
 199             }
 200         }
 201         else if (ch != 13)
 202         {
 203             if (nLen < MAX_INPUT_LEN)
 204             {
 205                 if (cEcho == 0)
 206                 {
 207                     cout << ch;
 208                 }
 209                 else
 210                 {
 211                     cout << cEcho;
 212                 }
 213                 cout.flush();
 214                 aBuffer[nLen++] = ch;
 215                 aBuffer[nLen] = '\0';
 216             }
 217             else
 218             {
 219                 cout << "\a";
 220                 cout.flush();
 221             }
 222         }
 223     }
 224 #else
 225     if (!cin.getline(aBuffer,sizeof aBuffer))
 226         return OString();
 227 #endif
 228     return rtl::OString(aBuffer);
 229 }
 230
 231 // -----------------------------------------------------------------------------
 232 rtl::OUString enterValue(const char* _aStr, const char* _aDefault, bool _bIsAPassword)
 233 {
 234     cout << _aStr;
 235     cout.flush();
 236
 237     rtl::OUString sValue;
 238     sValue <<= input(_aDefault, _bIsAPassword ? '*' : 0);
 239     return sValue;
 240 }
 241 //=============================================================================
 242
 243 uno::Reference< lang::XMultiServiceFactory > getORB();
 244 // -----------------------------------------------------------------------------
 245
 246
 247 Reference< XChangesBatch > xChangesBatch = NULL;
 248 void commit()
 249 {
 250     if (xChangesBatch.is())
 251     {
 252         xChangesBatch->commitChanges();
 253     }
 254 }
 255
 256 // -----------------------------------------------------------------------------
 257 static sal_Bool                         s_bInitialized  =       sal_False;
 258 #ifdef LLA_PRIVAT_DEBUG
 259 // static const sal_Char*               s_pSourcePath   =       "//./l|/src632/configmgr/workben/local_io/share";
 260 // static const sal_Char*               s_pUpdatePath   =       "//./l|/src632/configmgr/workben/local_io/user";
 261 static const sal_Char*          s_pSourcePath   =       "file:///f:/office60_633/share/config/registry";
 262 static const sal_Char*          s_pUpdatePath   =       "file:///f:/office60_633/user/config/registry";
 263 static const sal_Char*          s_pRootNode             =       "org.openoffice.test";
 264 static const sal_Char*          s_pServerType   =       "local";
 265 static const sal_Char*          s_pLocale               =       "de-DE";
 266 static const sal_Char*          s_pServer               =       "";
 267 static const sal_Char*          s_pUser                 =       "";
 268 static const sal_Char*          s_pPassword             =       "";
 269 #else
 270 static const sal_Char*          s_pSourcePath   =       "file:///g:/src/configmgr/workben/local_io/share";
 271 static const sal_Char*          s_pUpdatePath   =       "file:///g:/src/configmgr/workben/local_io/user";
 272 static const sal_Char*          s_pRootNode             =       "org.openoffice.test";
 273 static const sal_Char*          s_pServerType   =       "local";
 274 static const sal_Char*          s_pLocale               =       "de-DE";
 275 static const sal_Char*          s_pServer               =       "lautrec-3108:19205";
 276 static const sal_Char*          s_pUser                 =       "lars";
 277 static const sal_Char*          s_pPassword             =       "";
 278 #endif
 279
 280 static bool m_bChange = false;
 281 // -----------------------------------------------------------------------------
 282 static void loadDefaults()
 283 {
 284     if (s_bInitialized)
 285         return;
 286
 287     s_bInitialized = sal_True;
 288
 289     try
 290     {
 291         // the executable file name
 292         ::rtl::OUString sExecutable;
 293         osl_getExecutableFile(&sExecutable.pData);
 294         // cut the name, add a cfgapi.ini to the path
 295         sal_Int32 nLastSep = sExecutable.lastIndexOf('/');
 296         if (-1 != nLastSep)
 297             sExecutable = sExecutable.copy(0, nLastSep + 1);
 298 #ifdef UNX
 299         sExecutable += ::rtl::OUString::createFromAscii("cfgapirc");
 300 #else
 301         sExecutable += ::rtl::OUString::createFromAscii("cfgapi.ini");
 302 #endif
 303         ::rtl::OUString sNormalized;
 304         sNormalized = sExecutable;
 305         if (1) // osl_File_E_None == osl_normalizePath(sExecutable.pData, &sNormalized.pData))
 306         {
 307             ::osl::Profile aProfile(sNormalized);
 308
 309             static ::rtl::OString       sSection("defaults");
 310             static ::rtl::OString       sSourcePath("sourcepath");
 311             static ::rtl::OString       sUpdatePath("updatepath");
 312             static ::rtl::OString       sRootNode("rootnode");
 313             static ::rtl::OString       sServerType("servertype");
 314             static ::rtl::OString       sLocale("Locale");
 315             static ::rtl::OString       sServer("Server");
 316             static ::rtl::OString       sUser("User");
 317             static ::rtl::OString       sPassword("Password");
 318
 319             // read some strings.
 320             // Do this static because we want to redirect the global static character pointers to the buffers.
 321             static ::rtl::OString s_sSourcePath = aProfile.readString(sSection, sSourcePath, s_pSourcePath);
 322             static ::rtl::OString s_sUpdatePath = aProfile.readString(sSection, sUpdatePath, s_pUpdatePath);
 323             static ::rtl::OString s_sRootNode   = aProfile.readString(sSection, sRootNode, s_pRootNode);
 324             static ::rtl::OString s_sServerType = aProfile.readString(sSection, sServerType, s_pServerType);
 325             static ::rtl::OString s_sLocale             = aProfile.readString(sSection, sLocale, s_pLocale);
 326             static ::rtl::OString s_sServer             = aProfile.readString(sSection, sServer, s_pServer);
 327             static ::rtl::OString s_sUser               = aProfile.readString(sSection, sUser, s_pUser);
 328             static ::rtl::OString s_sPassword   = aProfile.readString(sSection, sPassword, s_pPassword);
 329
 330             // do this redirection
 331             s_pSourcePath       =       s_sSourcePath.getStr();
 332             s_pUpdatePath       =       s_sUpdatePath.getStr();
 333             s_pRootNode         =       s_sRootNode.getStr();
 334             s_pServerType       =       s_sServerType.getStr();
 335             s_pLocale           =       s_sLocale.getStr();
 336             s_pServer           =       s_sServer.getStr();
 337             s_pUser                     =       s_sUser.getStr();
 338             s_pPassword         =       s_sPassword.getStr();
 339         }
 340     }
 341     catch(std::exception& e)
 342     {
 343         e.what();       // silence warnings
 344     }
 345 }
 346
 347 // -----------------------------------------------------------------------------
 348 Sequence<Any> createSequence(const OUString &sUser, const OUString &sPasswd)
 349 {
 350     Sequence< Any > aCPArgs;
 351
 352     if (sUser.getLength() > 0)
 353     {
 354         aCPArgs.realloc(1);
 355         aCPArgs[0] <<= configmgr::createPropertyValue(ASCII("user"), sUser);
 356     }
 357     if (sPasswd.getLength() > 0)
 358     {
 359         aCPArgs.realloc(2);
 360         aCPArgs[1] <<= configmgr::createPropertyValue(ASCII("password"), sPasswd);
 361     }
 362     return aCPArgs;
 363 }
 364
 365 //=============================================================================
 366 #include <string.h>
 367 #if (defined UNX) || (defined OS2)
 368 #else
 369 #include <conio.h>
 370 #endif
 371
 372 // -----------------------------------------------------------------------------
 373
 374 void test_configuration_provider(uno::Reference<lang::XMultiServiceFactory> _xCfgProvider,
 375                                  rtl::OUString const& _sUser, bool _bLocal, sal_Int32 _nCount);
 376
 377
 378 // -----------------------------------------------------------------------------
 379
 380 uno::Reference<lang::XMultiServiceFactory>
 381 getProvider(
 382     uno::Reference< lang::XMultiServiceFactory > _xServiceRegistry,
 383     rtl::OUString const& _sServerType,
 384     rtl::OUString const& _sSharePath, rtl::OUString const& _sUserPath,
 385     bool &_bLocal)
 386 {
 387     try
 388     {
 389         Sequence< Any > aCPArgs;
 390
 391         OUString sServerType = _sServerType; // enterValue("servertype: ", s_pServerType, false);
 392
 393         rtl::OUString sUser;
 394
 395         _bLocal = sServerType.equalsIgnoreAsciiCase(ASCII("local")) || sServerType.equalsIgnoreAsciiCase(ASCII("setup"));
 396         if (!_bLocal)
 397         {
 398             rtl::OUString sServer;
 399             sServer =                   enterValue("server  : ", s_pServer,false);
 400             cout << endl;
 401
 402             sUser =                             enterValue("user    : ", s_pUser, false);
 403             cout << endl;
 404
 405             OUString sPasswd =  enterValue("password: ", s_pPassword, true);
 406             cout << endl;
 407
 408             aCPArgs = createSequence(sUser, sPasswd);
 409
 410             aCPArgs.realloc(aCPArgs.getLength() + 1);
 411             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("server"), sServer);
 412
 413             OUString sTimeout = ASCII("10000");
 414             aCPArgs.realloc(aCPArgs.getLength() + 1);
 415             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("timeout"), sTimeout);
 416
 417         }
 418         else
 419         {
 420             rtl::OUString sSharePath, sUserPath;
 421             sSharePath = _sSharePath;//         enterValue("share path: ", s_pSourcePath, false);
 422             // cout << endl;
 423             sUserPath = _sUserPath; //          enterValue("user path : ", s_pUpdatePath, false);
 424             // cout << endl;
 425
 426             aCPArgs.realloc(aCPArgs.getLength() + 1);
 427             sal_Int32 nCount = aCPArgs.getLength() - 1;
 428             Any *pAny = &aCPArgs[nCount];
 429             *pAny <<= configmgr::createPropertyValue(ASCII("sourcepath"), sSharePath);
 430             aCPArgs.realloc(aCPArgs.getLength() + 1);
 431             aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("updatepath"), sUserPath);
 432         }
 433
 434         aCPArgs.realloc(aCPArgs.getLength() + 1);
 435         aCPArgs[aCPArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("servertype"), sServerType);
 436
 437         Reference< XMultiServiceFactory > xCfgProvider(
 438             _xServiceRegistry->createInstanceWithArguments(
 439                 ::rtl::OUString::createFromAscii("com.sun.star.configuration.ConfigurationProvider"),
 440                 aCPArgs),
 441             UNO_QUERY);
 442         if (!xCfgProvider.is())
 443         {
 444             ::flush(cout);
 445             cerr << "Could not create the configuration provider !\n\n";
 446             return 0;
 447         }
 448 // -----------------------------------------------------------------------------
 449         return xCfgProvider;
 450     }
 451     catch (Exception& e)
 452     {
 453         ::flush(cout);
 454         cerr << "Caught exception: " << e.Message << endl;
 455     }
 456     return 0;
 457 }
 458
 459 // -----------------------------------------------------------------------------
 460 sal_Int32 m_nCount = 0;
 461
 462 void test(uno::Reference<lang::XMultiServiceFactory> _xORB, rtl::OUString const& _sSharePath,
 463           rtl::OUString const& _sUserPath)
 464 {
 465
 466     rtl::OUString sUser;
 467     bool bLocal;
 468     cout << ++m_nCount << ". start test with  new provider\n";
 469  {
 470      START_MEMORYMEASURE_FOR( aMemoryInfo, "*** API Test Execution ***" );
 471
 472      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "initialisierungs-check" );
 473
 474      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- Erzeuge Provider" );
 475
 476      uno::Reference<lang::XMultiServiceFactory>xCfgProvider =
 477          getProvider(_xORB, ASCII("local"), _sSharePath, _sUserPath,
 478                      bLocal);
 479
 480      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- Habe Provider, starte Test" );
 481
 482      test_configuration_provider(xCfgProvider, sUser, bLocal, 0); // xml
 483
 484      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- Test gelaufen, starte erneut" );
 485
 486      test_configuration_provider(xCfgProvider, sUser, bLocal, 0); // xml
 487
 488      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- Test gelaufen, entsorge Provider" );
 489
 490      uno::Reference<lang::XComponent>xComponent(xCfgProvider,UNO_QUERY);
 491      xComponent->dispose();
 492
 493      MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- Provider disposed" );
 494
 495      LOG_MEMORYMEASURE( "---------------- API Memory Test 2-----------------------------", "- Test memory traces.", aMemoryInfo );
 496  }
 497
 498  cout << "finish provider test\n";
 499
 500  // Test Version 1 and 3, it MUST be equal
 501 }
 502
 503 // -----------------------------------------------------------------------------
 504 // -----------------------------------------------------------------------------
 505 // -----------------------------------------------------------------------------
 506 static rtl::OUString makeFileURL(OUString const& sMaybeURL)
 507 {
 508     rtl::OUString const fileURLStart(RTL_CONSTASCII_USTRINGPARAM("file:/"));
 509
 510     if ( 0 != fileURLStart.compareTo(sMaybeURL, fileURLStart.getLength()) )
 511     {
 512         OUString sURL;
 513         if (!osl_getFileURLFromSystemPath(sMaybeURL.pData, &sURL.pData))
 514             return sURL;
 515     }
 516
 517     return sMaybeURL;
 518 }
 519 // -----------------------------------------------------------------------------
 520 static rtl::OUString makeSystemPath(OUString const& sMaybeURL)
 521 {
 522     rtl::OUString const fileURLStart(RTL_CONSTASCII_USTRINGPARAM("file:/"));
 523
 524     if ( 0 == fileURLStart.compareTo(sMaybeURL, fileURLStart.getLength()) )
 525     {
 526         OUString sSysPath;
 527         if (!osl_getSystemPathFromFileURL(sMaybeURL.pData, &sSysPath.pData))
 528             return sSysPath;
 529     }
 530
 531     return sMaybeURL;
 532 }
 533 // -----------------------------------------------------------------------------
 534 // ---------------------------------- M A I N ----------------------------------
 535 // -----------------------------------------------------------------------------
 536
 537 int main( int argc, char * argv[] )
 538 {
 539     TimeValue aTimeout;
 540     aTimeout.Seconds = 5;
 541     aTimeout.Nanosec = 0;
 542
 543     sal_Int32 nSizeISubtree = sizeof(ISubtree);
 544     sal_Int32 nSizeINode = sizeof(INode);
 545     sal_Int32 nSizeIValueNode = sizeof(ValueNode);
 546     {
 547         loadDefaults();
 548
 549         Reference< XMultiServiceFactory > xORB = getORB();
 550
 551         rtl::OUString sSharePath =  makeSystemPath(enterValue("share path: ", s_pSourcePath, false));
 552         cout << endl;
 553         rtl::OUString sUserPath =        makeSystemPath(enterValue("user path : ", s_pUpdatePath, false));
 554         cout << endl;
 555
 556         // test(xORB, sSharePath, sUserPath, ASCII("org.openoffice.test"));
 557
 558         // char* pMem = new char[1000 * 1000 * 10];
 559         // showMemoryStatistic();
 560
 561 //              test(xORB, sSharePath, sUserPath, ASCII("org.openoffice.Office.Views"));
 562
 563         START_MEMORYMEASURE_FOR( aMemoryInfo, "*** API Test Main ***" );
 564
 565         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "initialisierungs-check" );
 566
 567         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "starte test !" );
 568
 569         test(xORB, sSharePath, sUserPath);
 570
 571         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "tests beendet !" );
 572
 573         // stop the programm clear.
 574         Reference< XComponent > xComponent(xORB, UNO_QUERY);
 575         xComponent->dispose();
 576         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "ORB disposed." );
 577
 578         LOG_MEMORYMEASURE( "---------------- API Memory Test-------------------------------", "Outer memory traces.", aMemoryInfo );
 579     }
 580     return 0;
 581 }
 582
 583 ///////////////////////////////////////////////////////////////////////////////////////////
 584 void test(Reference< XHierarchicalName >& xAccessName)
 585 {
 586         if (xAccessName.is())
 587         {
 588             // cout << "Accessing Node: " << xAccessName->getHierarchicalName();
 589         }
 590         else
 591         {
 592             // cout << "BUG: XHierarchicalName not available";
 593         }
 594         // cout << endl;
 595 }
 596 void test(Reference< XNamed >& xAccess)
 597 {
 598         if (xAccess.is())
 599         {
 600             // cout << "Node is named: " << xAccess->getName();
 601         }
 602         else
 603         {
 604             // cout << "BUG: XNamed not available";
 605         }
 606         // cout << endl;
 607 }
 608
 609 ///////////////////////////////////////////////////////////////////////////////////////////
 610 void fillAllNames(Reference<XNameAccess  >& xAccess, Sequence<OUString>& _aSeq)
 611 {
 612         if (xAccess.is())
 613         {
 614             _aSeq = Sequence <OUString>(xAccess->getElementNames());
 615
 616             // cout << "Element Names: (" << _aSeq.getLength() << ")";
 617             // for (int i = 0; i < _aSeq.getLength(); ++i)
 618             //  cout << "\n[" << i << "] -\t" << _aSeq[i];
 619             //cout << endl;
 620         }
 621         else
 622         {
 623             // cout << "BUG: XNameAccess not available";
 624         }
 625         // cout << endl;
 626 }
 627 void write(Reference< XChild >& xChild)
 628 {
 629         if (xChild.is())
 630         {
 631             // cout << "\n[ P ] -\tParent";
 632         }
 633         else
 634         {
 635             // cout << "BUG: Parent not available (no XChild)";
 636         }
 637         // cout << endl;
 638 }
 639 ///////////////////////////////////////////////////////////////////////////////////////////
 640
 641 // -----------------------------------------------------------------------------
 642 Reference< XInterface > readaccess(uno::Reference< lang::XMultiServiceFactory > &xMSF,
 643                                    uno::Reference< uno::XInterface > const& xIface,
 644                                    rtl::OString const& buf,
 645                                    ostream& outStream)
 646 {
 647     Reference< XInterface > xNext;
 648     try
 649     {
 650         Reference< XNameAccess > xAccess(xIface, UNO_QUERY);
 651         Reference< XHierarchicalNameAccess > xDeepAccess(xIface, UNO_QUERY);
 652         Reference< XExactName > xExactName(xIface, UNO_QUERY);
 653
 654         if (xAccess.is() || xDeepAccess.is())
 655         {
 656             OUString aName;
 657             OUString aInput = OUString::createFromAscii(buf);
 658
 659             if (xExactName.is())
 660             {
 661                 ::rtl::OUString sTemp = xExactName->getExactName(aInput);
 662                 if (sTemp.getLength())
 663                     aInput = sTemp;
 664             }
 665
 666             if (xAccess.is() && xAccess->hasByName(aInput))
 667             {
 668                 aName = aInput;
 669             }
 670             else if (xDeepAccess.is() && xDeepAccess->hasByHierarchicalName(aInput))
 671             {
 672                 aName = aInput;
 673             }
 674             else if ('0' <= buf[0] && buf[0] <= '9' && xAccess.is())
 675             {
 676                 int n = atoi(buf);
 677                 Sequence<OUString> aNames = xAccess->getElementNames();
 678                 if (0 <= n && n < aNames.getLength())
 679                     aName = aNames[n];
 680             }
 681
 682             if (aName.getLength())
 683             {
 684                 bool bNest = aInput.indexOf(sal_Unicode('/')) >= 0;
 685
 686                 Any aElement = bNest ?
 687                     ( xDeepAccess.is() ?
 688                       xDeepAccess->getByHierarchicalName(aName) : Any()
 689                       ) :
 690                     ( xAccess.is() ?
 691                       xAccess->getByName(aName) : Any()
 692                       );
 693
 694                 while (aElement.getValueTypeClass() == TypeClass_ANY)
 695                 {
 696                     Any aWrap(aElement);
 697                     aWrap >>= aElement;
 698                 }
 699                 sal_Bool bValue = true;
 700                 sal_Bool bValueOk = false;
 701
 702                 switch (aElement.getValueTypeClass() )
 703                 {
 704                 case TypeClass_INTERFACE:
 705                     bValue = false;
 706                     if (aElement >>= xNext)
 707                     {
 708                         outStream << "Group: " << aName << endl;
 709                     }
 710                     else
 711                     {
 712                         outStream << "ERROR: can't get the interface" << endl;
 713                     }
 714                     break;
 715                 case TypeClass_BOOLEAN:
 716                 {
 717                     sal_Bool* pVal = (sal_Bool*)aElement.getValue();
 718                     bValueOk = (pVal != 0);
 719
 720                     outStream << "VALUE '" << aName << "' is a BOOLEAN = ";
 721                     if (!bValueOk)
 722                         outStream << "NULL (error!!)";
 723                     else if (*pVal)
 724                         outStream << "'TRUE'";
 725                     else
 726                         outStream << "'FALSE'";
 727
 728                     outStream << endl;
 729
 730                     // tryToChange(xAccess, aName, pVal);
 731                     break;
 732                 }
 733                 case TypeClass_SHORT:
 734                 {
 735                     sal_Int16 aValue;
 736                     outStream << "VALUE '" << aName << "' is a SHORT (16 bit) = ";
 737                     if (bValueOk = (aElement >>= aValue))
 738                     {
 739                         outStream << aValue;
 740                         // tryToChange(xAccess, aName, aValue);
 741                     }
 742                     else
 743                     {
 744                         outStream << "ERROR RETRIEVING VALUE";
 745                     }
 746                     outStream << endl;
 747
 748                     break;
 749                 }
 750                 case TypeClass_LONG:
 751                 {
 752
 753                     sal_Int32 aValue;
 754                     outStream << "VALUE '" << aName << "' is a INT (32 bit) = ";
 755                     if (bValueOk = (aElement >>= aValue))
 756                     {
 757                         outStream << aValue;
 758                         // tryToChange(xAccess, aName, aValue);
 759                     }
 760                     else
 761                     {
 762                         outStream << "ERROR RETRIEVING VALUE";
 763                     }
 764                     outStream << endl;
 765                     break;
 766                 }
 767                 case TypeClass_HYPER:
 768                 {
 769                     sal_Int64 aValue;
 770                     outStream << "VALUE '" << aName << "' is a LONG (64 bit) = ";
 771                     if (bValueOk = (aElement >>= aValue))
 772                     {
 773                         outStream << double(aValue);
 774                         // tryToChange(xAccess, aName, aValue);
 775                     }
 776                     else
 777                     {
 778                         outStream << "ERROR RETRIEVING VALUE";
 779                     }
 780                     outStream << endl;
 781                     break;
 782                 }
 783                 case TypeClass_DOUBLE:
 784                 {
 785                     double aValue;
 786                     outStream << "VALUE '" << aName << "' is a DOUBLE = ";
 787                     if (bValueOk = (aElement >>= aValue))
 788                     {
 789                         outStream << aValue;
 790                     }
 791                     else
 792                     {
 793                         outStream << "ERROR RETRIEVING VALUE";
 794                     }
 795                     outStream << endl;
 796                     break;
 797                 }
 798                 case TypeClass_STRING:
 799                 {
 800                     OUString aValue;
 801                     outStream << "VALUE '" << aName << "' is a STRING = ";
 802                     if (bValueOk = (aElement >>= aValue))
 803                     {
 804                         outStream << "\"" << aValue << "\"";
 805                         // tryToChange(xAccess, aName, aValue);
 806                     }
 807                     else
 808                     {
 809                         outStream << "ERROR RETRIEVING VALUE";
 810                     }
 811                     outStream << endl;
 812                     break;
 813                 }
 814                 case TypeClass_SEQUENCE:
 815                 {
 816                     outStream << "VALUE '" << aName << "' is a SEQUENCE or BINARY" << endl;
 817
 818                     Type aTypeS = configmgr::getSequenceElementType(aElement.getValueType());
 819                     OUString sType = configmgr::toTypeName(aTypeS.getTypeClass());
 820                     outStream << "UNO type is " << aElement.getValueType().getTypeName()  << endl;
 821                     outStream << "Real type is Sequence<" << sType << ">" << endl;
 822                     // outSequence(aElement, aTypeS, outStream);
 823                     bValueOk = true;
 824                     break;
 825                 }
 826                 case TypeClass_VOID:
 827                     outStream << "ELEMENT '" << aName << "' is NULL and VOID " << endl;
 828                     bValueOk = true;
 829                     break;
 830                 default:
 831                     outStream << "Error: ELEMENT '" << aName << "' is of unknown or unrecognized type" << endl;
 832                     break;
 833                 }
 834
 835             }
 836             else
 837             {
 838                 outStream << "Error: No element \"" << aInput << "\" found." <<endl;
 839             }
 840         }
 841     }
 842     catch (Exception& e)
 843     {
 844         outStream << "An Exception occurred: " << e.Message << endl;
 845     }
 846     catch (...)
 847     {
 848         outStream << "An UNKNOWN Exception occurred !" << endl;
 849     }
 850
 851     return xNext;
 852 }
 853
 854
 855
 856
 857 // -----------------------------------------------------------------------------
 858 void test_read_access( uno::Reference< lang::XMultiServiceFactory > &xMSF,
 859                        uno::Reference< uno::XInterface >& xIface,
 860                        ofstream & out)
 861 {
 862     Sequence<OUString> aAllNames;
 863
 864     using com::sun::star::uno::UNO_QUERY;
 865
 866     // cout << "\n\n---------------------------------------------------------------" << endl;
 867     Reference< XNameAccess > xAccess(xIface, UNO_QUERY);
 868     Reference< XChild > xChild(xIface, UNO_QUERY);
 869     Reference< XHierarchicalName > xAccessPath(xIface,UNO_QUERY);
 870     Reference< XNamed > xAccessName(xIface,UNO_QUERY);
 871 //              Reference< XHierarchicalNameAccess >& xAccess(xIface, UNO_QUERY);
 872
 873     test(xAccessPath);
 874     test(xAccessName);
 875     fillAllNames(xAccess, aAllNames);
 876     write(xChild);
 877
 878     for (sal_Int32 i=0;i<aAllNames.getLength();i++)
 879     {
 880         OString aValue;
 881         aValue <<= aAllNames[i];
 882         uno::Reference<uno::XInterface> xFace = readaccess(xMSF, xIface, aValue, out);
 883         if (xFace.is())
 884         {
 885             test_read_access(xMSF, xFace, out);
 886         }
 887     }
 888 }
 889
 890 // -----------------------------------------------------------------------------
 891 void test_read_access( uno::Reference< lang::XMultiServiceFactory > &xMSF,
 892                        uno::Reference< uno::XInterface >& xIface,
 893                        rtl::OString aFilename)
 894 {
 895     ofstream out(aFilename.getStr());
 896     test_read_access(xMSF, xIface, out);
 897 }
 898
 899 // -----------------------------------------------------------------------------
 900 void test_configuration_provider(uno::Reference<lang::XMultiServiceFactory> _xCfgProvider,
 901                                  rtl::OUString const& _sUser, bool _bLocal,
 902                                  sal_Int32 _nCount)
 903 {
 904     START_MEMORYMEASURE_FOR( aMemoryInfo, "*** Configuration Provider Loop Test ***" );
 905     START_MEMORYMEASURE_FOR( aInnerMemoryInfo, "*** Configuration Provider Module Details ***" );
 906
 907     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "initialisierungs-check" );
 908     MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "initialisierungs-check" );
 909
 910     std::vector< Reference< XInterface > > aLoadedModules;
 911     aLoadedModules.reserve(configtest::s_nTestModules);
 912
 913     Sequence< Any > aArgs;
 914     aArgs = createSequence(_sUser, ASCII(""));
 915
 916     if (!_bLocal)
 917     {
 918         OUString sLocale =      enterValue("locale  : ", s_pLocale, false);
 919         cout << endl;
 920         aArgs.realloc(aArgs.getLength() + 1);
 921         aArgs[aArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("locale"), sLocale);
 922     }
 923
 924 #if 0
 925     sal_Bool bLazyWrite = true;
 926     aArgs.realloc(aArgs.getLength() + 1);
 927     aArgs[aArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("lazywrite"), bLazyWrite);
 928 #else
 929     sal_Bool bNoCache = true;
 930     aArgs.realloc(aArgs.getLength() + 1);
 931     aArgs[aArgs.getLength() - 1] <<= configmgr::createPropertyValue(ASCII("nocache"), bNoCache);
 932 #endif
 933
 934     sal_Int32 nPathIdx = aArgs.getLength();
 935     aArgs.realloc(nPathIdx + 1);
 936
 937     const OString sInnerInfoText("- - - Loading module: ");
 938     MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "- - - Before Loading Modules" );
 939     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- - Prepared Arguments - Lade Module" );
 940
 941     for (char const * const * ppTestModule = configtest::s_aTestModules; *ppTestModule; ++ppTestModule)
 942     {
 943         OUString sPath = OUString::createFromAscii(*ppTestModule);
 944         cout << "\t" << ++_nCount << ". test with node: " << sPath << endl;
 945
 946         aArgs[nPathIdx] <<= configmgr::createPropertyValue(ASCII("nodepath"), sPath);
 947
 948         MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, sInnerInfoText.concat(*ppTestModule) );
 949         Reference< XInterface > xIFace = _xCfgProvider->createInstanceWithArguments(
 950             /* OUString::createFromAscii("com.sun.star.configuration.ConfigurationUpdateAccess"), */
 951             OUString::createFromAscii("com.sun.star.configuration.ConfigurationAccess"),
 952             aArgs);
 953         // cout << "---------------------------------------------------------------\n Configuration Read/Write Access created !\n---------------------------------------------------------------" << endl;
 954
 955         aLoadedModules.push_back(xIFace);
 956     /*
 957         xChangesBatch = Reference< XChangesBatch >(xIFace, UNO_QUERY);
 958
 959         Sequence<OUString> aSeq = _xCfgProvider->getAvailableServiceNames();
 960
 961         OString sPath;
 962         sPath <<= _sPath;
 963
 964         OString aFilename = "c:\\temp\\fileout_";
 965         aFilename += sPath;
 966         aFilename += OString::valueOf(_nCount);
 967         aFilename += ".txt";
 968         test_read_access(_xCfgProvider, xIFace, aFilename);
 969     */
 970     }
 971     MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "- - - Done Loading modules" );
 972
 973     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- - Alle Module geladen" );
 974
 975     aLoadedModules.clear();
 976
 977     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "- - Module released" );
 978
 979     LOG_MEMORYMEASURE( "---------------- API Memory Test 3 -----------------------------", "- - Provider memory traces.", aMemoryInfo );
 980     LOG_MEMORYMEASURE( "---------------- API Memory Test 4 -----------------------------", "- - - Module memory traces.", aInnerMemoryInfo );
 981
 982 }
 983
 984
 985 // -----------------------------------------------------------------------------
 986 // ----------------------------------- Main 2 -----------------------------------
 987 // -----------------------------------------------------------------------------
 988
 989 int requestTest( int argc, char * argv[] )
 990 {
 991     TimeValue aTimeout;
 992     aTimeout.Seconds = 5;
 993     aTimeout.Nanosec = 0;
 994
 995     sal_Int32 nSizeISubtree = sizeof(ISubtree);
 996     sal_Int32 nSizeINode = sizeof(INode);
 997     sal_Int32 nSizeIValueNode = sizeof(ValueNode);
 998     {
 999         loadDefaults();
1000
1001         Reference< XMultiServiceFactory > xORB = getORB();
1002
1003         rtl::OUString sSharePath = makeFileURL(enterValue("share path: ", s_pSourcePath, false));
1004         cout << endl;
1005         rtl::OUString sUserPath =       makeFileURL(enterValue("user path : ", s_pUpdatePath, false));
1006         cout << endl;
1007
1008         START_MEMORYMEASURE_FOR( aMemoryInfo, "*** Request Tree Test ***" );
1009
1010         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "initialisierungs-check" );
1011
1012         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "create tree manager" );
1013
1014         OTreeLoad aTreeLoad(xORB, sSharePath, sUserPath);
1015         sal_Int32 nIdx = 0;
1016
1017         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "created tree manager" );
1018
1019         OString const sInnerInfoText("- Loading module: ");
1020
1021         START_MEMORYMEASURE_FOR( aInnerMemoryInfo, "*** Request Tree Test Details ***" );
1022         MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "initialisierungs-check" );
1023
1024         MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "- before loading modules" );
1025         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "request subtrees" );
1026
1027         for (char const * const * ppRequestModule = configtest::s_aTestModules; *ppRequestModule; ++ppRequestModule)
1028         {
1029             MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, sInnerInfoText.concat(*ppRequestModule) );
1030             aTreeLoad.requestSubtree( OUString::createFromAscii(*ppRequestModule));
1031         }
1032
1033         MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "- loaded all modules" );
1034         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "release subtrees" );
1035
1036         for (char const * const * ppReleaseModule = configtest::s_aTestModules; *ppReleaseModule; ++ppReleaseModule)
1037             aTreeLoad.releaseSubtree( OUString::createFromAscii(*ppReleaseModule));
1038
1039         MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "ich habe fertig." );
1040         LOG_MEMORYMEASURE( "---------------- Request Memory Test ---------------------------", "Direct Cache Access memory traces.", aMemoryInfo );
1041         LOG_MEMORYMEASURE( "---------------- Request Memory Detail -------------------------", "Module request memory traces.", aInnerMemoryInfo );
1042     }
1043     return 0;
1044 }
1045
1046 // -----------------------------------------------------------------------------
1047 // --------------------------------- Trust Test ---------------------------------
1048 // -----------------------------------------------------------------------------
1049
1050 int trust( int argc, char * argv[] )
1051 {
1052     Reference< XMultiServiceFactory > xORB = getORB();
1053
1054     std::vector<char*> aMemHolder;
1055     aMemHolder.reserve(1024);
1056
1057     START_MEMORYMEASURE_FOR( aMemoryInfo, "Allocator check" );
1058
1059     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "initialisierungs-check" );
1060
1061     sal_Int32 const total_alloc = 8 * 1024 * 1024;
1062
1063     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "get 8 MB" );
1064
1065     char* pChar = new char[total_alloc];
1066
1067     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "free 8 MB" );
1068
1069     delete [] pChar;
1070
1071     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "deleted 8 MB" );
1072
1073     sal_Int32 const chunk = 8 * 1024;
1074     sal_Int32 const alloc_count = total_alloc/chunk;
1075
1076     sal_Int32 const msg_count = 16;
1077     sal_Int32 const loop_count = alloc_count/msg_count;
1078     sal_Int32 const loop_allocation = loop_count * chunk;
1079
1080     OString const sPieces = OString::valueOf(alloc_count).concat(" pieces");
1081     OString const sInnerMessage = OString("Allocating ").concat(OString::valueOf(loop_count))
1082                                   .concat(" chunks [").concat(OString::valueOf(loop_allocation)).concat(" Bytes].");
1083
1084     START_MEMORYMEASURE( aInnerMemoryInfo );
1085     MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "initialisierungs-check" );
1086
1087     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, OString("get 8 MB as ").concat(sPieces) );
1088
1089     for (sal_Int32 i=0;i<alloc_count/loop_count;i++)
1090     {
1091         MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, sInnerMessage );
1092         for (sal_Int32 j=0;j<loop_count;j++)
1093         {
1094
1095             pChar = new char[8 * 1024];
1096             aMemHolder.push_back(pChar);
1097         }
1098     }
1099     MAKE_MEMORY_SNAPSHOT( aInnerMemoryInfo, "last allocation done" );
1100
1101     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "free pieces" );
1102
1103     pChar = NULL;
1104     for (std::vector<char*>::iterator it = aMemHolder.begin();
1105          it != aMemHolder.end();
1106          it++)
1107     {
1108         pChar = *it;
1109         delete []pChar;
1110     }
1111     aMemHolder.clear();
1112
1113     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, OString("get another 8 MB as ").concat(sPieces) );
1114
1115
1116     for (sal_Int32 j=0;j<alloc_count;j++)
1117     {
1118         pChar = new char[8 * 1024];
1119         aMemHolder.push_back(pChar);
1120     }
1121
1122     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "free second set of pieces" );
1123
1124     pChar = NULL;
1125     for (std::vector<char*>::iterator jt = aMemHolder.begin();
1126          jt != aMemHolder.end();
1127          jt++)
1128     {
1129         pChar = *jt;
1130         delete []pChar;
1131     }
1132     aMemHolder.clear();
1133
1134     MAKE_MEMORY_SNAPSHOT( aMemoryInfo, "ich habe fertig." );
1135     LOG_MEMORYMEASURE( "---------------- Trust Memory Test ----------------------------", "Cross-checked memory traces.", aMemoryInfo );
1136     LOG_MEMORYMEASURE( "---------------- Small Allocation Loop ------------------------", "Allocation Loop Detail memory traces.", aInnerMemoryInfo );
1137
1138     return 0;
1139 }
1140
1141 // -----------------------------------------------------------------------------
1142 static uno::Reference< lang::XMultiServiceFactory > g_xORB;
1143 static void createORB(char const* pRegistry)
1144 {
1145     if (!g_xORB.is())
1146         try
1147         {
1148             rtl::OUString const sServiceRegistry = OUString::createFromAscii(pRegistry);
1149
1150             g_xORB = createRegistryServiceFactory( sServiceRegistry, ::rtl::OUString() );
1151
1152         }
1153         catch (uno::Exception &e)
1154         {
1155             cerr << "Exception creating the service factory: " << e.Message << "\n";
1156         }
1157     else
1158         cerr << "Trying to recreate the service factory\n";
1159
1160     if (!g_xORB.is())
1161     {
1162         ::flush(cout);
1163         cerr << "Could not create the service factory '" << pRegistry << "' !\n";
1164         exit(-2);
1165     }
1166 }
1167 uno::Reference< lang::XMultiServiceFactory > getORB()
1168 {
1169     if (!g_xORB.is())
1170     {
1171         createORB( "applicat.rdb" );
1172     }
1173     return g_xORB;
1174 }
1175 // -----------------------------------------------------------------------------
1176
1177
1178 } // namespace configmgr
1179 // -----------------------------------------------------------------------------
1180 void usage()
1181 {
1182     cerr << "Wrong or missing parameters.\nUsage:\n"
1183             "\tmemorytest [-r <registry.rdb>] (all | trust | request | api)+ [clear] [(+<module>|-<module>)+]\n";
1184
1185     exit(-1);
1186 }
1187
1188 // -----------------------------------------------------------------------------
1189 // ------------------------------------ Main ------------------------------------
1190 // -----------------------------------------------------------------------------
1191 #if (defined UNX) || (defined OS2)
1192 int main( int argc, char * argv[] )
1193 #else
1194 int _cdecl main( int argc, char * argv[] )
1195 #endif
1196 {
1197     if (argc > 1 && !::rtl_str_compare(argv[1], "-r"  ) )
1198     {
1199         if (!argv[2]) usage();
1200
1201         configmgr::createORB(argv[2]);
1202
1203         argv += 2;
1204         argc -= 2;
1205     }
1206     configmgr::getORB(); // ensures there is one
1207
1208     enum TestSelect { TEST_TRUST = 01, TEST_REQUEST = 02, TEST_API = 04, TEST_ALL = 07 };
1209
1210     unsigned nSelect = 0;
1211     while (argc >= 1 && argv[1] != NULL)
1212     {
1213              if ( !::rtl_str_compareIgnoreAsciiCase(argv[1], "trust"  ) ) nSelect |= TEST_TRUST;
1214         else if ( !::rtl_str_compareIgnoreAsciiCase(argv[1], "request") ) nSelect |= TEST_REQUEST;
1215         else if ( !::rtl_str_compareIgnoreAsciiCase(argv[1], "api"    ) ) nSelect |= TEST_API;
1216         else if ( !::rtl_str_compareIgnoreAsciiCase(argv[1], "all"    ) ) nSelect |= TEST_ALL;
1217         else break;
1218
1219         // here we found a known selector, so look on
1220         ++argv;
1221         --argc;
1222     }
1223
1224     if (nSelect == 0) usage();
1225
1226 //--------------------
1227 #define DO_TEST( test, func )   \
1228     if (nSelect & TEST_##test)   \
1229     {                           \
1230         char const * const test_name = #test;   \
1231         if (int nRet = func(argc, argv))        \
1232             cerr << "Test: " << test_name << " returned with error code " << nRet << endl;  \
1233         else                                                                                \
1234             cerr << "Test: " << test_name << " finished without error !\n" ;                  \
1235     } else // to allow a semicolon
1236 //--------------------
1237
1238     DO_TEST( TRUST   , configmgr::trust );
1239     DO_TEST( REQUEST , configmgr::requestTest );
1240     DO_TEST( API     , configmgr::main );
1241
1242     return 0;
1243 }
1244