xref: /aoo4110/main/sal/qa/testHelperFunctions/testHelperFunctions.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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 <testshl/simpleheader.hxx>

// void isJaBloed()
// {
//     t_print("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);
    t_print("t_abs64(%ld)\n", _nValue);
    // CPPUNIT_ASSERT(_nValue < 2147483647);

    if (_nValue < 0)
    {
        _nValue = -_nValue;
    }
    return _nValue;
}

void t_print64(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 CppUnit::TestFixture
    {
    public:
        void test0();
        void test1_0();
        void test1();
        void test1_1();
        void test2();
        void test3();
        void test4();

        CPPUNIT_TEST_SUITE( test_t_abs64 );
        CPPUNIT_TEST( test0 );
        CPPUNIT_TEST( test1_0 );
        CPPUNIT_TEST( test1 );
        CPPUNIT_TEST( test1_1 );
        CPPUNIT_TEST( test2 );
        CPPUNIT_TEST( test3 );
        CPPUNIT_TEST( test4 );
        CPPUNIT_TEST_SUITE_END( );
    };

    void test_t_abs64::test0()
    {
        // this values has an overrun!
        sal_Int32 n32 = 2147483648;
        t_print("n32 should be -2^31 is: %d\n", n32);
        CPPUNIT_ASSERT_MESSAGE("n32!=2147483648", n32 == -2147483648 );
    }


    void test_t_abs64::test1_0()
    {
        sal_Int64 n;
        n = 1073741824;
        n <<= 9;
        t_print("Value of n is ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=2^30 << 9", t_abs64(n) > 0 );
    }

    void test_t_abs64::test1()
    {
        sal_Int64 n;
        n = 2147483648 << 8;
        t_print("Value of n is ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=2^31 << 8", t_abs64(n) > 0 );
    }
    void test_t_abs64::test1_1()
    {
        sal_Int64 n;
        n = sal_Int64(2147483648) << 8;
        t_print("Value of n is ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=2^31 << 8", t_abs64(n) > 0 );
    }

    void test_t_abs64::test2()
    {
        sal_Int64 n;
        n = 2147483648 << 1;
        t_print("Value of n is ");
        t_print64(n);

        CPPUNIT_ASSERT_MESSAGE("(2147483648 << 1) is != 0", n != 0 );

        sal_Int64 n2 = 2147483648 * 2;
        CPPUNIT_ASSERT_MESSAGE("2147483648 * 2 is != 0", n2 != 0 );

        sal_Int64 n3 = 4294967296LL;
        CPPUNIT_ASSERT_MESSAGE("4294967296 is != 0", n3 != 0 );

        CPPUNIT_ASSERT_MESSAGE("n=2^31 << 1, n2 = 2^31 * 2, n3 = 2^32, all should equal!", n == n2 && n == n3 );
    }


    void test_t_abs64::test3()
    {
        sal_Int64 n = 0;
        CPPUNIT_ASSERT_MESSAGE("n=0", t_abs64(n) == 0 );

        n = 1;
        CPPUNIT_ASSERT_MESSAGE("n=1", t_abs64(n) > 0 );

        n = 2147483647;
        CPPUNIT_ASSERT_MESSAGE("n=2^31 - 1", t_abs64(n) > 0 );

        n = 2147483648;
        CPPUNIT_ASSERT_MESSAGE("n=2^31", t_abs64(n) > 0 );
    }

    void test_t_abs64::test4()
    {
        sal_Int64 n = 0;
        n = -1;
        t_print("Value of n is -1 : ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=-1", t_abs64(n) > 0 );

        n = -2147483648;
        t_print("Value of n is -2^31 : ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=-2^31", t_abs64(n) > 0 );

        n = -8589934592LL;
        t_print("Value of n is -2^33 : ");
        t_print64(n);
        CPPUNIT_ASSERT_MESSAGE("n=-2^33", t_abs64(n) > 0 );
    }


// -----------------------------------------------------------------------------
    class test_t_print : public CppUnit::TestFixture
    {
    public:
        void t_print_001();

        CPPUNIT_TEST_SUITE( test_t_print );
        CPPUNIT_TEST( t_print_001 );
        CPPUNIT_TEST_SUITE_END( );
    };

    void test_t_print::t_print_001( )
    {
        t_print("This is only a test of some helper functions\n");
        sal_Int32 nValue = 12345;
        t_print("a value %d (should be 12345)\n", nValue);

        rtl::OString sValue("foo bar");
        t_print("a String '%s' (should be 'foo bar')\n", sValue.getStr());

        rtl::OUString suValue(rtl::OUString::createFromAscii("a unicode string"));
        sValue <<= suValue;
        t_print("a String '%s'\n", sValue.getStr());
    }


    class StopWatch
    {
        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 CppUnit::TestFixture
    {
    public:

        void t_time1();
        void t_time2();
        void t_time3();

        CPPUNIT_TEST_SUITE( test_TimeValues );
        CPPUNIT_TEST( t_time1 );
        CPPUNIT_TEST( t_time2 );
        CPPUNIT_TEST( t_time3 );
        CPPUNIT_TEST_SUITE_END( );
    };

void test_TimeValues::t_time1()
{
    StopWatch aWatch;
    aWatch.start();
    TimeValue aTimeValue={3,0};
    osl::Thread::wait(aTimeValue);
    aWatch.stop();
    aWatch.showTime("Wait for 3 seconds");
}

void test_TimeValues::t_time2()
{
    t_print("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");
    }
}

void test_TimeValues::t_time3()
{
    t_print("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

// -----------------------------------------------------------------------------
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( testOfHelperFunctions::test_t_print, "helperFunctions" );
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( testOfHelperFunctions::test_t_abs64, "helperFunctions" );
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( testOfHelperFunctions::test_TimeValues, "helperFunctions" );

// -----------------------------------------------------------------------------
NOADDITIONAL;