/*

* Copyright (c) 2010 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: 

*

*/

#include <wchar.h>

#include <string>

#include <iostream>

#include "itk.h"

#include "cpixstrtools.h"

template<typename V>

void testConvertDefault(Itk::TestMgr  * testMgr,

                                     V             * v,

                                     const wchar_t * pass[],

                                     const wchar_t * fail[])

{

    using namespace Cpt;

    using namespace std;

    wcout << L"pass:" << endl;

    for (const wchar_t ** p = pass; *p != NULL; ++p)

        {

            const char

                * result = wconvert(v,

                                    *p);

            ITK_EXPECT(testMgr,

                       result == NULL,

                       "Should have passed: %S",

                       *p);

            wcout << L"SUCCESS: " << *p << ": ";

            wcout << *v << endl;

        }

    wcout << L"fail:" << endl;

    for (const wchar_t ** p = fail; *p != NULL; ++p)

        {

            const char

                * result = wconvert(v,

                                    *p);

            ITK_EXPECT(testMgr,

                       result != NULL,

                       "Should NOT have passed: %S",

                       *p);

            wcout << L"FAILURE: " << *p << ": " << flush;

            cout << result << endl << flush;

        }

}

template<typename UINT>

void testConvertOctal(Itk::TestMgr  * testMgr,

                      UINT          * v,

                      const wchar_t * pass[],

                      const wchar_t * fail[])

{

    using namespace Cpt;

    using namespace std;

    wcout << L"pass:" << endl;

    for (const wchar_t ** p = pass; *p != NULL; ++p)

        {

            const char

                * result = wconvertOctal(v,

                                         *p);

            ITK_EXPECT(testMgr,

                       result == NULL,

                       "Should have passed: %S",

                       *p);

            wcout << L"SUCCESS: " << *p << ": ";

            wcout << *v << endl;

        }

    wcout << L"fail:" << endl;

    for (const wchar_t ** p = fail; *p != NULL; ++p)

        {

            const char

                * result = wconvertOctal(v,

                                    *p);

            ITK_EXPECT(testMgr,

                       result != NULL,

                       "Should NOT have passed: %S",

                       *p);

            wcout << L"FAILURE: " << *p << ": " << flush;

            cout << result << endl << flush;

        }

}

template<typename UINT>

void testConvertHexadecimal(Itk::TestMgr  * testMgr,

                            UINT          * v,

                            const wchar_t * pass[],

                            const wchar_t * fail[])

{

    using namespace Cpt;

    using namespace std;

    wcout << L"pass:" << endl;

    for (const wchar_t ** p = pass; *p != NULL; ++p)

        {

            const char

                * result = wconvertHexadecimal(v,

                                               *p);

            ITK_EXPECT(testMgr,

                       result == NULL,

                       "Should have passed: %S",

                       *p);

            wcout << L"SUCCESS: " << *p << ": ";

            wcout << *v << endl;

        }

    wcout << L"fail:" << endl;

    for (const wchar_t ** p = fail; *p != NULL; ++p)

        {

            const char

                * result = wconvertHexadecimal(v,

                                               *p);

            ITK_EXPECT(testMgr,

                       result != NULL,

                       "Should NOT have passed: %S",

                       *p);

            wcout << L"FAILURE: " << *p << ": ";

            wcout << result << endl << flush;

        }

}

void testConvertInteger(Itk::TestMgr * testMgr)

{

    printf("TESTING integer (generic, default) formatting. Target: int\n");

    static const wchar_t * pass[] = {

        L"0",

        L"123",

        L"-123",

        L"0xdead",

        L"0x100",

        L"0100",

        L"100",

        NULL

    };

    static const wchar_t * fail[] = {

        L"0a",

        L"123a",

        L"-123a",

        L"0xdeadg",

        L"0x100g",

        L"01009",

        L"100.",

        NULL

    };

    int

        v;

    testConvertDefault(testMgr,

                       &v,

                       pass,

                       fail);

}

void testConvertInteger_8(Itk::TestMgr * testMgr)

{

    printf("TESTING integer (octal) formatting. Target: unsigned int\n");

    static const wchar_t * pass[] = {

        L"0",

        L"123",

        L"0100",

        L"100",

        NULL

    };

    static const wchar_t * fail[] = {

        L"0a",

        L"123a",

        L"01009",

        L"100.",

        NULL

    };

    unsigned int

        v;

    testConvertOctal(testMgr,

                     &v,

                     pass,

                     fail);

}

void testConvertInteger_16(Itk::TestMgr * testMgr)

{

    printf("TESTING integer (hexadecimal) formatting. Target: unsigned int\n");

    static const wchar_t * pass[] = {

        L"ff",

        L"beef",

        L"123",

        L"0100",

        L"100",

        NULL

    };

    static const wchar_t * fail[] = {

        L"0z",

        L"123g",

        L"0100g",

        L"100.",

        NULL

    };

    unsigned int

        v;

    testConvertHexadecimal(testMgr,

                           &v,

                           pass,

                           fail);

}

void testConvertFloat(Itk::TestMgr * testMgr)

{

    printf("TESTING float (generic, default) formatting. Target: float\n");

    static const wchar_t * pass[] = {

        L"0",

        L"0.5",

        L".5",

        L"-.5",

        L"+.5",

        L"+12.345",

        NULL

    };

    static const wchar_t * fail[] = {

        L"a",

        L".-5",

        L"zaza",

        L"3.1415a",

        NULL

    };

    float

        v;

    testConvertDefault(testMgr,

                       &v,

                       pass,

                       fail);

}

void testConvertDouble(Itk::TestMgr * testMgr)

{

    printf("TESTING double (generic, default) formatting. Target: double\n");

    static const wchar_t * pass[] = {

        L"0",

        L"0.5",

        L".5",

        L"-.5",

        L"+.5",

        L"+12.345",

        NULL

    };

    static const wchar_t * fail[] = {

        L"a",

        L".-5",

        L"zaza",

        L"3.1415a",

        NULL

    };

    double

        v;

    testConvertDefault(testMgr,

                       &v,

                       pass,

                       fail);

}

Itk::TesterBase * CreateConversionTests()

{

    using namespace Itk;

    SuiteTester

        * conversionTests = new SuiteTester("conversion");

#define TEST "integer"

    conversionTests->add(TEST,

                         testConvertInteger,

                         TEST);

#undef TEST

#define TEST "integer_8"

    conversionTests->add(TEST,

                         testConvertInteger_8,

                         TEST);

#undef TEST

#define TEST "integer_16"

    conversionTests->add(TEST,

                         testConvertInteger_16,

                         TEST);

#undef TEST

#define TEST "float"

    conversionTests->add(TEST,

                         testConvertFloat,

                         TEST);

#undef TEST

#define TEST "double"

    conversionTests->add(TEST,

                         testConvertDouble,

                         TEST);

#undef TEST

    // ... add more tests to suite

    return conversionTests;

}