| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sal.hxx" |
| |
| // Documentation about bootstraping can be found at: |
| // http://udk.openoffice.org/common/man/concept/micro_deployment.html |
| |
| #include <math.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <algorithm> // STL |
| |
| #ifdef WNT |
| #define WIN32_LEAN_AND_MEAN |
| #include <windows.h> |
| #endif |
| |
| #include "gtest/gtest.h" |
| //#include "stringhelper.hxx" |
| //#include "valueequal.hxx" |
| #include <rtl/bootstrap.hxx> |
| |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/ustring.h> |
| #include <rtl/ustring.hxx> |
| #include <osl/file.hxx> |
| #include <osl/module.hxx> |
| #include <osl/process.h> /* osl_getExecutableFile() */ |
| |
| #include <osl/thread.hxx> |
| |
| // using namespace osl; |
| using namespace rtl; |
| |
| #define TESTSHL2_INI "testshl2" |
| #define PSEUDO_INI "pseudo" |
| |
| /** print a UNI_CODE String. And also print some comments of the string. |
| */ |
| inline void printUString( const ::rtl::OUString & str, const sal_Char * msg = "" ) |
| { |
| |
| if (strlen(msg) > 0) |
| { |
| printf("%s: ", msg ); |
| } |
| rtl::OString aString; |
| aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US ); |
| printf("%s\n", (char *)aString.getStr( ) ); |
| } |
| |
| /** if the file exist |
| */ |
| bool t_fileExist(rtl::OUString const& _sFilename) |
| { |
| ::osl::FileBase::RC nError1; |
| ::osl::File aTestFile( _sFilename ); |
| nError1 = aTestFile.open ( OpenFlag_Read ); |
| if ( ( ::osl::FileBase::E_NOENT != nError1 ) && ( ::osl::FileBase::E_ACCES != nError1 ) ) |
| { |
| aTestFile.close( ); |
| return true; |
| } |
| return false; |
| } |
| |
| /** get the exectutable path ( here is bootstrap_process), on Linux, such as "sal/unxlngi4.pro/bin/" |
| */ |
| inline ::rtl::OUString getModulePath( void ) |
| { |
| ::rtl::OUString suDirPath; |
| ::osl::Module::getUrlFromAddress( ( oslGenericFunction ) &getModulePath, suDirPath ); |
| |
| suDirPath = suDirPath.copy( 0, suDirPath.lastIndexOf('/') ); |
| suDirPath = suDirPath.copy( 0, suDirPath.lastIndexOf('/') + 1); |
| suDirPath += rtl::OUString::createFromAscii("bin"); |
| return suDirPath; |
| } |
| |
| #define TESTSHL2_INI "testshl2" |
| #define PSEUDO_INI "pseudo" |
| |
| |
| static rtl::OUString getExecutableDirectory() |
| { |
| rtl::OUString fileName; |
| osl_getExecutableFile(&fileName.pData); |
| |
| sal_Int32 nDirEnd = fileName.lastIndexOf('/'); |
| |
| OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory"); |
| |
| rtl::OUString aDirURL = fileName.copy(0, nDirEnd); |
| return aDirURL; |
| } |
| |
| |
| // get the URL of testshl2rc/rtlrc/pseudorc |
| inline rtl::OUString t_getSourcePath(rtl::OString const& _sFilename) |
| { |
| |
| rtl::OUString aDirURL(getExecutableDirectory()); |
| aDirURL += OUString::createFromAscii( "/"); |
| aDirURL += OUString::createFromAscii( _sFilename.getStr() ); |
| #if defined(WNT) || defined(OS2) |
| aDirURL += rtl::OUString::createFromAscii(".ini"); |
| #else |
| aDirURL += rtl::OUString::createFromAscii("rc"); |
| #endif |
| return aDirURL; |
| |
| // LLA: does not right work on my personal laptop, SRC_ROOT does not show where the source is :-(. |
| /* |
| sal_Char * pStr = getenv("SRC_ROOT"); |
| rtl::OUString suPath; |
| if (filename != "") |
| { |
| suPath = rtl::OUString::createFromAscii(pStr) + rtl::OUString::createFromAscii( "/sal/qa/rtl/bootstrap/" ) |
| + rtl::OUString::createFromAscii( filename ); |
| } |
| else |
| { |
| suPath = rtl::OUString::createFromAscii(pStr) + rtl::OUString::createFromAscii( "/sal/qa/rtl/bootstrap" ); |
| } |
| rtl::OUString suURL; |
| ::osl::FileBase::getFileURLFromSystemPath( suPath, suURL ); |
| return suURL; |
| */ |
| } |
| |
| void thread_sleep_tenth_sec(sal_Int32 _nTenthSec) |
| { |
| #ifdef WNT //Windows |
| Sleep(_nTenthSec * 100 ); |
| #endif |
| #if ( defined UNX ) || ( defined OS2 ) //Unix |
| TimeValue nTV; |
| nTV.Seconds = static_cast<sal_uInt32>( _nTenthSec/10 ); |
| nTV.Nanosec = ( (_nTenthSec%10 ) * 100000000 ); |
| osl_waitThread(&nTV); |
| #endif |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| namespace rtl_Bootstrap |
| { |
| class ctor : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class ctor |
| |
| // ctor with ini name |
| TEST_F(ctor, ctor_001) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| printUString( suIniname ); |
| Bootstrap aBootstrap( suIniname ); |
| rtl::OUString suGetname; // = rtl::OUString::createFromAscii(""); |
| aBootstrap.getIniName( suGetname ); |
| printUString( suGetname ); |
| |
| // LLA: first: this seems to be a wrong test. |
| // second: there seems to be a design hole, if I give a absolute path ini file, |
| // but try to use ${file::KEYVALUE} than 'file' will only used out of the 'executable path'/file |
| // not from the path given from the absolute path. |
| |
| // Due to the fact, we create at this position a file (createTestshl2rc() ), we check for existence |
| bool bFileExist = t_fileExist( suGetname ); |
| ASSERT_TRUE(bFileExist == true) << "ctor error with initial file."; |
| } |
| |
| TEST_F(ctor, ctor_002) |
| { |
| rtl::Bootstrap aBootstrap; |
| rtl::OUString suGetname; |
| aBootstrap.getIniName( suGetname ); |
| printUString( suGetname ); |
| ASSERT_TRUE(suGetname.getLength() != 0) << "ctor error without initial file."; |
| } |
| |
| class getFrom : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| |
| /** helper function: return the child process's ret value( typedef sal_uInt32 oslProcessExitCode;) |
| * param1 is the process's name(only file name, not include path) |
| */ |
| oslProcessExitCode ini_execProcess( const sal_Char* process_name, const sal_Char * flag ) |
| { |
| rtl::OUString suCWD = getModulePath(); |
| oslProcess hProcess = NULL; |
| rtl::OUString suFileURL = suCWD; |
| suFileURL += rtl::OUString::createFromAscii("/") + rtl::OUString::createFromAscii(process_name) ; |
| #if defined(WNT) || defined(OS2) |
| suFileURL += rtl::OUString::createFromAscii(".exe"); |
| #endif |
| const int nParameterCount = 3; |
| rtl_uString* pParameters[ nParameterCount ]; |
| OUString suFlag( OUString::createFromAscii(flag) ); |
| OUString suEnv1( OUString::createFromAscii("-env:UNO_SERVICES=service.rdb")); |
| OUString suIniname = t_getSourcePath("rtl"); |
| printUString( suIniname, "rtl path:"); |
| //OUString suEnv2( OUString::createFromAscii("-env:MYENV=bootstrap_process")); |
| |
| pParameters[0] = suFlag.pData; |
| pParameters[1] = suEnv1.pData; |
| // the custom ini/rc file's URL |
| pParameters[2] = suIniname.pData; |
| |
| oslProcessError osl_error = osl_executeProcess( |
| suFileURL.pData, |
| pParameters, |
| nParameterCount, |
| osl_Process_WAIT, |
| 0, |
| suCWD.pData, |
| NULL, |
| 0, |
| &hProcess ); |
| |
| EXPECT_TRUE(osl_error == osl_Process_E_None) |
| << "osl_createProcess failed"; |
| osl_joinProcess(hProcess); |
| oslProcessInfo* pInfo = new oslProcessInfo; |
| pInfo->Size = sizeof( oslProcessInfo ); |
| osl_error = osl_getProcessInfo( hProcess, osl_Process_EXITCODE, pInfo ); |
| EXPECT_TRUE(osl_Process_E_None == osl_error) |
| << "osl_getProcessInfo returned with failure"; |
| |
| printf("the exit code is %d.\n", pInfo->Code ); |
| oslProcessExitCode nCode = pInfo->Code; |
| delete pInfo; |
| return nCode; |
| } |
| |
| }; // class getFrom |
| |
| // get the value of env variable |
| TEST_F(getFrom, getFrom_001) |
| { |
| Bootstrap aBootstrap; |
| rtl::OUString suValue; |
| rtl::OUString suValuename = rtl::OUString::createFromAscii( "SOLAR_JAVA" ); |
| //aBootstrap.getFrom( suValuename, suValue ); |
| aBootstrap.getFrom( suValuename, suValue ); |
| sal_Char * pStr = getenv("SOLAR_JAVA"); |
| // printUString( suGetname ); |
| ASSERT_TRUE(suValue.compareToAscii( pStr ) == 0) << "get the value of environment variable."; |
| } |
| /* Notes on Windows: |
| void getFrom_001_1() |
| { |
| Bootstrap aBootstrap; |
| rtl::OUString suValue; |
| rtl::OUString suValuename = rtl::OUString::createFromAscii( "SRC_ROOT" ); |
| //aBootstrap.getFrom( suValuename, suValue ); |
| aBootstrap.getFrom( suValuename, suValue ); |
| sal_Char * pStr = getenv("SRC_ROOT"); |
| // printUString( suGetname ); |
| ASSERT_TRUE(suValue.compareToAscii( pStr ) == 0) << "get the value of environment variable."; |
| } |
| The result on Windows: |
| # # the SRC_ROOT is e:\Qadev\cvs\m19 |
| # # suValue is e:Qadevcvsm19 |
| reason: |
| The problem is that the internally getenv()ed variable SRC_ROOT is macro expanded, |
| thus every \ will introduce an escape. |
| */ |
| |
| // get the value of a variable in ini file |
| TEST_F(getFrom, getFrom_002) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname ); |
| rtl::OUString suGetname; |
| rtl::OUString suValuename = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); |
| aBootstrap.getFrom( suValuename, suGetname ); |
| printUString( suGetname ); |
| ASSERT_TRUE(suGetname.getLength() != 0) << "get the value of a variable in ini file."; |
| } |
| |
| //use default value |
| TEST_F(getFrom, getFrom_003) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname ); |
| rtl::OUString suGetname; |
| rtl::OUString suValuename = rtl::OUString::createFromAscii( "MY_VALUE" ); |
| rtl::OUString myDefault = rtl::OUString::createFromAscii( "2" ); |
| aBootstrap.getFrom( suValuename, suGetname, myDefault ); |
| //printUString( suGetname ); |
| ASSERT_TRUE(suGetname.compareTo( myDefault ) == 0) << "getFrom use default."; |
| } |
| |
| TEST_F(getFrom, getFrom_004) |
| { |
| printf("1\n"); |
| // initialise Bootstrap with an own ini file |
| // PSEUDO_INI is pseudo(rc|.ini) created be create_pseudorc() |
| rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); |
| Bootstrap aBootstrap( suIniname ); |
| |
| rtl::OUString suGetIniName; |
| aBootstrap.getIniName( suGetIniName ); |
| |
| printUString(suGetIniName, "Current bootstrap file"); |
| sal_Int32 nIndex = suGetIniName.indexOf(rtl::OUString::createFromAscii( "pseudo" )); |
| ASSERT_TRUE(nIndex > 0) << "ini name must have 'pseudo' in name."; |
| |
| // rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); |
| // ASSERT_TRUE(bsHandle != 0) << "getHandle return NULL!"; |
| |
| rtl::OUString suValue; |
| rtl::OUString suKeyName = rtl::OUString::createFromAscii( "FILE" ); |
| aBootstrap.getFrom( suKeyName, suValue ); |
| printUString( suValue ); |
| sal_Int32 nCompare = suValue.compareTo( rtl::OUString::createFromAscii("pseudo file") ); |
| |
| ASSERT_TRUE(nCompare == 0) |
| << "<Bootstrap('pseudo')>.getFrom('FILE', ...) result is unexpected."; |
| } |
| |
| TEST_F(getFrom, getFrom_004_1) |
| { |
| // get the same key out of the default context |
| rtl::OUString suKeyName = rtl::OUString::createFromAscii( "FILE" ); |
| rtl::OUString suGetValue; |
| Bootstrap::get( suKeyName, suGetValue ); |
| printUString( suGetValue ); |
| |
| ASSERT_TRUE(suGetValue.compareTo( rtl::OUString::createFromAscii("testshl2 file") ) == 0) |
| << "Bootstrap::get('FILE', ...)"; |
| } |
| |
| TEST_F(getFrom, getFrom_005_1) |
| { |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "1" ); |
| ASSERT_TRUE(nExitCode == 10) << "Parameters passed by command line can not be gotten!"; |
| } |
| TEST_F(getFrom, getFrom_005_2) |
| { |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "2" ); |
| ASSERT_TRUE(nExitCode == 20) << "Parameters passed by .ini/rc file can not be gotten!"; |
| } |
| TEST_F(getFrom, getFrom_005_3) |
| { |
| #if (defined WNT) || (defined SOLARIS) |
| putenv(const_cast< char * >("QADEV_BOOTSTRAP=sun&ms")); |
| #else |
| setenv("QADEV_BOOTSTRAP", "sun&ms", 0); |
| #endif |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "3" ); |
| ASSERT_TRUE(nExitCode == 30) << "Parameters passed by environment variables can not be gotten!"; |
| } |
| TEST_F(getFrom, getFrom_005_4) |
| { |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "4" ); |
| ASSERT_TRUE(nExitCode == 40) << "Parameters passed by customed .ini/rc file can not be gotten!"; |
| } |
| TEST_F(getFrom, getFrom_005_5) |
| { |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "5" ); |
| ASSERT_TRUE(nExitCode == 50) << "Parameters passed by inheritance can not be gotten!"; |
| } |
| TEST_F(getFrom, getFrom_005_6) |
| { |
| oslProcessExitCode nExitCode = ini_execProcess( "bootstrap_process", "6" ); |
| ASSERT_TRUE(nExitCode == 60) << "Parameters passed by default can not be gotten!"; |
| } |
| |
| class setIniFilename : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class setIniFilename |
| |
| TEST_F(setIniFilename, setIniFilename_001) |
| { |
| Bootstrap aBootstrap; |
| |
| rtl::OUString suGetIniname; |
| aBootstrap.getIniName( suGetIniname ); |
| //which should be .....testshl2rc |
| //printUString( suGetIniname ); |
| |
| rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); |
| Bootstrap::setIniFilename( suIniname ); |
| |
| rtl::OUString suGetname; |
| aBootstrap.getIniName( suGetname ); |
| |
| printUString( suGetname ); |
| ASSERT_TRUE(suGetname.compareTo( suIniname ) == 0 |
| && suGetname.compareTo( suGetIniname ) != 0) << "setIniFilename then get it."; |
| } |
| |
| TEST_F(setIniFilename, setIniFilename_002) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| // ASSERT_TRUE(t_fileExist(suIniname ) == true) << |
| // "test failed, Bootstrap ini does not exist." |
| |
| Bootstrap::setIniFilename( suIniname ); |
| //rtl_bootstrap_args_open( suIniname.pData ); |
| rtl::OUString suGetname; |
| rtl::OUString suValuename = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); |
| //aBootstrap.getFrom( suValuename, suGetname ); |
| Bootstrap::get( suValuename, suGetname ); |
| printUString( suGetname ); |
| ASSERT_TRUE(suGetname.getLength() != 0) << "setIniFilename and get value of the argument."; |
| } |
| |
| class getHandle : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class getHandle |
| |
| TEST_F(getHandle, getHandle_001) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap; |
| rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); |
| ASSERT_TRUE(bsHandle == 0) << "getHandle should return 0 if the bootstrap has no ini file!"; |
| } |
| TEST_F(getHandle, getHandle_002) |
| { |
| rtl::OUString suIniname = t_getSourcePath(PSEUDO_INI); |
| Bootstrap aBootstrap( suIniname ); |
| |
| rtlBootstrapHandle bsHandle = aBootstrap.getHandle(); |
| ASSERT_TRUE(bsHandle != 0) << "getHandle return NULL!"; |
| |
| //rtl::OUString iniName; |
| //rtl_bootstrap_get_iniName_from_handle( bsHandle, &iniName.pData ); |
| |
| rtl::OUString suValue; |
| rtl::OUString suKeyName = rtl::OUString::createFromAscii( "PSEUDOFILE" ); |
| rtl_bootstrap_get_from_handle(bsHandle, suKeyName.pData, &suValue.pData, NULL); |
| printUString( suValue); |
| |
| ASSERT_TRUE(suValue.equals( rtl::OUString::createFromAscii("be pseudo") ) == sal_True) << "Can not use the handle which is returned by getHandle!"; |
| |
| // ASSERT_TRUE(// suGetname.equalsIgnoreAsciiCase( iniName ) == sal_True) << "Can not use the handle which is returned by getHandle!"; |
| } |
| |
| class set : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class set |
| |
| TEST_F(set, set_001) |
| { |
| //in ini fle, INHERITED_VALUE=inherited_value |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname); |
| rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); |
| rtl::OUString suValue = rtl::OUString::createFromAscii( "ok" ); |
| // set to another value |
| Bootstrap::set( suName, suValue ); |
| rtl::OUString suGetValue; |
| Bootstrap::get( suName, suGetValue); |
| ASSERT_TRUE(suGetValue.compareTo(suValue) == 0) << "set and get argument failed."; |
| } |
| TEST_F(set, set_002) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap myBootstrap( suIniname); |
| rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); |
| rtl::OUString suGetOrientValue; |
| Bootstrap::get( suName, suGetOrientValue); |
| // ?? INHERITED_VALUE = ok now, which is set in set_001 |
| printUString( suGetOrientValue ); |
| |
| rtl::OUString suValue = rtl::OUString::createFromAscii( TESTSHL2_INI ); |
| // set to another value |
| Bootstrap::set( suName, suValue ); |
| rtl::OUString suGetValue; |
| Bootstrap::get( suName, suGetValue); |
| ASSERT_TRUE(suGetValue.compareTo(suValue) == 0) << "set and get argument failed."; |
| } |
| |
| class expandMacrosFrom : public ::testing::Test |
| { |
| public: |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class expandMacrosFrom |
| |
| TEST_F(expandMacrosFrom, expandMacrosFrom_001) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname); |
| rtl::OUString suMacro = rtl::OUString::createFromAscii( "$MYVAR/expand1" ); |
| //printUString( suMacro ); |
| //expandMacro now |
| aBootstrap.expandMacrosFrom( suMacro ); |
| rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "src680_test/expand1" ); |
| //printUString( suMacro ); |
| ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0) << "expandMacrosFrom failed."; |
| } |
| |
| /** here a special macro should expand |
| * if rtlrc is under sal/qa/rtl/bootstrap/, "${rtlrc:Bootstrap:RTLVALUE}" could be expanded |
| * else rtlrc is under solver/680/unxlngi4.pro/bin/, "${file:/// ....solver/680/unxlngi4.pro/bin/rtlrc:Bootstrap:RTLVALUE}" |
| * could not be expanded |
| */ |
| TEST_F(expandMacrosFrom, expandMacrosFrom_002) |
| { |
| // Build a string with '${rtl.ini:RTLVALUE}' and try to expand it. |
| // In function 'create_rtlrc() is the content of the rtl.ini file. |
| |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| printf("inifile is:"); |
| printUString( suIniname ); |
| Bootstrap aBootstrap( suIniname) ; |
| rtl::OUString suMacro = rtl::OUString::createFromAscii( "${" ); //rtlrc:Bootstrap:RTLVALUE}"); |
| |
| rtl::OUString aDirURL = OUString::createFromAscii( "$ORIGIN"); |
| aDirURL += OUString::createFromAscii( "/"); |
| aDirURL += OUString::createFromAscii( "rtl" ); |
| #if defined(WNT) || defined(OS2) |
| aDirURL += rtl::OUString::createFromAscii(".ini"); |
| #else |
| aDirURL += rtl::OUString::createFromAscii("rc"); |
| #endif |
| |
| suMacro += aDirURL;//t_getSourcePath("rtl"); |
| suMacro += rtl::OUString::createFromAscii( "::RTLVALUE}"); |
| |
| printf("created macro is: "); |
| printUString( suMacro ); |
| //expandMacro now |
| aBootstrap.expandMacrosFrom( suMacro ); |
| printf("expanded macro is:"); |
| printUString( suMacro ); |
| rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "qadev17" ); |
| ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0 ) |
| << "failed, can't expand '${file:///.../" SAL_CONFIGFILE("rtl") "::RTLVALUE}' to 'qadev17'"; |
| } |
| TEST_F(expandMacrosFrom, expandMacrosFrom_002_1) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| printf("inifile is:"); |
| printUString( suIniname ); |
| Bootstrap aBootstrap( suIniname); |
| |
| rtl::OUString suMacro; |
| // just a simple test, if this really work. |
| aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE2" ), suMacro ); |
| printf("SOFROMVALUE2:"); |
| printUString( suMacro ); |
| ASSERT_TRUE(suMacro.getLength() > 0) << "'SOFROMVALUE2' seems to do not exist."; |
| |
| aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE" ), suMacro ); |
| |
| printf("SOFROMVALUE:"); |
| printUString( suMacro ); |
| |
| //expandMacro now |
| // seems to be, that getFrom() already expand the string |
| // printf("expanded macro is:"); |
| // aBootstrap.expandMacrosFrom( suMacro ); |
| // printUString( suMacro ); |
| rtl::OUString suExpectedMacro = rtl::OUString::createFromAscii( "src680_qadev" ); |
| ASSERT_TRUE(suMacro.compareTo(suExpectedMacro) == 0) |
| << "failed, can't expand '${" SAL_CONFIGFILE("rtl") "::SOVALUE}' to 'src680_qadev'"; |
| } |
| TEST_F(expandMacrosFrom, expandMacrosFrom_002_2) |
| { |
| // test, to read and expand SOFROMVALUE3 |
| // SOFROMVALUE3 is 'rtl(.ini|rc)::TESTSHL_SOVALUE' which should expand to 'rtlfile' if all is ok. |
| |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| printf("inifile is:"); |
| printUString( suIniname ); |
| Bootstrap aBootstrap( suIniname); |
| |
| rtl::OUString suMacro; |
| aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE3" ), suMacro ); |
| |
| printf("SOFROMVALUE3:"); |
| printUString( suMacro ); |
| |
| if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file") ) == sal_True) |
| { |
| ASSERT_TRUE(0) << "Value 'SOFROMVALUE3' is read from the wrong ini file."; |
| } |
| else |
| { |
| ASSERT_TRUE(suMacro.equals(rtl::OUString::createFromAscii("rtlfile") ) == sal_True) << "SOFROMVALUE3 should contain 'rtlfile'."; |
| } |
| } |
| //? I don't know if this is a right test. |
| // void expandMacrosFrom_002_3() |
| // { |
| // // test, to read and expand SOFROMVALUE4 |
| // // SOFROMVALUE4 is 'rtl(.ini|rc):Other_Section:TESTSHL_SOVALUE' which should expand to '' if all is ok. |
| // |
| // rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| // printf("inifile is:"); |
| // printUString( suIniname ); |
| // Bootstrap aBootstrap( suIniname); |
| // |
| // rtl::OUString suMacro; |
| // aBootstrap.getFrom(rtl::OUString::createFromAscii( "SOFROMVALUE4" ), suMacro ); |
| // |
| // printf("SOFROMVALUE4:"); |
| // printUString( suMacro ); |
| // |
| // if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file") ) == sal_True) |
| // { |
| // ASSERT_TRUE(0) << "Value 'SOFROMVALUE4' is read from the wrong section out of the wrong ini file."; |
| // } |
| // else if (suMacro.equals(rtl::OUString::createFromAscii("testshl2_file_other") ) == sal_True) |
| // { |
| // ASSERT_TRUE(0) << "Value 'SOFROMVALUE4' is read from the wrong ini file."; |
| // } |
| // else |
| // { |
| // ASSERT_TRUE(suMacro.equals(rtl::OUString::createFromAscii("rtlfile_other") ) == sal_True) << "Value 'SOFROMVALUE4' should contain 'rtlfile_other'."; |
| // } |
| // } |
| TEST_F(expandMacrosFrom, expandMacrosFrom_003) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname); |
| rtl::OUString suMacro[4]; |
| suMacro[0] = rtl::OUString::createFromAscii( "$SYSUSERCONFIG" ); |
| suMacro[1] = rtl::OUString::createFromAscii( "$SYSUSERHOME" ); |
| suMacro[2] = rtl::OUString::createFromAscii( "$SYSBINDIR" ); |
| suMacro[3] = rtl::OUString::createFromAscii( "$ORIGIN" ); |
| |
| for ( int i = 0; i < 4; i++ ) |
| { |
| aBootstrap.expandMacrosFrom( suMacro[i] ); |
| printUString(suMacro[i]); |
| } |
| // printUString( t_getSourcePath("") ); |
| // ASSERT_TRUE(suMacro[3].equalsIgnoreAsciiCase(t_getSourcePath("")) == sal_True) << "some integral variables."; |
| ASSERT_TRUE(suMacro[0].getLength() > 0 && |
| suMacro[1].getLength() > 0 && |
| suMacro[2].getLength() > 0 && |
| suMacro[3].getLength() > 0) << "some integral variables."; |
| } |
| |
| TEST_F(expandMacrosFrom, testRecursion) { |
| rtl::OUString t(RTL_CONSTASCII_USTRINGPARAM("$RECURSIVE")); |
| Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); |
| ASSERT_TRUE(t.equalsAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("***RECURSION DETECTED***"))) << "recursion detection"; |
| } |
| |
| TEST_F(expandMacrosFrom, testLink) { |
| rtl::OUString t(RTL_CONSTASCII_USTRINGPARAM("$LINKED")); |
| Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); |
| ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("qadev17"))) << "link file"; |
| } |
| |
| TEST_F(expandMacrosFrom, testOverride) { |
| rtl::OUString t1( |
| RTL_CONSTASCII_USTRINGPARAM( |
| "${.override:$ORIGIN/" SAL_CONFIGFILE("rtl") ":ORIGIN}")); |
| Bootstrap(t_getSourcePath("rtl")).expandMacrosFrom(t1); |
| ASSERT_TRUE(t1.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("direct"))) << "override ORIGIN"; |
| rtl::OUString t2( |
| RTL_CONSTASCII_USTRINGPARAM( |
| "${.override:$ORIGIN/" SAL_CONFIGFILE("none") ":MYVAR}")); |
| Bootstrap::expandMacros(t2); |
| ASSERT_TRUE(t2.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("src680_test"))) << "override MYVAR"; |
| } |
| |
| TEST_F(expandMacrosFrom, testNonexisting) { |
| rtl::OUString t( |
| RTL_CONSTASCII_USTRINGPARAM( |
| "${$ORIGIN/" SAL_CONFIGFILE("none") ":MYVAR}")); |
| Bootstrap::expandMacros(t); |
| ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("src680_test"))) << "nonexisting"; |
| } |
| |
| TEST_F(expandMacrosFrom, testSection) { |
| rtl::OUStringBuffer b; |
| b.appendAscii(RTL_CONSTASCII_STRINGPARAM("${")); |
| rtl::OUString p(t_getSourcePath(TESTSHL2_INI)); |
| for (sal_Int32 i = 0; i < p.getLength(); ++i) { |
| if (p[i] != 'u') { |
| b.append(static_cast< sal_Unicode >('\\')); |
| } |
| b.append(p[i]); |
| } |
| b.appendAscii(RTL_CONSTASCII_STRINGPARAM(":Other_Section:EXPAND}")); |
| rtl::OUString t(b.makeStringAndClear()); |
| Bootstrap(t_getSourcePath(TESTSHL2_INI)).expandMacrosFrom(t); |
| ASSERT_TRUE(t.equalsAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("$FILE"))) << "section expansion"; |
| // the correct answer would be "testshl2 file" instead, but |
| // expansion including a section currently erroneously does not |
| // recursively expand macros in the resulting replacement text |
| } |
| |
| class expandMacros : public ::testing::Test |
| { |
| public: |
| // initialise your test code values here. |
| void SetUp() |
| { |
| } |
| |
| void TearDown() |
| { |
| } |
| }; // class expandMacros |
| |
| |
| TEST_F(expandMacros, expandMacros_001) |
| { |
| rtl::OUString suIniname = t_getSourcePath(TESTSHL2_INI); |
| Bootstrap aBootstrap( suIniname) ; |
| rtl::OUString suMacro = rtl::OUString::createFromAscii( "$INHERITED_VALUE/well" ); |
| Bootstrap::expandMacros( suMacro ); |
| |
| rtl::OUString suName = rtl::OUString::createFromAscii( "INHERITED_VALUE" ); |
| OUString suGetValue; |
| Bootstrap::get( suName, suGetValue ); |
| suGetValue += OUString::createFromAscii( "/well" ); |
| ASSERT_TRUE(suGetValue.compareTo(suMacro) == 0) << "expandMacros failed."; |
| } |
| } // namespace rtl_Bootstrap |
| |
| // ----------------------------------------------------------------------------- |
| |
| // this macro creates an empty function, which will called by the RegisterAllFunctions() |
| // to let the user the possibility to also register some functions by hand. |
| // NOADDITIONAL; |
| |
| |
| // Here are some helpers, which create a new file 'rtlrc' at the executable path position |
| // and fill the file with some information. |
| // static rtl::OUString getExecutableDirectory() |
| // { |
| // rtl::OUString fileName; |
| // osl_getExecutableFile(&fileName.pData); |
| // |
| // sal_Int32 nDirEnd = fileName.lastIndexOf('/'); |
| // |
| // OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory"); |
| // |
| // rtl::OUString aDirURL = fileName.copy(0, nDirEnd); |
| // return aDirURL; |
| // } |
| |
| static void removeAndCreateFile(rtl::OUString const& _suFileURL, rtl::OString const& _sContent) |
| { |
| osl::File::remove(_suFileURL); |
| |
| ::std::auto_ptr<osl::File> pFile( new osl::File( _suFileURL ) ); |
| ::osl::FileBase::RC nError = pFile->open( OpenFlag_Write | OpenFlag_Create ); |
| if ( ::osl::FileBase::E_None == nError || ::osl::FileBase::E_EXIST == nError ) |
| { |
| printf("%s\n" , OString(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); |
| sal_uInt64 nWritenBytes; |
| pFile->write(_sContent.getStr(), _sContent.getLength(), nWritenBytes); |
| // printf("nBytes: %ld\n", nBytes); |
| |
| rtl::OString sError = "can't write enough bytes to file"; |
| sError += OString(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US); |
| OSL_ENSURE(nWritenBytes == _sContent.getLength(), sError.getStr()); |
| |
| pFile->close(); |
| } |
| else |
| { |
| rtl::OString sError = "can't create file URL: '"; |
| rtl::OString sFile(_suFileURL.getStr(), _suFileURL.getLength(), RTL_TEXTENCODING_ASCII_US); |
| sError += sFile; |
| 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."; |
| printf("%s\n", sError.getStr() ); |
| exit(1); |
| } |
| OSL_ASSERT(t_fileExist(_suFileURL) == true); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| static void create_rtlrc() |
| { |
| rtl::OUString aFileURL(getExecutableDirectory()); |
| #if defined(WNT) || defined(OS2) |
| aFileURL += rtl::OUString::createFromAscii("/rtl.ini"); |
| #else |
| aFileURL += rtl::OUString::createFromAscii("/rtlrc"); |
| #endif |
| |
| rtl::OString sLines; |
| sLines += "[Bootstrap]\n"; |
| sLines += "SOVALUE=src680_qadev\n"; |
| sLines += "RTLVALUE=qadev17\n"; |
| sLines += "TESTSHL_SOVALUE=rtlfile\n"; |
| sLines += "RECURSIVE=${$ORIGIN/" SAL_CONFIGFILE("testshl2") ":RECURSIVE}\n"; |
| sLines += "ORIGIN=direct\n"; |
| sLines += "[Other_Section]\n"; |
| sLines += "TESTSHL_SOVALUE=rtlfile_other\n"; |
| |
| removeAndCreateFile(aFileURL, sLines); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| static void create_testshl2rc() |
| { |
| rtl::OUString aFileURL(getExecutableDirectory()); |
| #if defined(WNT) || defined(OS2) |
| aFileURL += rtl::OUString::createFromAscii("/testshl2.ini"); |
| #else |
| aFileURL += rtl::OUString::createFromAscii("/testshl2rc"); |
| #endif |
| rtl::OString sLines; |
| sLines += "[Bootstrap]\n"; |
| sLines += "FILE=testshl2 file\n"; |
| sLines += "MYBOOTSTRAPTESTVALUE=file\n"; |
| sLines += "INHERITED_VALUE=inherited_value\n"; |
| sLines += "INHERITED_OVERWRITTEN_VALUE=not_overwritten\n"; |
| sLines += "MYVAR=src680_test\n"; |
| sLines += "SOFROMVALUE=${$ORIGIN/" SAL_CONFIGFILE("rtl") "::SOVALUE}\n"; |
| sLines += "SOFROMVALUE2=test\n"; |
| sLines += "SOFROMVALUE3=${$ORIGIN/" SAL_CONFIGFILE("rtl") "::TESTSHL_SOVALUE}\n"; |
| sLines += "TESTSHL_SOVALUE=testshl2_file\n"; |
| //? sLines += "SOFROMVALUE4=${" SAL_CONFIGFILE("rtl") ":Other_Section:TESTSHL_SOVALUE}\n"; |
| sLines += "ILLEGAL VALUE=test\n"; |
| sLines += "ILLEGAL.DOT=test\n"; |
| sLines += "ILLEGAL;SEMICOLON=test\n"; |
| sLines += "ILLEGAL:COLON=test\n"; |
| sLines += " KEY_FOR_TRIM_TEST = value for trim test \n"; |
| sLines += "RECURSIVE=${$ORIGIN/" SAL_CONFIGFILE("rtl") ":RECURSIVE}\n"; |
| sLines += "LINKED=${${.link:$ORIGIN/testshl2-link}:RTLVALUE}\n"; |
| sLines += "[Other_Section]\n"; |
| sLines += "FILE=testshl2 file other\n"; |
| sLines += "EXPAND=$FILE\n"; |
| //? sLines += "TESTSHL_SOVALUE=testshl2_file_other\n"; |
| |
| removeAndCreateFile(aFileURL, sLines); |
| |
| removeAndCreateFile( |
| (getExecutableDirectory() + |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/testshl2-link"))), |
| SAL_CONFIGFILE("rtl")); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| static void create_pseudorc() |
| { |
| rtl::OUString aFileURL(getExecutableDirectory()); |
| #if defined(WNT) || defined(OS2) |
| aFileURL += rtl::OUString::createFromAscii("/pseudo.ini"); |
| #else |
| aFileURL += rtl::OUString::createFromAscii("/pseudorc"); |
| #endif |
| rtl::OString sLines; |
| sLines += "[Bootstrap]\n"; |
| sLines += "FILE=pseudo file\n"; |
| sLines += "PSEUDOFILE=be pseudo\n"; |
| |
| removeAndCreateFile(aFileURL, sLines); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void create_bootstrap_processrc() |
| { |
| rtl::OUString aDirURL(getModulePath()); |
| #if defined(WNT) || defined(OS2) |
| aDirURL += rtl::OUString::createFromAscii("/bootstrap_process.ini"); |
| #else |
| aDirURL += rtl::OUString::createFromAscii("/bootstrap_processrc"); |
| #endif |
| rtl::OString sLines; |
| sLines += "[Bootstrap]\n"; |
| sLines += "EXECUTABLE_RC=true\n"; |
| sLines += "IF_CUSTOM_RC=false\n"; |
| |
| removeAndCreateFile(aDirURL, sLines); |
| } |
| // ----------------------------------------------------------------------------- |
| |
| |
| int main(int argc, char **argv) |
| { |
| // start message |
| printf("Initializing ...\n" ); |
| osl_setCommandArgs(argc, argv); |
| create_rtlrc(); |
| create_testshl2rc(); |
| create_pseudorc(); |
| create_bootstrap_processrc(); |
| |
| printf("Initialization Done.\n" ); |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
