xref: /trunk/main/sal/qa/testHelperFunctions/testHelperFunctions.cxx (revision faf81e809c29d65982a2c7451a71a31ffccdc32f)

/**************************************************************
 *
 * 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 <osl/time.h>
#include <osl/thread.hxx>

#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();
}