/*

* 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 UeiArgsParser class

*

*/

#include <string>

#include <vector>

#include "ueiargsparser.h"

#include "TestHarness.h"

#include "logger.h"

using java::runtime::UeiArgsParser;

using namespace std;

class ArgsParserTester : public UeiArgsParser

{

public:

    // give access to base class's protected functions

    using UeiArgsParser::getArgs;

    using UeiArgsParser::isVerbose;

    using UeiArgsParser::isRundjwp;

    using UeiArgsParser::convertVerbose;

    using UeiArgsParser::convertRundjwp;

    using UeiArgsParser::hasOption;

    using UeiArgsParser::trimTrailingSpaces;

};

TEST_GROUP(TestUeiArgsParser)

{

    ArgsParserTester parser;

    TEST_SETUP()

    {

    }

    TEST_TEARDOWN()

    {

    }

};

TEST(TestUeiArgsParser, convertUeiArgsToJvmArgs)

{

    EXPECT_N_LEAKS(12);

    wstring uei = L"-classpath midlet.jar"

                  L" -Xverbose:allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

                  L"bytecodes,frames,stackchunks,exceptions,events,threading,monitors,networking"

                  L" -Xdebug -Xrunjdwp:server=y,address=localhost:8000"

                  L" -Dproperty=value -Xdescriptor:jad-file -Xdevice:device-name -Xheapsize:2M";

    wstring expectedResult = L"-verbose:gc,class -Xrunjdwp:server=y,address=localhost:8000";

    wstring result = parser.convertUeiArgsToJvmArgs(uei);

    CHECK(result.compare(expectedResult) == 0);

}

TEST(TestUeiArgsParser, getArgs)

{

    EXPECT_N_LEAKS(4);

    std::vector<std::wstring> result = parser.getArgs(L"");

    CHECK(result.size() == 0);

    result = parser.getArgs(L"-Xverbose");

    CHECK(result.size() == 1);

    result = parser.getArgs(L"-Xverbose -Xrunjdwp:server=y,address=localhost:8000");

    CHECK(result.size() == 2);

    result = parser.getArgs(L"-Xdebug -Xverbose -Xrunjdwp:server=y,address=localhost:8000");

    CHECK(result.size() == 3);

}

TEST(TestUeiArgsParser, isVerbose)

{

    wstring str = L"-Xverbose";

    CHECK(parser.isVerbose(str) == true);

    str = L"-Xverbose:all,allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

          L"bytecodes,frames,stackchunks,exceptions,events,threading,monitors,networking"

          L"-Xdebug -Xrunjdwp:server=y,address=localhost:8000";

    CHECK(parser.isVerbose(str) == true);

    str = L"-verbose:all,allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

          L"bytecodes,frames,stackchunks,exceptions,events,threading,monitors,networking"

          L"-Xdebug -Xrunjdwp:server=y,address=localhost:8000";

    CHECK(parser.isVerbose(str) == false);

    str = L" -Xverbose";

    CHECK(parser.isVerbose(str) == false);

    str = L"-xverbose";

    CHECK(parser.isVerbose(str) == false);

    str = L"";

    CHECK(parser.isVerbose(str) == false);

}

TEST(TestUeiArgsParser, isRundjwp)

{

    wstring str = L"-Xrunjdwp";

    CHECK(parser.isRundjwp(str) == true);

    str = L"-Xrunjdwp:server=y,address=localhost:8000";

    CHECK(parser.isRundjwp(str) == true);

    str = L"-drunjdwp:server=y,address=localhost:8000";

    CHECK(parser.isRundjwp(str) == false);

    str = L" -Xrunjdwp";

    CHECK(parser.isRundjwp(str) == false);

    str = L"-drunjdwp";

    CHECK(parser.isRundjwp(str) == false);

    str = L"";

    CHECK(parser.isRundjwp(str) == false);

}

TEST(TestUeiArgsParser, convertVerbose)

{

    EXPECT_N_LEAKS(7);

    wstring str = L"-Xverbose:all,allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

                  L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    wstring result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose:gc,class,stack,sizes") == 0);

    // no all

    str = L"-Xverbose:allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

          L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose:gc,class") == 0);

    // only all

    str = L"-Xverbose:all,allocation,gcverbose,classverbose,verifier,stackmaps,"

          L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose:gc,class,stack,sizes") == 0);

    // only gc

    str = L"-Xverbose:allocation,gc,gcverbose,classverbose,verifier,stackmaps,"

          L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose:gc") == 0);

    // only class

    str = L"-Xverbose:allocation,gcverbose,class,classverbose,verifier,stackmaps,"

          L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose:class") == 0);

    // no supported options

    str = L"-Xverbose:allocation,gcverbose,classverbose,verifier,stackmaps,"

          L"bytecodes,frames.stackchunks,exceptions,events,threading,monitors,networking";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose") == 0);

    // only Xverbose

    str = L"-Xverbose";

    result = parser.convertVerbose(str);

    CHECK(result.compare(L"-verbose") == 0);

}

TEST(TestUeiArgsParser, convertRundjwp)

{

    wstring str = L"-Xrunjdwp:server=y,address=localhost:8000";

    wstring result = parser.convertRundjwp(str);

    CHECK(result.compare(str) == 0);

}

TEST(TestUeiArgsParser, hasOption)

{

    wstring str = L"-classpath midlet.jar"

                  L"-Xverbose:all,allocation,gc,gcverbose,class,classverbose,verifier,stackmaps,"

                  L"bytecodes,frames,stackchunks,exceptions,events,threading,monitors,networking"

                  L"-Xdebug -Xrunjdwp:server=y,address=localhost:8000";

    CHECK(parser.hasOption(str, L"all") == true);

    CHECK(parser.hasOption(str, L"class") == true);

    CHECK(parser.hasOption(str, L"gc") == true);

    CHECK(parser.hasOption(str, L"8000") == true);

    CHECK(parser.hasOption(str, L"alloca") == false);

    CHECK(parser.hasOption(str, L"classv") == false);

    CHECK(parser.hasOption(str, L"stack") == false);

    CHECK(parser.hasOption(str, L"ALL") == false);

    CHECK(parser.hasOption(str, L"CLASS") == false);

    CHECK(parser.hasOption(str, L"GC") == false);

}

TEST(TestUeiArgsParser, trimTrailingSpaces)

{

    // string has whitespaces

    wstring str = L"erase trailing white-spaces   \n";

    wstring whitespaces = L" \t\f\v\n\r";

    wstring result = parser.trimTrailingSpaces(str, whitespaces);

    CHECK(result.compare(L"erase trailing white-spaces") == 0);

    str = L"erase trailing white-spaces ";

    result = parser.trimTrailingSpaces(str, L" ");

    CHECK(result.compare(L"erase trailing white-spaces") == 0);

    str = L"-verbose: ";

    result = parser.trimTrailingSpaces(str, L": ");

    CHECK(result.compare(L"-verbose") == 0);

    str = L"-verbose:gc,class,";

    result = parser.trimTrailingSpaces(str, L",");

    CHECK(result.compare(L"-verbose:gc,class") == 0);

    // string does not have whitespaces

    str = L"erase trailing white-spaces";

    result = parser.trimTrailingSpaces(str, whitespaces);

    CHECK(result.compare(L"erase trailing white-spaces") == 0);

    str = L"erase trailing white-spaces";

    result = parser.trimTrailingSpaces(str, L"kjh");

    CHECK(result.compare(L"erase trailing white-spaces") == 0);

    str = L"erase trailing white-spaces";

    result = parser.trimTrailingSpaces(str, L"e");

    CHECK(result.compare(L"erase trailing white-spaces") == 0);

    // empty string

    wstring empty;

    result = parser.trimTrailingSpaces(empty, whitespaces);

    CHECK(result.compare(L"") == 0);

    empty = L"";

    result = parser.trimTrailingSpaces(empty, L" ");

    CHECK(result.compare(L"") == 0);

}