/************************************************************** * * 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" // This is a test of helperfunctions #include #include #include "stringhelper.hxx" #include "gtest/gtest.h" // void isJaBloed() // { // printf("Ist ja echt bloed.\n"); // } inline sal_Int64 t_abs64(sal_Int64 _nValue) { // std::abs() seems to have some ambiguity problems (so-texas) // return abs(_nValue); printf("t_abs64(%ld)\n", _nValue); // ASSERT_TRUE(_nValue < 2147483647); if (_nValue < 0) { _nValue = -_nValue; } return _nValue; } void printf64(sal_Int64 n) { if (n < 0) { // negativ printf("-"); n = -n; } if (n > 2147483647) { sal_Int64 n64 = n >> 32; sal_uInt32 n32 = n64 & 0xffffffff; printf("0x%.8x ", n32); n32 = n & 0xffffffff; printf("%.8x (64bit)", n32); } else { sal_uInt32 n32 = n & 0xffffffff; printf("0x%.8x (32bit) ", n32); } printf("\n"); } // ----------------------------------------------------------------------------- namespace testOfHelperFunctions { class test_t_abs64 : public ::testing::Test { }; TEST_F(test_t_abs64, test0) { // this values has an overrun! sal_Int32 n32 = 2147483648; printf("n32 should be -2^31 is: %d\n", n32); ASSERT_TRUE(n32 == -2147483648 ) << "n32!=2147483648"; } TEST_F(test_t_abs64,test1_0) { sal_Int64 n; n = 1073741824; n <<= 9; printf("Value of n is "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=2^30 << 9"; } TEST_F(test_t_abs64, test1) { sal_Int64 n; n = 2147483648 << 8; printf("Value of n is "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=2^31 << 8"; } TEST_F(test_t_abs64, test1_1) { sal_Int64 n; n = sal_Int64(2147483648) << 8; printf("Value of n is "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=2^31 << 8"; } TEST_F(test_t_abs64, test2) { sal_Int64 n; n = 2147483648 << 1; printf("Value of n is "); printf64(n); ASSERT_TRUE(n != 0) << "(2147483648 << 1) is != 0"; sal_Int64 n2 = 2147483648 * 2; ASSERT_TRUE(n2 != 0) << "2147483648 * 2 is != 0"; sal_Int64 n3 = 4294967296LL; ASSERT_TRUE(n3 != 0) << "4294967296 is != 0"; ASSERT_TRUE(n == n2 && n == n3) << "n=2^31 << 1, n2 = 2^31 * 2, n3 = 2^32, all should equal!"; } TEST_F(test_t_abs64, test3) { sal_Int64 n = 0; ASSERT_TRUE(t_abs64(n) == 0) << "n=0"; n = 1; ASSERT_TRUE(t_abs64(n) > 0) << "n=1"; n = 2147483647; ASSERT_TRUE(t_abs64(n) > 0) << "n=2^31 - 1"; n = 2147483648; ASSERT_TRUE(t_abs64(n) > 0) << "n=2^31"; } TEST_F(test_t_abs64, test4) { sal_Int64 n = 0; n = -1; printf("Value of n is -1 : "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=-1"; n = -2147483648; printf("Value of n is -2^31 : "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=-2^31"; n = -8589934592LL; printf("Value of n is -2^33 : "); printf64(n); ASSERT_TRUE(t_abs64(n) > 0) << "n=-2^33"; } // ----------------------------------------------------------------------------- class test_printf : public ::testing::Test { }; TEST_F(test_printf, printf_001) { printf("This is only a test of some helper functions\n"); sal_Int32 nValue = 12345; printf("a value %d (should be 12345)\n", nValue); rtl::OString sValue("foo bar"); printf("a String '%s' (should be 'foo bar')\n", sValue.getStr()); rtl::OUString suValue(rtl::OUString::createFromAscii("a unicode string")); sValue <<= suValue; printf("a String '%s'\n", sValue.getStr()); } class StopWatch { protected: TimeValue m_aStartTime; TimeValue m_aEndTime; bool m_bStarted; public: StopWatch() :m_bStarted(false) { } void start() { m_bStarted = true; osl_getSystemTime(&m_aStartTime); } void stop() { osl_getSystemTime(&m_aEndTime); OSL_ENSURE(m_bStarted, "Not Started."); m_bStarted = false; } rtl::OString makeTwoDigits(rtl::OString const& _sStr) { rtl::OString sBack; if (_sStr.getLength() == 0) { sBack = "00"; } else { if (_sStr.getLength() == 1) { sBack = "0" + _sStr; } else { sBack = _sStr; } } return sBack; } rtl::OString makeThreeDigits(rtl::OString const& _sStr) { rtl::OString sBack; if (_sStr.getLength() == 0) { sBack = "000"; } else { if (_sStr.getLength() == 1) { sBack = "00" + _sStr; } else { if (_sStr.getLength() == 2) { sBack = "0" + _sStr; } else { sBack = _sStr; } } } return sBack; } void showTime(const rtl::OString & aWhatStr) { OSL_ENSURE(!m_bStarted, "Not Stopped."); sal_Int32 nSeconds = m_aEndTime.Seconds - m_aStartTime.Seconds; sal_Int32 nNanoSec = sal_Int32(m_aEndTime.Nanosec) - sal_Int32(m_aStartTime.Nanosec); // printf("Seconds: %d Nanosec: %d ", nSeconds, nNanoSec); if (nNanoSec < 0) { nNanoSec = 1000000000 + nNanoSec; nSeconds--; // printf(" NEW Seconds: %d Nanosec: %d\n", nSeconds, nNanoSec); } rtl::OString aStr = "Time for "; aStr += aWhatStr; aStr += " "; aStr += makeTwoDigits(rtl::OString::valueOf(nSeconds / 3600)); aStr += ":"; aStr += makeTwoDigits(rtl::OString::valueOf((nSeconds % 3600) / 60)); aStr += ":"; aStr += makeTwoDigits(rtl::OString::valueOf((nSeconds % 60))); aStr += ":"; aStr += makeThreeDigits(rtl::OString::valueOf((nNanoSec % 1000000000) / 1000000)); aStr += ":"; aStr += makeThreeDigits(rtl::OString::valueOf((nNanoSec % 1000000) / 1000)); aStr += ":"; aStr += makeThreeDigits(rtl::OString::valueOf((nNanoSec % 1000))); printf("%s\n", aStr.getStr()); // cout << aStr.getStr() << endl; } }; static sal_Bool isEqualTimeValue ( const TimeValue* time1, const TimeValue* time2) { if( time1->Seconds == time2->Seconds && time1->Nanosec == time2->Nanosec) return sal_True; else return sal_False; } static sal_Bool isGreaterTimeValue( const TimeValue* time1, const TimeValue* time2) { sal_Bool retval= sal_False; if ( time1->Seconds > time2->Seconds) retval= sal_True; else if ( time1->Seconds == time2->Seconds) { if( time1->Nanosec > time2->Nanosec) retval= sal_True; } return retval; } static sal_Bool isGreaterEqualTimeValue( const TimeValue* time1, const TimeValue* time2) { if( isEqualTimeValue( time1, time2) ) return sal_True; else if( isGreaterTimeValue( time1, time2)) return sal_True; else return sal_False; } bool isBTimeGreaterATime(TimeValue const& A, TimeValue const& B) { if (B.Seconds > A.Seconds) return true; if (B.Nanosec > A.Nanosec) return true; // lower or equal return false; } // ----------------------------------------------------------------------------- class test_TimeValues : public ::testing::Test { }; TEST_F(test_TimeValues, t_time1) { StopWatch aWatch; aWatch.start(); TimeValue aTimeValue={3,0}; osl::Thread::wait(aTimeValue); aWatch.stop(); aWatch.showTime("Wait for 3 seconds"); } TEST_F(test_TimeValues, t_time2) { printf("Wait repeats 20 times.\n"); int i=0; while(i++<20) { StopWatch aWatch; aWatch.start(); TimeValue aTimeValue={0,1000 * 1000 * 500}; osl::Thread::wait(aTimeValue); aWatch.stop(); aWatch.showTime("wait for 500msec"); } } TEST_F(test_TimeValues, t_time3) { printf("Wait repeats 100 times.\n"); int i=0; while(i++<20) { StopWatch aWatch; aWatch.start(); TimeValue aTimeValue={0,1000*1000*100}; osl::Thread::wait(aTimeValue); aWatch.stop(); aWatch.showTime("wait for 100msec"); } } // void demoTimeValue() // { // TimeValue aStartTime, aEndTime; // osl_getSystemTime(&aStartTime); // // testSession(xORB, false); // osl_getSystemTime(&aEndTime); // // sal_Int32 nSeconds = aEndTime.Seconds - aStartTime.Seconds; // sal_Int32 nNanoSec = aEndTime.Nanosec - aStartTime.Nanosec; // if (nNanoSec < 0) // { // nNanoSec = 1000000000 - nNanoSec; // nSeconds++; // } // // // cout << "Time: " << nSeconds << ". " << nNanoSec << endl; // } } // namespace testOfHelperFunctions int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }