1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sal.hxx" 26 27 // Documentation about bootstraping can be found at: 28 // http://udk.openoffice.org/common/man/concept/micro_deployment.html 29 30 #include <math.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <algorithm> // STL 34 35 #ifdef WNT 36 #define WIN32_LEAN_AND_MEAN 37 #include <windows.h> 38 #endif 39 40 #include "gtest/gtest.h" 41 //#include "stringhelper.hxx" 42 //#include "valueequal.hxx" 43 #include <rtl/bootstrap.hxx> 44 45 #include <rtl/ustrbuf.hxx> 46 #include <rtl/ustring.h> 47 #include <rtl/ustring.hxx> 48 #include <osl/file.hxx> 49 #include <osl/module.hxx> 50 #include <osl/process.h> /* osl_getExecutableFile() */ 51 52 #include <osl/thread.hxx> 53 54 // using namespace osl; 55 using namespace rtl; 56 57 #define TESTSHL2_INI "testshl2" 58 #define PSEUDO_INI "pseudo" 59 60 /** print a UNI_CODE String. And also print some comments of the string. 61 */ 62 inline void printUString( const ::rtl::OUString & str, const sal_Char * msg = "" ) 63 { 64 65 if (strlen(msg) > 0) 66 { 67 printf("%s: ", msg ); 68 } 69 rtl::OString aString; 70 aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US ); 71 printf("%s\n", (char *)aString.getStr( ) ); 72 } 73 74 /** if the file exist 75 */ 76 bool t_fileExist(rtl::OUString const& _sFilename) 77 { 78 ::osl::FileBase::RC nError1; 79 ::osl::File aTestFile( _sFilename ); 80 nError1 = aTestFile.open ( OpenFlag_Read ); 81 if ( ( ::osl::FileBase::E_NOENT != nError1 ) && ( ::osl::FileBase::E_ACCES != nError1 ) ) 82 { 83 aTestFile.close( ); 84 return true; 85 } 86 return false; 87 } 88 89 /** get the exectutable path ( here is bootstrap_process), on Linux, such as "sal/unxlngi4.pro/bin/" 90 */ 91 inline ::rtl::OUString getModulePath( void ) 92 { 93 ::rtl::OUString suDirPath; 94 ::osl::Module::getUrlFromAddress( ( oslGenericFunction ) &getModulePath, suDirPath ); 95 96 suDirPath = suDirPath.copy( 0, suDirPath.lastIndexOf('/') ); 97 suDirPath = suDirPath.copy( 0, suDirPath.lastIndexOf('/') + 1); 98 suDirPath += rtl::OUString::createFromAscii("bin"); 99 return suDirPath; 100 } 101 102 #define TESTSHL2_INI "testshl2" 103 #define PSEUDO_INI "pseudo" 104 105 106 static rtl::OUString getExecutableDirectory() 107 { 108 rtl::OUString fileName; 109 osl_getExecutableFile(&fileName.pData); 110 111 sal_Int32 nDirEnd = fileName.lastIndexOf('/'); 112 113 OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory"); 114 115 rtl::OUString aDirURL = fileName.copy(0, nDirEnd); 116 return aDirURL; 117 } 118 119 120 // get the URL of testshl2rc/rtlrc/pseudorc 121 inline rtl::OUString t_getSourcePath(rtl::OString const& _sFilename) 122 { 123 124 rtl::OUString aDirURL(getExecutableDirectory()); 125 aDirURL += OUString::createFromAscii( "/"); 126 aDirURL += OUString::createFromAscii( _sFilename.getStr() ); 127 #if defined(WNT) || defined(OS2) 128 aDirURL += rtl::OUString::createFromAscii(".ini"); 129 #else 130 aDirURL += rtl::OUString::createFromAscii("rc"); 131 #endif 132 return aDirURL; 133 134 // LLA: does not right work on my personal laptop, SRC_ROOT does not show where the source is :-(. 135 /* 136 sal_Char * pStr = getenv("SRC_ROOT"); 137 rtl::OUString suPath; 138 if (filename != "") 139 { 140 suPath = rtl::OUString::createFromAscii(pStr) + rtl::OUString::createFromAscii( "/sal/qa/rtl/bootstrap/" ) 141 + rtl::OUString::createFromAscii( filename ); 142 } 143 else 144 { 145 suPath = rtl::OUString::createFromAscii(pStr) + rtl::OUString::createFromAscii( "/sal/qa/rtl/bootstrap" ); 146 } 147 rtl::OUString suURL; 148 ::osl::FileBase::getFileURLFromSystemPath( suPath, suURL ); 149 return suURL; 150 */ 151 } 152 153 void thread_sleep_tenth_sec(sal_Int32 _nTenthSec) 154 { 155 #ifdef WNT //Windows 156 Sleep(_nTenthSec * 100 ); 157 #endif 158 #if ( defined UNX ) || ( defined OS2 ) //Unix 159 TimeValue nTV; 160 nTV.Seconds = static_cast<sal_uInt32>( _nTenthSec/10 ); 161 nTV.Nanosec = ( (_nTenthSec%10 ) * 100000000 ); 162 osl_waitThread(&nTV); 163 #endif 164 } 165 166 // ----------------------------------------------------------------------------- 167 168 namespace rtl_Bootstrap 169 { 170 class ctor : public ::testing::Test 171 { 172 public: 173 // initialise your test code values here. 174 void SetUp() 175 { 176 } 177 178 void TearDown() 179 { 180 } 181 }; // class ctor 182 183 // ctor with ini name 184 TEST_F(ctor, ctor_001) 185 { 186 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 187 printUString( suIniname ); 188 Bootstrap aBootstrap( suIniname ); 189 rtl::OUString suGetname; // = rtl::OUString::createFromAscii(""); 190 aBootstrap.getIniName( suGetname ); 191 printUString( suGetname ); 192 193 // LLA: first: this seems to be a wrong test. 194 // second: there seems to be a design hole, if I give a absolute path ini file, 195 // but try to use ${file::KEYVALUE} than 'file' will only used out of the 'executable path'/file 196 // not from the path given from the absolute path. 197 198 // Due to the fact, we create at this position a file (createTestshl2rc() ), we check for existence 199 bool bFileExist = t_fileExist( suGetname ); 200 ASSERT_TRUE(bFileExist == true) << "ctor error with initial file."; 201 } 202 203 TEST_F(ctor, ctor_002) 204 { 205 rtl::Bootstrap aBootstrap; 206 rtl::OUString suGetname; 207 aBootstrap.getIniName( suGetname ); 208 printUString( suGetname ); 209 ASSERT_TRUE(suGetname.getLength() != 0) << "ctor error without initial file."; 210 } 211 212 class getFrom : public ::testing::Test 213 { 214 public: 215 // initialise your test code values here. 216 void SetUp() 217 { 218 } 219 220 void TearDown() 221 { 222 } 223 224 /** helper function: return the child process's ret value( typedef sal_uInt32 oslProcessExitCode;) 225 * param1 is the process's name(only file name, not include path) 226 */ 227 oslProcessExitCode ini_execProcess( const sal_Char* process_name, const sal_Char * flag ) 228 { 229 rtl::OUString suCWD = getModulePath(); 230 oslProcess hProcess = NULL; 231 rtl::OUString suFileURL = suCWD; 232 suFileURL += rtl::OUString::createFromAscii("/") + rtl::OUString::createFromAscii(process_name) ; 233 #if defined(WNT) || defined(OS2) 234 suFileURL += rtl::OUString::createFromAscii(".exe"); 235 #endif 236 const int nParameterCount = 3; 237 rtl_uString* pParameters[ nParameterCount ]; 238 OUString suFlag( OUString::createFromAscii(flag) ); 239 OUString suEnv1( OUString::createFromAscii("-env:UNO_SERVICES=service.rdb")); 240 OUString suIniname = t_getSourcePath("rtl"); 241 printUString( suIniname, "rtl path:"); 242 //OUString suEnv2( OUString::createFromAscii("-env:MYENV=bootstrap_process")); 243 244 pParameters[0] = suFlag.pData; 245 pParameters[1] = suEnv1.pData; 246 // the custom ini/rc file's URL 247 pParameters[2] = suIniname.pData; 248 249 oslProcessError osl_error = osl_executeProcess( 250 suFileURL.pData, 251 pParameters, 252 nParameterCount, 253 osl_Process_WAIT, 254 0, 255 suCWD.pData, 256 NULL, 257 0, 258 &hProcess ); 259 260 EXPECT_TRUE(osl_error == osl_Process_E_None) 261 << "osl_createProcess failed"; 262 osl_joinProcess(hProcess); 263 oslProcessInfo* pInfo = new oslProcessInfo; 264 pInfo->Size = sizeof( oslProcessInfo ); 265 osl_error = osl_getProcessInfo( hProcess, osl_Process_EXITCODE, pInfo ); 266 EXPECT_TRUE(osl_Process_E_None == osl_error) 267 << "osl_getProcessInfo returned with failure"; 268 269 printf("the exit code is %d.\n", pInfo->Code ); 270 oslProcessExitCode nCode = pInfo->Code; 271 delete pInfo; 272 return nCode; 273 } 274 275 }; // class getFrom 276 277 // get the value of env variable 278 TEST_F(getFrom, getFrom_001) 279 { 280 Bootstrap aBootstrap; 281 rtl::OUString suValue; 282 rtl::OUString suValuename = rtl::OUString::createFromAscii( "SOLAR_JAVA" ); 283 //aBootstrap.getFrom( suValuename, suValue ); 284 aBootstrap.getFrom( suValuename, suValue ); 285 sal_Char * pStr = getenv("SOLAR_JAVA"); 286 // printUString( suGetname ); 287 ASSERT_TRUE(suValue.compareToAscii( pStr ) == 0) << "get the value of environment variable."; 288 } 289 /* Notes on Windows: 290 void getFrom_001_1() 291 { 292 Bootstrap aBootstrap; 293 rtl::OUString suValue; 294 rtl::OUString suValuename = rtl::OUString::createFromAscii( "SRC_ROOT" ); 295 //aBootstrap.getFrom( suValuename, suValue ); 296 aBootstrap.getFrom( suValuename, suValue ); 297 sal_Char * pStr = getenv("SRC_ROOT"); 298 // printUString( suGetname ); 299 ASSERT_TRUE(suValue.compareToAscii( pStr ) == 0) << "get the value of environment variable."; 300 } 301 The result on Windows: 302 # # the SRC_ROOT is e:\Qadev\cvs\m19 303 # # suValue is e:Qadevcvsm19 304 reason: 305 The problem is that the internally getenv()ed variable SRC_ROOT is macro expanded, 306 thus every \ will introduce an escape. 307 */ 308 309 // get the value of a variable in ini file 310 TEST_F(getFrom, getFrom_002) 311 { 312 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 313 Bootstrap aBootstrap( suIniname ); 314 rtl::OUString suGetname; 315 rtl::OUString suValuename = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); 316 aBootstrap.getFrom( suValuename, suGetname ); 317 printUString( suGetname ); 318 ASSERT_TRUE(suGetname.getLength() != 0) << "get the value of a variable in ini file."; 319 } 320 321 //use defaut value 322 TEST_F(getFrom, getFrom_003) 323 { 324 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 325 Bootstrap aBootstrap( suIniname ); 326 rtl::OUString suGetname; 327 rtl::OUString suValuename = rtl::OUString::createFromAscii( "MY_VALUE" ); 328 rtl::OUString myDefault = rtl::OUString::createFromAscii( "2" ); 329 aBootstrap.getFrom( suValuename, suGetname, myDefault ); 330 //printUString( suGetname ); 331 ASSERT_TRUE(suGetname.compareTo( myDefault ) == 0) << "getFrom use default."; 332 } 333 334 TEST_F(getFrom, getFrom_004) 335 { 336 printf("1\n"); 337 // initialise Bootstrap with an own ini file 338 // PSEUDO_INI is pseudo(rc|.ini) created be create_pseudorc() 339 rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); 340 Bootstrap aBootstrap( suIniname ); 341 342 rtl::OUString suGetIniName; 343 aBootstrap.getIniName( suGetIniName ); 344 345 printUString(suGetIniName, "Current bootstrap file"); 346 sal_Int32 nIndex = suGetIniName.indexOf(rtl::OUString::createFromAscii( "pseudo" )); 347 ASSERT_TRUE(nIndex > 0) << "ini name must have 'pseudo' in name."; 348 349 // rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); 350 // ASSERT_TRUE(bsHandle != 0) << "getHandle return NULL!"; 351 352 rtl::OUString suValue; 353 rtl::OUString suKeyName = rtl::OUString::createFromAscii( "FILE" ); 354 aBootstrap.getFrom( suKeyName, suValue ); 355 printUString( suValue ); 356 sal_Int32 nCompare = suValue.compareTo( rtl::OUString::createFromAscii("pseudo file") ); 357 358 ASSERT_TRUE(nCompare == 0) 359 << "<Bootstrap('pseudo')>.getFrom('FILE', ...) result is unexpected."; 360 } 361 362 TEST_F(getFrom, getFrom_004_1) 363 { 364 // get the same key out of the default context 365 rtl::OUString suKeyName = rtl::OUString::createFromAscii( "FILE" ); 366 rtl::OUString suGetValue; 367 Bootstrap::get( suKeyName, suGetValue ); 368 printUString( suGetValue ); 369 370 ASSERT_TRUE(suGetValue.compareTo( rtl::OUString::createFromAscii("testshl2 file") ) == 0) 371 << "Bootstrap::get('FILE', ...)"; 372 } 373 374 TEST_F(getFrom, getFrom_005_1) 375 { 376 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "1" ); 377 ASSERT_TRUE(nExitCode == 10) << "Parameters passed by command line can not be gotten!"; 378 } 379 TEST_F(getFrom, getFrom_005_2) 380 { 381 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "2" ); 382 ASSERT_TRUE(nExitCode == 20) << "Parameters passed by .ini/rc file can not be gotten!"; 383 } 384 TEST_F(getFrom, getFrom_005_3) 385 { 386 #if (defined WNT) || (defined SOLARIS) 387 putenv(const_cast< char * >("QADEV_BOOTSTRAP=sun&ms")); 388 #else 389 setenv("QADEV_BOOTSTRAP", "sun&ms", 0); 390 #endif 391 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "3" ); 392 ASSERT_TRUE(nExitCode == 30) << "Parameters passed by environment variables can not be gotten!"; 393 } 394 TEST_F(getFrom, getFrom_005_4) 395 { 396 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "4" ); 397 ASSERT_TRUE(nExitCode == 40) << "Parameters passed by customed .ini/rc file can not be gotten!"; 398 } 399 TEST_F(getFrom, getFrom_005_5) 400 { 401 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "5" ); 402 ASSERT_TRUE(nExitCode == 50) << "Parameters passed by inheritance can not be gotten!"; 403 } 404 TEST_F(getFrom, getFrom_005_6) 405 { 406 oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "6" ); 407 ASSERT_TRUE(nExitCode == 60) << "Parameters passed by default can not be gotten!"; 408 } 409 410 class setIniFilename : public ::testing::Test 411 { 412 public: 413 // initialise your test code values here. 414 void SetUp() 415 { 416 } 417 418 void TearDown() 419 { 420 } 421 }; // class setIniFilename 422 423 TEST_F(setIniFilename, setIniFilename_001) 424 { 425 Bootstrap aBootstrap; 426 427 rtl::OUString suGetIniname; 428 aBootstrap.getIniName( suGetIniname ); 429 //which should be .....testshl2rc 430 //printUString( suGetIniname ); 431 432 rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); 433 Bootstrap::setIniFilename( suIniname ); 434 435 rtl::OUString suGetname; 436 aBootstrap.getIniName( suGetname ); 437 438 printUString( suGetname ); 439 ASSERT_TRUE(suGetname.compareTo( suIniname ) == 0 440 && suGetname.compareTo( suGetIniname ) != 0) << "setIniFilename then get it."; 441 } 442 443 TEST_F(setIniFilename, setIniFilename_002) 444 { 445 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 446 // ASSERT_TRUE(t_fileExist(suIniname ) == true) << 447 // "test failed, Bootstrap ini does not exist." 448 449 Bootstrap::setIniFilename( suIniname ); 450 //rtl_bootstrap_args_open( suIniname.pData ); 451 rtl::OUString suGetname; 452 rtl::OUString suValuename = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); 453 //aBootstrap.getFrom( suValuename, suGetname ); 454 Bootstrap::get( suValuename, suGetname ); 455 printUString( suGetname ); 456 ASSERT_TRUE(suGetname.getLength() != 0) << "setIniFilename and get value of the argument."; 457 } 458 459 class getHandle : public ::testing::Test 460 { 461 public: 462 // initialise your test code values here. 463 void SetUp() 464 { 465 } 466 467 void TearDown() 468 { 469 } 470 }; // class getHandle 471 472 TEST_F(getHandle, getHandle_001) 473 { 474 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 475 Bootstrap aBootstrap; 476 rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); 477 ASSERT_TRUE(bsHandle == 0) << "getHandle should return 0 if the bootstrap has no ini file!"; 478 } 479 TEST_F(getHandle, getHandle_002) 480 { 481 rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); 482 Bootstrap aBootstrap( suIniname ); 483 484 rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); 485 ASSERT_TRUE(bsHandle != 0) << "getHandle return NULL!"; 486 487 //rtl::OUString iniName; 488 //rtl_bootstrap_get_iniName_from_handle( bsHandle, &iniName.pData ); 489 490 rtl::OUString suValue; 491 rtl::OUString suKeyName = rtl::OUString::createFromAscii( "PSEUDOFILE" ); 492 rtl_bootstrap_get_from_handle(bsHandle, suKeyName.pData, &suValue.pData, NULL); 493 printUString( suValue); 494 495 ASSERT_TRUE(suValue.equals( rtl::OUString::createFromAscii("be pseudo") ) == sal_True) << "Can not use the handle which is returned by getHandle!"; 496 497 // ASSERT_TRUE(// suGetname.equalsIgnoreAsciiCase( iniName ) == sal_True) << "Can not use the handle which is returned by getHandle!"; 498 } 499 500 class set : public ::testing::Test 501 { 502 public: 503 // initialise your test code values here. 504 void SetUp() 505 { 506 } 507 508 void TearDown() 509 { 510 } 511 }; // class set 512 513 TEST_F(set, set_001) 514 { 515 //in ini fle, INHERITED_VALUE=inherited_value 516 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 517 Bootstrap aBootstrap( suIniname); 518 rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); 519 rtl::OUString suValue = rtl::OUString::createFromAscii( "ok" ); 520 // set to another value 521 Bootstrap::set( suName, suValue ); 522 rtl::OUString suGetValue; 523 Bootstrap::get( suName, suGetValue); 524 ASSERT_TRUE(suGetValue.compareTo(suValue) == 0) << "set and get argument failed."; 525 } 526 TEST_F(set, set_002) 527 { 528 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 529 Bootstrap myBootstrap( suIniname); 530 rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); 531 rtl::OUString suGetOrientValue; 532 Bootstrap::get( suName, suGetOrientValue); 533 // ?? INHERITED_VALUE = ok now, which is set in set_001 534 printUString( suGetOrientValue ); 535 536 rtl::OUString suValue = rtl::OUString::createFromAscii( TESTSHL2_INI ); 537 // set to another value 538 Bootstrap::set( suName, suValue ); 539 rtl::OUString suGetValue; 540 Bootstrap::get( suName, suGetValue); 541 ASSERT_TRUE(suGetValue.compareTo(suValue) == 0) << "set and get argument failed."; 542 } 543 544 class expandMacrosFrom : public ::testing::Test 545 { 546 public: 547 void SetUp() 548 { 549 } 550 551 void TearDown() 552 { 553 } 554 }; // class expandMacrosFrom 555 556 TEST_F(expandMacrosFrom, expandMacrosFrom_001) 557 { 558 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 559 Bootstrap aBootstrap( suIniname); 560 rtl::OUString suMacro = rtl::OUString::createFromAscii( "$MYVAR/expand1" ); 561 //printUString( suMacro ); 562 //expandMacro now 563 aBootstrap.expandMacrosFrom( suMacro ); 564 rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "src680_test/expand1" ); 565 //printUString( suMacro ); 566 ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0) << "expandMacrosFrom failed."; 567 } 568 569 /** here a special macro should expand 570 * if rtlrc is under sal/qa/rtl/bootstrap/, "${rtlrc:Bootstrap:RTLVALUE}" could be expanded 571 * else rtlrc is under solver/680/unxlngi4.pro/bin/, "${file:/// ....solver/680/unxlngi4.pro/bin/rtlrc:Bootstrap:RTLVALUE}" 572 * could not be expanded 573 */ 574 TEST_F(expandMacrosFrom, expandMacrosFrom_002) 575 { 576 // Build a string with '${rtl.ini:RTLVALUE}' and try to expand it. 577 // In function 'create_rtlrc() is the content of the rtl.ini file. 578 579 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 580 printf("inifile is:"); 581 printUString( suIniname ); 582 Bootstrap aBootstrap( suIniname) ; 583 rtl::OUString suMacro = rtl::OUString::createFromAscii( "${" ); //rtlrc:Bootstrap:RTLVALUE}"); 584 585 rtl::OUString aDirURL = OUString::createFromAscii( "$ORIGIN"); 586 aDirURL += OUString::createFromAscii( "/"); 587 aDirURL += OUString::createFromAscii( "rtl" ); 588 #if defined(WNT) || defined(OS2) 589 aDirURL += rtl::OUString::createFromAscii(".ini"); 590 #else 591 aDirURL += rtl::OUString::createFromAscii("rc"); 592 #endif 593 594 suMacro += aDirURL;//t_getSourcePath("rtl"); 595 suMacro += rtl::OUString::createFromAscii( "::RTLVALUE}"); 596 597 printf("created macro is: "); 598 printUString( suMacro ); 599 //expandMacro now 600 aBootstrap.expandMacrosFrom( suMacro ); 601 printf("expanded macro is:"); 602 printUString( suMacro ); 603 rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "qadev17" ); 604 ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0 ) 605 << "failed, can't expand '${file:///.../" SAL_CONFIGFILE("rtl") "::RTLVALUE}' to 'qadev17'"; 606 } 607 TEST_F(expandMacrosFrom, expandMacrosFrom_002_1) 608 { 609 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 610 printf("inifile is:"); 611 printUString( suIniname ); 612 Bootstrap aBootstrap( suIniname); 613 614 rtl::OUString suMacro; 615 // just a simple test, if this really work. 616 aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE2" ), suMacro ); 617 printf("SOFROMVALUE2:"); 618 printUString( suMacro ); 619 ASSERT_TRUE(suMacro.getLength() > 0) << "'SOFROMVALUE2' seems to do not exist."; 620 621 aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE" ), suMacro ); 622 623 printf("SOFROMVALUE:"); 624 printUString( suMacro ); 625 626 //expandMacro now 627 // seems to be, that getFrom() already expand the string 628 // printf("expanded macro is:"); 629 // aBootstrap.expandMacrosFrom( suMacro ); 630 // printUString( suMacro ); 631 rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "src680_qadev" ); 632 ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0) 633 << "failed, can't expand '${" SAL_CONFIGFILE("rtl") "::SOVALUE}' to 'src680_qadev'"; 634 } 635 TEST_F(expandMacrosFrom, expandMacrosFrom_002_2) 636 { 637 // test, to read and expand SOFROMVALUE3 638 // SOFROMVALUE3 is 'rtl(.ini|rc)::TESTSHL_SOVALUE' which should expand to 'rtlfile' if all is ok. 639 640 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 641 printf("inifile is:"); 642 printUString( suIniname ); 643 Bootstrap aBootstrap( suIniname); 644 645 rtl::OUString suMacro; 646 aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE3" ), suMacro ); 647 648 printf("SOFROMVALUE3:"); 649 printUString( suMacro ); 650 651 if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file") ) == sal_True) 652 { 653 ASSERT_TRUE(0) << "Value 'SOFROMVALUE3' is read from the wrong ini file."; 654 } 655 else 656 { 657 ASSERT_TRUE(suMacro.equals(rtl::OUString::createFromAscii("rtlfile") ) == sal_True) << "SOFROMVALUE3 should contain 'rtlfile'."; 658 } 659 } 660 //? I don't know if this is a right test. 661 // void expandMacrosFrom_002_3() 662 // { 663 // // test, to read and expand SOFROMVALUE4 664 // // SOFROMVALUE4 is 'rtl(.ini|rc):Other_Section:TESTSHL_SOVALUE' which should expand to '' if all is ok. 665 // 666 // rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 667 // printf("inifile is:"); 668 // printUString( suIniname ); 669 // Bootstrap aBootstrap( suIniname); 670 // 671 // rtl::OUString suMacro; 672 // aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE4" ), suMacro ); 673 // 674 // printf("SOFROMVALUE4:"); 675 // printUString( suMacro ); 676 // 677 // if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file") ) == sal_True) 678 // { 679 // ASSERT_TRUE(0) << "Value 'SOFROMVALUE4' is read from the wrong section out of the wrong ini file."; 680 // } 681 // else if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file_other") ) == sal_True) 682 // { 683 // ASSERT_TRUE(0) << "Value 'SOFROMVALUE4' is read from the wrong ini file."; 684 // } 685 // else 686 // { 687 // ASSERT_TRUE(suMacro.equals(rtl::OUString::createFromAscii("rtlfile_other") ) == sal_True) << "Value 'SOFROMVALUE4' should contain 'rtlfile_other'."; 688 // } 689 // } 690 TEST_F(expandMacrosFrom, expandMacrosFrom_003) 691 { 692 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 693 Bootstrap aBootstrap( suIniname); 694 rtl::OUString suMacro[4]; 695 suMacro[0] = rtl::OUString::createFromAscii( "$SYSUSERCONFIG" ); 696 suMacro[1] = rtl::OUString::createFromAscii( "$SYSUSERHOME" ); 697 suMacro[2] = rtl::OUString::createFromAscii( "$SYSBINDIR" ); 698 suMacro[3] = rtl::OUString::createFromAscii( "$ORIGIN" ); 699 700 for ( int i = 0; i < 4; i++ ) 701 { 702 aBootstrap.expandMacrosFrom( suMacro[i] ); 703 printUString(suMacro[i]); 704 } 705 // printUString( t_getSourcePath("") ); 706 // ASSERT_TRUE(suMacro[3].equalsIgnoreAsciiCase(t_getSourcePath("")) == sal_True) << "some integral variables."; 707 ASSERT_TRUE(suMacro[0].getLength() > 0 && 708 suMacro[1].getLength() > 0 && 709 suMacro[2].getLength() > 0 && 710 suMacro[3].getLength() > 0) << "some integral variables."; 711 } 712 713 TEST_F(expandMacrosFrom, testRecursion) { 714 rtl::OUString t(RTL_CONSTASCII_USTRINGPARAM("$RECURSIVE")); 715 Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); 716 ASSERT_TRUE(t.equalsAsciiL( 717 RTL_CONSTASCII_STRINGPARAM("***RECURSION DETECTED***"))) << "recursion detection"; 718 } 719 720 TEST_F(expandMacrosFrom, testLink) { 721 rtl::OUString t(RTL_CONSTASCII_USTRINGPARAM("$LINKED")); 722 Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); 723 ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("qadev17"))) << "link file"; 724 } 725 726 TEST_F(expandMacrosFrom, testOverride) { 727 rtl::OUString t1( 728 RTL_CONSTASCII_USTRINGPARAM( 729 "${.override:$ORIGIN/" SAL_CONFIGFILE("rtl") ":ORIGIN}")); 730 Bootstrap(t_getSourcePath("rtl")).expandMacrosFrom(t1); 731 ASSERT_TRUE(t1.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("direct"))) << "override ORIGIN"; 732 rtl::OUString t2( 733 RTL_CONSTASCII_USTRINGPARAM( 734 "${.override:$ORIGIN/" SAL_CONFIGFILE("none") ":MYVAR}")); 735 Bootstrap::expandMacros(t2); 736 ASSERT_TRUE(t2.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("src680_test"))) << "override MYVAR"; 737 } 738 739 TEST_F(expandMacrosFrom, testNonexisting) { 740 rtl::OUString t( 741 RTL_CONSTASCII_USTRINGPARAM( 742 "${$ORIGIN/" SAL_CONFIGFILE("none") ":MYVAR}")); 743 Bootstrap::expandMacros(t); 744 ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("src680_test"))) << "nonexisting"; 745 } 746 747 TEST_F(expandMacrosFrom, testSection) { 748 rtl::OUStringBuffer b; 749 b.appendAscii(RTL_CONSTASCII_STRINGPARAM("${")); 750 rtl::OUString p(t_getSourcePath(TESTSHL2_INI)); 751 for (sal_Int32 i = 0; i < p.getLength(); ++i) { 752 if (p[i] != 'u') { 753 b.append(static_cast< sal_Unicode >('\\')); 754 } 755 b.append(p[i]); 756 } 757 b.appendAscii(RTL_CONSTASCII_STRINGPARAM(":Other_Section:EXPAND}")); 758 rtl::OUString t(b.makeStringAndClear()); 759 Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); 760 ASSERT_TRUE(t.equalsAsciiL( 761 RTL_CONSTASCII_STRINGPARAM("$FILE"))) << "section expansion"; 762 // the correct answer would be "testshl2 file" instead, but 763 // expansion including a section currently erroneously does not 764 // recursively expand macros in the resulting replacement text 765 } 766 767 class expandMacros : public ::testing::Test 768 { 769 public: 770 // initialise your test code values here. 771 void SetUp() 772 { 773 } 774 775 void TearDown() 776 { 777 } 778 }; // class expandMacros 779 780 781 TEST_F(expandMacros, expandMacros_001) 782 { 783 rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); 784 Bootstrap aBootstrap( suIniname) ; 785 rtl::OUString suMacro = rtl::OUString::createFromAscii( "$INHERITED_VALUE/well" ); 786 Bootstrap::expandMacros( suMacro ); 787 788 rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); 789 OUString suGetValue; 790 Bootstrap::get( suName, suGetValue ); 791 suGetValue += OUString::createFromAscii( "/well" ); 792 ASSERT_TRUE(suGetValue.compareTo(suMacro) == 0) << "expandMacros failed."; 793 } 794 } // namespace rtl_Bootstrap 795 796 // ----------------------------------------------------------------------------- 797 798 // this macro creates an empty function, which will called by the RegisterAllFunctions() 799 // to let the user the possibility to also register some functions by hand. 800 // NOADDITIONAL; 801 802 803 // Here are some helpers, which create a new file 'rtlrc' at the executable path position 804 // and fill the file with some information. 805 // static rtl::OUString getExecutableDirectory() 806 // { 807 // rtl::OUString fileName; 808 // osl_getExecutableFile(&fileName.pData); 809 // 810 // sal_Int32 nDirEnd = fileName.lastIndexOf('/'); 811 // 812 // OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory"); 813 // 814 // rtl::OUString aDirURL = fileName.copy(0, nDirEnd); 815 // return aDirURL; 816 // } 817 818 static void removeAndCreateFile(rtl::OUString const& _suFileURL, rtl::OString const& _sContent) 819 { 820 osl::File::remove(_suFileURL); 821 822 ::std::auto_ptr<osl::File> pFile( new osl::File( _suFileURL ) ); 823 ::osl::FileBase::RC nError = pFile->open( OpenFlag_Write | OpenFlag_Create ); 824 if ( ::osl::FileBase::E_None == nError || ::osl::FileBase::E_EXIST == nError ) 825 { 826 printf("%s\n" , OString(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 827 sal_uInt64 nWritenBytes; 828 pFile->write(_sContent.getStr(), _sContent.getLength(), nWritenBytes); 829 // printf("nBytes: %ld\n", nBytes); 830 831 rtl::OString sError = "can't write enough bytes to file"; 832 sError += OString(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US); 833 OSL_ENSURE(nWritenBytes == _sContent.getLength(), sError.getStr()); 834 835 pFile->close(); 836 } 837 else 838 { 839 rtl::OString sError = "can't create file URL: '"; 840 rtl::OString sFile(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US); 841 sError += sFile; 842 sError += "' maybe no write access. If it is true with no write access, please create a local environment and start these tests again. rtl::Bootstrap test must quit."; 843 printf("%s\n", sError.getStr() ); 844 exit(1); 845 } 846 OSL_ASSERT(t_fileExist(_suFileURL) == true); 847 } 848 849 // ----------------------------------------------------------------------------- 850 static void create_rtlrc() 851 { 852 rtl::OUString aFileURL(getExecutableDirectory()); 853 #if defined(WNT) || defined(OS2) 854 aFileURL += rtl::OUString::createFromAscii("/rtl.ini"); 855 #else 856 aFileURL += rtl::OUString::createFromAscii("/rtlrc"); 857 #endif 858 859 rtl::OString sLines; 860 sLines += "[Bootstrap]\n"; 861 sLines += "SOVALUE=src680_qadev\n"; 862 sLines += "RTLVALUE=qadev17\n"; 863 sLines += "TESTSHL_SOVALUE=rtlfile\n"; 864 sLines += "RECURSIVE=${$ORIGIN/" SAL_CONFIGFILE("testshl2") ":RECURSIVE}\n"; 865 sLines += "ORIGIN=direct\n"; 866 sLines += "[Other_Section]\n"; 867 sLines += "TESTSHL_SOVALUE=rtlfile_other\n"; 868 869 removeAndCreateFile(aFileURL, sLines); 870 } 871 872 // ----------------------------------------------------------------------------- 873 static void create_testshl2rc() 874 { 875 rtl::OUString aFileURL(getExecutableDirectory()); 876 #if defined(WNT) || defined(OS2) 877 aFileURL += rtl::OUString::createFromAscii("/testshl2.ini"); 878 #else 879 aFileURL += rtl::OUString::createFromAscii("/testshl2rc"); 880 #endif 881 rtl::OString sLines; 882 sLines += "[Bootstrap]\n"; 883 sLines += "FILE=testshl2 file\n"; 884 sLines += "MYBOOTSTRAPTESTVALUE=file\n"; 885 sLines += "INHERITED_VALUE=inherited_value\n"; 886 sLines += "INHERITED_OVERWRITTEN_VALUE=not_overwritten\n"; 887 sLines += "MYVAR=src680_test\n"; 888 sLines += "SOFROMVALUE=${$ORIGIN/" SAL_CONFIGFILE("rtl") "::SOVALUE}\n"; 889 sLines += "SOFROMVALUE2=test\n"; 890 sLines += "SOFROMVALUE3=${$ORIGIN/" SAL_CONFIGFILE("rtl") "::TESTSHL_SOVALUE}\n"; 891 sLines += "TESTSHL_SOVALUE=testshl2_file\n"; 892 //? sLines += "SOFROMVALUE4=${" SAL_CONFIGFILE("rtl") ":Other_Section:TESTSHL_SOVALUE}\n"; 893 sLines += "ILLEGAL VALUE=test\n"; 894 sLines += "ILLEGAL.DOT=test\n"; 895 sLines += "ILLEGAL;SEMICOLON=test\n"; 896 sLines += "ILLEGAL:COLON=test\n"; 897 sLines += " KEY_FOR_TRIM_TEST = value for trim test \n"; 898 sLines += "RECURSIVE=${$ORIGIN/" SAL_CONFIGFILE("rtl") ":RECURSIVE}\n"; 899 sLines += "LINKED=${${.link:$ORIGIN/testshl2-link}:RTLVALUE}\n"; 900 sLines += "[Other_Section]\n"; 901 sLines += "FILE=testshl2 file other\n"; 902 sLines += "EXPAND=$FILE\n"; 903 //? sLines += "TESTSHL_SOVALUE=testshl2_file_other\n"; 904 905 removeAndCreateFile(aFileURL, sLines); 906 907 removeAndCreateFile( 908 (getExecutableDirectory() + 909 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/testshl2-link"))), 910 SAL_CONFIGFILE("rtl")); 911 } 912 913 // ----------------------------------------------------------------------------- 914 915 static void create_pseudorc() 916 { 917 rtl::OUString aFileURL(getExecutableDirectory()); 918 #if defined(WNT) || defined(OS2) 919 aFileURL += rtl::OUString::createFromAscii("/pseudo.ini"); 920 #else 921 aFileURL += rtl::OUString::createFromAscii("/pseudorc"); 922 #endif 923 rtl::OString sLines; 924 sLines += "[Bootstrap]\n"; 925 sLines += "FILE=pseudo file\n"; 926 sLines += "PSEUDOFILE=be pseudo\n"; 927 928 removeAndCreateFile(aFileURL, sLines); 929 } 930 931 // ----------------------------------------------------------------------------- 932 void create_bootstrap_processrc() 933 { 934 rtl::OUString aDirURL(getModulePath()); 935 #if defined(WNT) || defined(OS2) 936 aDirURL += rtl::OUString::createFromAscii("/bootstrap_process.ini"); 937 #else 938 aDirURL += rtl::OUString::createFromAscii("/bootstrap_processrc"); 939 #endif 940 rtl::OString sLines; 941 sLines += "[Bootstrap]\n"; 942 sLines += "EXECUTABLE_RC=true\n"; 943 sLines += "IF_CUSTOM_RC=false\n"; 944 945 removeAndCreateFile(aDirURL, sLines); 946 } 947 // ----------------------------------------------------------------------------- 948 949 950 int main(int argc, char **argv) 951 { 952 // start message 953 printf("Initializing ...\n" ); 954 osl_setCommandArgs(argc, argv); 955 create_rtlrc(); 956 create_testshl2rc(); 957 create_pseudorc(); 958 create_bootstrap_processrc(); 959 960 printf("Initialization Done.\n" ); 961 ::testing::InitGoogleTest(&argc, argv); 962 return RUN_ALL_TESTS(); 963 } 964