/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  TimerServerJavaTime

*

*/

#include "TestHarness.h"

#include <sys/time.h>

#include <time.h>

#include "commsclientendpoint.h"

#include "commslistener.h"

#include "comms.h"

#include "monitor.h"

#include "testmessages.h"

#include "timerserverhelpers.h"

using namespace java::comms;

using namespace java::captain;

using namespace java::util;

extern java::comms::CommsClientEndpoint* commsClient;

static Monitor* monitor1;

static Monitor* monitor2;

static int      timerId;

class JavaTime

{

public:

    JavaTime():mMillisFromEpoch(0LL) {}

    JavaTime(const long long& aTime):mMillisFromEpoch(aTime) {}

    JavaTime(const JavaTime& aJt):mMillisFromEpoch(aJt.getTime()) {}

    JavaTime& operator= (const JavaTime& aJt)

    {

        mMillisFromEpoch = aJt.getTime();

        return *this;

    }

    const long long& operator+ (const long long& a)

    {

        return (this->mMillisFromEpoch += a);

    }

    virtual ~JavaTime() {}

    virtual long long getTime() const

    {

        return mMillisFromEpoch;

    }

    virtual void setTime(const long long& aNewTime)

    {

        mMillisFromEpoch = aNewTime;

    }

private:

    long long mMillisFromEpoch;

};

long long getCurrentJavaTime()

{

    timeval tim;

    int err = gettimeofday(&tim, NULL);

    if (-1 == err)

    {

        return -1LL;

    }

    return (tim.tv_sec * 1000LL) +

           (tim.tv_usec / 1000LL);

}

TEST_GROUP(TimerServerJavaTime)

{

    tsCommsListener* tsListener;

    TEST_SETUP()

    {

        monitor1 = Monitor::createMonitor();

        monitor2 = Monitor::createMonitor();

        tsListener = new tsCommsListener(monitor1, monitor2, timerId);

        commsClient->registerDefaultListener(tsListener);

    }

    TEST_TEARDOWN()

    {

        commsClient->unregisterDefaultListener(tsListener);

        delete tsListener;

        delete monitor2;

        delete monitor1;

    }

};

static void omaEquals(int& a, int&b)

{

    if (a != b)

        printf("Comparing 0x%x == 0x%x fails!!!\n", a, b);

    CHECK(a == b);

}

/*

TEST(TimerServerJavaTime, TS10_STOP)

{

    int timerId = 0;

    startTimer(timerId, 10);

    stopTimer(timerId);

}

TEST(TimerServerJavaTime, TS09_3_timers_a2_b2_c2_seconds_c_canceled)

{

    int tid1=0, tid2=0, tid3=0;

    startTimer(tid1, 2);

    startTimer(tid2, 2);

    startTimer(tid3, 2);

    stopTimer(tid3);

    monitor->wait();

    CHECK(receivedTimeout==tid2 || receivedTimeout==tid1);

    monitor2->notify();

    monitor->wait();

    CHECK(receivedTimeout==tid2 || receivedTimeout==tid1);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TS08_3_timers_a1_b2_c3_seconds_b_canceled)

{   int tid1=0, tid2=0, tid3=0;

    startTimer(tid1, 1);

    startTimer(tid2, 2);

    stopTimer(tid2);

    startTimer(tid3, 3);

    monitor->wait();

    CHECK(receivedTimeout==tid1 || receivedTimeout==tid3);

    monitor2->notify();

    monitor->wait();

    CHECK(receivedTimeout==tid1 || receivedTimeout==tid3);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TS07_3_timers_a3_b2_c1_seconds_a_canceled)

{

    int tid1=0, tid2=0, tid3=0;

    startTimer(tid1, 3);

    startTimer(tid2, 2);

    stopTimer(tid1);

    startTimer(tid3, 1);

    monitor->wait();

    CHECK(receivedTimeout==tid2 || receivedTimeout==tid3);

    monitor2->notify();

    monitor->wait();

    CHECK(receivedTimeout==tid2 || receivedTimeout==tid3);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TS06_3_timers_2_1_2_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startTimer(tid1, 2);

    startTimer(tid2, 1);

    startTimer(tid3, 2);

    monitor->wait();

    omaEquals(tid2, receivedTimeout);

//    CHECK(tid2 == receivedTimeout);

    monitor2->notify();

    monitor->wait();

    CHECK(receivedTimeout==tid1 || receivedTimeout==tid3);

    monitor2->notify();

    monitor->wait();

    CHECK(receivedTimeout==tid1 || receivedTimeout==tid3);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TS05_3_timers_1_2_3_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startTimer(tid1, 1);

    startTimer(tid2, 2);

    startTimer(tid3, 3);

    monitor->wait();

    omaEquals(tid1, receivedTimeout);

//    CHECK(tid1 == receivedTimeout);

    monitor2->notify();

    monitor->wait();

    omaEquals(tid2, receivedTimeout);

//    CHECK(tid2 == receivedTimeout);

    monitor2->notify();

    monitor->wait();

    omaEquals(tid3, receivedTimeout);

//    CHECK(tid3 == receivedTimeout);

    monitor2->notify();

}

*/

TEST(TimerServerJavaTime, TSJT02_01_3_timers_2_1_2_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(1L * 1000L)).getTime());

    startJavaTimeTimer(tid3, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    monitor1->wait();

    CHECK(tid2 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid1 == timerId || tid3 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid1 == timerId || tid3 == timerId);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT02_02_3_timers_1_2_3_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(1L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid3, JavaTime(getCurrentJavaTime()+(3L * 1000L)).getTime());

    monitor1->wait();

    CHECK(tid1 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid2 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid3 == timerId);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT02_01_3_timers_3_2_1_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(3L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid3, JavaTime(getCurrentJavaTime()+(1L * 1000L)).getTime());

    monitor1->wait();

    CHECK(tid3 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid2 == timerId);

    monitor2->notify();

    monitor1->wait();

    CHECK(tid1 == timerId);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT01_05_5_timers_2_2_2_2_2_seconds)

{

    int tid1=0, tid2=0, tid3=0, tid4=0, tid5=0;

    JavaTime jt(getCurrentJavaTime()+(2L * 1000L));

    startJavaTimeTimer(tid1, jt.getTime());

    startJavaTimeTimer(tid2, jt.getTime());

    startJavaTimeTimer(tid3, jt.getTime());

    startJavaTimeTimer(tid4, jt.getTime());

    startJavaTimeTimer(tid5, jt.getTime());

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4 || timerId==tid5);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4 || timerId==tid5);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4 || timerId==tid5);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4 || timerId==tid5);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4 || timerId==tid5);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT01_04_4_timers_2_2_2_2_seconds)

{

    int tid1=0, tid2=0, tid3=0, tid4=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(1900L)).getTime());

    startJavaTimeTimer(tid3, JavaTime(getCurrentJavaTime()+(1800L)).getTime());

    startJavaTimeTimer(tid4, JavaTime(getCurrentJavaTime()+(1700L)).getTime());

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3 || timerId==tid4);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT01_03_3_timers_2_2_2_seconds)

{

    int tid1=0, tid2=0, tid3=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid3, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2 || timerId==tid3);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT01_02_2_timers_2_2_seconds)

{

    int tid1=0, tid2=0;

    startJavaTimeTimer(tid1, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    startJavaTimeTimer(tid2, JavaTime(getCurrentJavaTime()+(2L * 1000L)).getTime());

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2);

    monitor2->notify();

    monitor1->wait();

    CHECK(timerId==tid1 || timerId==tid2);

    monitor2->notify();

}

TEST(TimerServerJavaTime, TSJT01_01_1_timer_2_seconds)

{

    int tid = 0;

    JavaTime jt(getCurrentJavaTime() + (2L * 1000L));

    startJavaTimeTimer(tid, jt.getTime());

    monitor1->wait();

//    CHECK(tid == receivedTimeout);

    omaEquals(tid, timerId);

    monitor2->notify();

}