/*

* Copyright (c) 2009 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:  Tests for Java Debug API

*

*/

#include <memory>

#include <flogger.h>

#include "TestHarness.h"

#include "javadiagnostic.h"

#include "javaredirector.h"

#include "diagnosticimpl.h"

#include "logger.h"

using namespace java::debug;

using namespace java::util;

_LIT8(KText1,"");

_LIT8(KText2," ");

_LIT8(KText3,"\n");

_LIT8(KText4,"hello world\r\n");

_LIT8(KText5,"this is\r\n multiline\r\n example string with\t tabs\r\n");

_LIT8(KText6,"very long string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      indeed\r\n");

_LIT8(KText7,"0123456789abcdefghijklmnopqrstyvwxyz\r\n");

_LIT8(KText8,"*-.,/\"%&()=?\r\n");

class TestListener: public DiagnosticListener

{

public:

    TestListener() : mSystemOutCount(0), mSystemErrCount(0), mLogCount(0)

    {

        mData = HBufC8::New(2000);

    };

    ~TestListener()

    {

        delete mData;

    };

    virtual void systemOut(const TDesC8& aData)

    {

        *mData = aData;

        mSystemOutCount++;

    };

    virtual void systemErr(const TDesC8& aData)

    {

        *mData = aData;

        mSystemErrCount++;

    };

    virtual void log(const TDesC8 &aData)

    {

        *mData = aData;

        mLogCount++;

    };

    bool operator==(const TDesC8& aRhs) const

    {

        if (aRhs.Compare(mData->Des()) == 0)

            return true;

        return false;

    };

    TInt mSystemOutCount;

    TInt mSystemErrCount;

    TInt mLogCount;

private:

    HBufC8* mData;

};

class LoggingListener : public TestListener

{

public:

    virtual void systemOut(const TDesC8& aData)

    {

        flog(aData);

        TestListener::systemOut(aData);

    };

    virtual void systemErr(const TDesC8& aData)

    {

        flog(aData);

        TestListener::systemErr(aData);

    };

    virtual void log(const TDesC8& aData)

    {

        flog(aData);

        TestListener::log(aData);

    };

protected:

    virtual void flog(const TDesC8& aData)

    {

        _LIT(KLogDirectory, "debug");   // create e.g. c:\logs\java to get logs

        _LIT(KLogFileName, "javadiagnostic.txt");

        RFileLogger::Write(KLogDirectory, KLogFileName, EFileLoggingModeAppendRaw, aData);

    };

};

class DiagnosticImplTester : public DiagnosticImpl

{

public:

    using DiagnosticImpl::DoCancel;

    using DiagnosticImpl::RunError;

};

TEST_GROUP(TestJavaDiagnostic)

{

    TEST_SETUP()

    {

    }

    TEST_TEARDOWN()

    {

    }

};

TEST(TestJavaDiagnostic, createInstance)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

}

TEST(TestJavaDiagnostic, setRemoveListener)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    TInt rc = jd->setDiagnosticListener(listener);

    CHECK(rc == KErrNone);

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, setRemoveListenerTwice)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    TInt rc = jd->setDiagnosticListener(listener);

    CHECK(rc == KErrNone);

    TestListener listener2;

    rc = jd->setDiagnosticListener(listener2);

    CHECK(rc == KErrAlreadyExists);

    jd->removeDiagnosticListener();

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, noRemoveListener)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    jd->setDiagnosticListener(listener);

}

TEST(TestJavaDiagnostic, noSetListener)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, serverNotRunning)

{

    Redirector r;

    TInt rc = r.connect();

    CHECK(rc != KErrNone);

    rc = r.systemOut(KText1);

    CHECK(rc != KErrNone);

    rc = r.systemErr(KText1);

    CHECK(rc != KErrNone);

    rc = Redirector::log(KText1);

    CHECK(rc != KErrNone);

    r.close();

}

TEST(TestJavaDiagnostic, redirectorNotConnected)

{

    Redirector r;

    TInt rc = r.systemOut(KText1);

    CHECK(rc != KErrNone);

    rc = r.systemErr(KText1);

    CHECK(rc != KErrNone);

    rc = Redirector::log(KText1);

    CHECK(rc != KErrNone);

    r.close();

}

TEST(TestJavaDiagnostic, alreadyRunning)

{

    std::auto_ptr<JavaDiagnostic> jd1(JavaDiagnostic::createInstance());

    CHECK(jd1.get());

    TestListener listener;

    TInt rc = jd1->setDiagnosticListener(listener);

    CHECK(rc == KErrNone);

    std::auto_ptr<JavaDiagnostic> jd2(JavaDiagnostic::createInstance());

    CHECK(jd2.get());

    rc = jd2->setDiagnosticListener(listener);

    CHECK(rc != KErrNone);

}

TEST(TestJavaDiagnostic, systemOut)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    jd->setDiagnosticListener(listener);

    Redirector r;

    TInt rc = r.connect();

    CHECK(rc == KErrNone);

    rc = r.systemOut(KText1);

    CHECK(rc == KErrNone);

    CHECK(listener == KText1);

    CHECK(listener.mSystemOutCount == 1);

    rc = r.systemOut(KText2);

    CHECK(rc == KErrNone);

    CHECK(listener == KText2);

    CHECK(listener.mSystemOutCount == 2);

    rc = r.systemOut(KText3);

    CHECK(rc == KErrNone);

    CHECK(listener == KText3);

    CHECK(listener.mSystemOutCount == 3);

    rc = r.systemOut(KText4);

    CHECK(rc == KErrNone);

    CHECK(listener == KText4);

    CHECK(listener.mSystemOutCount == 4);

    rc = r.systemOut(KText5);

    CHECK(rc == KErrNone);

    CHECK(listener == KText5);

    CHECK(listener.mSystemOutCount == 5);

    rc = r.systemOut(KText6);

    CHECK(rc == KErrNone);

    CHECK(listener == KText6);

    CHECK(listener.mSystemOutCount == 6);

    rc = r.systemOut(KText7);

    CHECK(rc == KErrNone);

    CHECK(listener == KText7);

    CHECK(listener.mSystemOutCount == 7);

    rc = r.systemOut(KText8);

    CHECK(rc == KErrNone);

    CHECK(listener == KText8);

    CHECK(listener.mSystemOutCount == 8);

    r.close();

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, systemErr)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    jd->setDiagnosticListener(listener);

    Redirector r;

    TInt rc = r.connect();

    CHECK(rc == KErrNone);

    rc = r.systemErr(KText1);

    CHECK(rc == KErrNone);

    CHECK(listener == KText1);

    CHECK(listener.mSystemErrCount == 1);

    rc = r.systemErr(KText2);

    CHECK(rc == KErrNone);

    CHECK(listener == KText2);

    CHECK(listener.mSystemErrCount == 2);

    rc = r.systemErr(KText3);

    CHECK(rc == KErrNone);

    CHECK(listener == KText3);

    CHECK(listener.mSystemErrCount == 3);

    rc = r.systemErr(KText4);

    CHECK(rc == KErrNone);

    CHECK(listener == KText4);

    CHECK(listener.mSystemErrCount == 4);

    rc = r.systemErr(KText5);

    CHECK(rc == KErrNone);

    CHECK(listener == KText5);

    CHECK(listener.mSystemErrCount == 5);

    rc = r.systemErr(KText6);

    CHECK(rc == KErrNone);

    CHECK(listener == KText6);

    CHECK(listener.mSystemErrCount == 6);

    rc = r.systemErr(KText7);

    CHECK(rc == KErrNone);

    CHECK(listener == KText7);

    CHECK(listener.mSystemErrCount == 7);

    rc = r.systemErr(KText8);

    CHECK(rc == KErrNone);

    CHECK(listener == KText8);

    CHECK(listener.mSystemErrCount == 8);

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, log)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    LoggingListener listener;

    jd->setDiagnosticListener(listener);

    TInt rc = Redirector::log(KText1);

    CHECK(rc == KErrNone);

    CHECK(listener == KText1);

    CHECK(listener.mLogCount == 1);

    rc = Redirector::log(KText2);

    CHECK(rc == KErrNone);

    CHECK(listener == KText2);

    CHECK(listener.mLogCount == 2);

    rc = Redirector::log(KText3);

    CHECK(rc == KErrNone);

    CHECK(listener == KText3);

    CHECK(listener.mLogCount == 3);

    rc = Redirector::log(KText4);

    CHECK(rc == KErrNone);

    CHECK(listener == KText4);

    CHECK(listener.mLogCount == 4);

    rc = Redirector::log(KText5);

    CHECK(rc == KErrNone);

    CHECK(listener == KText5);

    CHECK(listener.mLogCount == 5);

    rc = Redirector::log(KText6);

    CHECK(rc == KErrNone);

    CHECK(listener == KText6);

    CHECK(listener.mLogCount == 6);

    rc = Redirector::log(KText7);

    CHECK(rc == KErrNone);

    CHECK(listener == KText7);

    CHECK(listener.mLogCount == 7);

    rc = Redirector::log(KText8);

    CHECK(rc == KErrNone);

    CHECK(listener == KText8);

    CHECK(listener.mLogCount == 8);

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, loadTest)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    TestListener listener;

    jd->setDiagnosticListener(listener);

    Redirector r;

    TInt rc = r.connect();

    CHECK(rc == KErrNone);

    for (int i = 0; i< 1000; i++)

    {

        rc = r.systemOut(KText1);

        CHECK(rc == KErrNone);

        rc = r.systemErr(KText1);

        CHECK(rc == KErrNone);

        rc = Redirector::log(KText1);

        CHECK(rc == KErrNone);

    }

    CHECK(listener.mSystemOutCount == 1000);

    CHECK(listener.mSystemErrCount == 1000);

    CHECK(listener.mLogCount == 1000);

    r.close();

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, logger)

{

    std::auto_ptr<JavaDiagnostic> jd(JavaDiagnostic::createInstance());

    CHECK(jd.get());

    LoggingListener listener;

    jd->setDiagnosticListener(listener);

    ELOG(EDebugApi, "error level text");

    CHECK(listener.mLogCount == 1);

    WLOG(EDebugApi, "warning level text");

    CHECK(listener.mLogCount == 2);

    LOG(EDebugApi, EInfo, "info level text");

    CHECK(listener.mLogCount == 2);

    jd->removeDiagnosticListener();

}

TEST(TestJavaDiagnostic, unusedMethods)

{

    std::auto_ptr<DiagnosticImplTester> d((DiagnosticImplTester*)JavaDiagnostic::createInstance());

    d->DoCancel();

    TInt rc = d->RunError(KErrGeneral);

    CHECK(rc == KErrNone);

}