/*---------------------------------------------------------------------------*
  Project: Revolution ENC sample demo
  File:    unicode.c

  Copyright 2006 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law. They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: unicode.c,v $
  Revision 1.1  08/11/2006 10:16:58  yoshioka_yasuhiro
  Initial commit.

  $NoKeywords: $
 *---------------------------------------------------------------------------*/

#include <revolution.h>
#include <revolution/enc.h>

static u32 utf32[] = {0x00000041, 0x00000042, 0x00000043, 0x000000C0, 0x000000C1, 0x000000C2, 0x00003042, 0x00003044, 0x00003046, 0x0000FF71, 0x0000FF72, 0x0000FF73, 0x00010000, 0x00000000};
static u16 utf16[] = {0x0041, 0x0042, 0x0043, 0x00C0, 0x00C1, 0x00C2, 0x3042, 0x3044, 0x3046, 0xFF71, 0xFF72, 0xFF73, 0xD800, 0xDC00, 0x0000};
static u8 utf8[] = {0x41, 0x42, 0x43, 0xC3, 0x80, 0xC3, 0x81, 0xC3, 0x82, 0xE3, 0x81, 0x82, 0xE3, 0x81, 0x84, 0xE3, 0x81, 0x86, 0xEF, 0xBD, 0xB1, 0xEF, 0xBD, 0xB2, 0xEF, 0xBD, 0xB3, 0xF0, 0x90, 0x80, 0x80, 0x00};

int main()
{
    #define LENGTH 32
    BOOL test_clear = TRUE;
    s32 srclen, dstlen;
    ENCResult err_code;

    /* UTF32 str -> UTF16 str */
    OSReport("\n* UTF32 str -> UTF16 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf32ToUtf16(NULL, &dstlen, utf32, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u16 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf32ToUtf16(dst, &dstlen, utf32, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s32 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf16[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf16[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }
    
    /* UTF16 str -> UTF32 str */
    OSReport("\n* UTF16 str -> UTF32 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf16ToUtf32(NULL, &dstlen, utf16, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u32 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf16ToUtf32(dst, &dstlen, utf16, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s32 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf32[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf32[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }

    /* UTF32 str -> UTF8 str */
    OSReport("\n* UTF32 str -> UTF8 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf32ToUtf8(NULL, &dstlen, utf32, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u8 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf32ToUtf8(dst, &dstlen, utf32, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s32 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf8[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf8[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }
    
    /* UTF8 str -> UTF32 str */
    OSReport("\n* UTF8 str -> UTF32 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf8ToUtf32(NULL, &dstlen, utf8, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u32 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf8ToUtf32(dst, &dstlen, utf8, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s32 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf32[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf32[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }

    /* UTF16 str -> UTF8 str */
    OSReport("\n* UTF16 str -> UTF8 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf16ToUtf8(NULL, &dstlen, utf16, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u8 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf16ToUtf8(dst, &dstlen, utf16, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s16 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf8[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf8[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }
    
    /* UTF8 str -> UTF16 str */
    OSReport("\n* UTF8 str -> UTF16 str *\n");
    srclen = -1;
    err_code = ENCConvertStringUtf8ToUtf16(NULL, &dstlen, utf8, &srclen);
    if (err_code)
    {
        OSReport("ERROR: %d\n", err_code);
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        test_clear = FALSE;
    }
    else
    {
        u16 dst[LENGTH];
        OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
        err_code = ENCConvertStringUtf8ToUtf16(dst, &dstlen, utf8, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            s16 i, j;
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            for (i = 0; i < dstlen; ++i)
            {
                if (dst[i] == utf16[i])
                    continue;
                OSReport("FAILURE\nend @ %d\n", i);
                OSReport("result\tanswer\n");
                for (j = 0; j < 8; ++j)
                    OSReport("%#x\t%#x\n", dst[i + j], utf16[i + j]);
                test_clear = FALSE;
                break;
            }
            if (i == dstlen)
            {
                OSReport("SUCCESS\nend @ %d\n", i - 1);
            }
        }
    }
    
    if (test_clear)
        OSReport("\nTOTAL SUCCESS\n");
    else
        OSReport("\nTOTAL FAILURE\n");

    return 0;
}