/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <log4cxx/helpers/transcoder.h>
#include "../insertwide.h"
#include "../logunit.h"


using namespace log4cxx;
using namespace log4cxx::helpers;


LOGUNIT_CLASS(TranscoderTestCase)
{
        LOGUNIT_TEST_SUITE(TranscoderTestCase);
                LOGUNIT_TEST(decode1);
#if LOG4CXX_WCHAR_T_API
                LOGUNIT_TEST(decode2);
#endif
                LOGUNIT_TEST(decode3);
#if LOG4CXX_WCHAR_T_API
                LOGUNIT_TEST(decode4);
#endif
                LOGUNIT_TEST(decode7);
                LOGUNIT_TEST(decode8);
#if LOG4CXX_WCHAR_T_API
                LOGUNIT_TEST(encode1);
#endif
                LOGUNIT_TEST(encode2);
#if LOG4CXX_WCHAR_T_API
                LOGUNIT_TEST(encode3);
#endif
                LOGUNIT_TEST(encode4);
#if LOG4CXX_WCHAR_T_API
                LOGUNIT_TEST(encode5);
#endif
                LOGUNIT_TEST(encode6);
                LOGUNIT_TEST(testDecodeUTF8_1);
                LOGUNIT_TEST(testDecodeUTF8_2);
                LOGUNIT_TEST(testDecodeUTF8_3);
                LOGUNIT_TEST(testDecodeUTF8_4);
#if LOG4CXX_UNICHAR_API
                LOGUNIT_TEST(udecode2);
                LOGUNIT_TEST(udecode4);
                LOGUNIT_TEST(uencode1);
                LOGUNIT_TEST(uencode3);
                LOGUNIT_TEST(uencode5);
#endif
#if LOG4CXX_LOGCHAR_IS_UTF8
                LOGUNIT_TEST(encodeCharsetName1);
                LOGUNIT_TEST(encodeCharsetName2);
                LOGUNIT_TEST(encodeCharsetName3);
#endif
        LOGUNIT_TEST_SUITE_END();


public:
        void decode1() {
          const char* greeting = "Hello, World";
          LogString decoded(LOG4CXX_STR("foo\n"));
          Transcoder::decode(greeting, decoded);
          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
        }

#if LOG4CXX_WCHAR_T_API
        void decode2() {
          const wchar_t* greeting = L"Hello, World";
          LogString decoded(LOG4CXX_STR("foo\n"));
          Transcoder::decode(greeting, decoded);
          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
        }
#endif

        void decode3() {
           const char* nothing = "";
           LogString decoded(LOG4CXX_STR("foo\n"));
           Transcoder::decode(nothing, decoded);
           LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
        }

#if LOG4CXX_WCHAR_T_API
        void decode4() {
            const wchar_t* nothing = L"";
            LogString decoded(LOG4CXX_STR("foo\n"));
            Transcoder::decode(nothing, decoded);
            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
        }
#endif


        enum { BUFSIZE = 255 };

        void decode7() {
            //
            //   normal characters striding over a buffer boundary
            //
            std::string longMsg(BUFSIZE - 2, 'A');
            longMsg.append("Hello");
            LogString decoded;
            Transcoder::decode(longMsg, decoded);
            LOGUNIT_ASSERT_EQUAL((size_t) BUFSIZE + 3, decoded.length());
            LOGUNIT_ASSERT_EQUAL(LogString(BUFSIZE -2, LOG4CXX_STR('A')),
                  decoded.substr(0, BUFSIZE - 2));
            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Hello"),
                  decoded.substr(BUFSIZE -2 ));
        }

        void decode8() {
            std::string msg("Hello, World.");
            LogString actual;
            Transcoder::decode(msg, actual);
            LogString expected(LOG4CXX_STR("Hello, World."));
            LOGUNIT_ASSERT_EQUAL(expected, actual);
        }


#if LOG4CXX_WCHAR_T_API
        void encode1() {
          const LogString greeting(LOG4CXX_STR("Hello, World"));
          std::wstring encoded;
          Transcoder::encode(greeting, encoded);
          LOGUNIT_ASSERT_EQUAL((std::wstring) L"Hello, World", encoded);
        }
#endif

        void encode2() {
          const LogString greeting(LOG4CXX_STR("Hello, World"));
          std::string encoded;
          Transcoder::encode(greeting, encoded);
          LOGUNIT_ASSERT_EQUAL((std::string) "Hello, World", encoded);
        }

#if LOG4CXX_WCHAR_T_API
        void encode3() {
          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
          greeting.append(LOG4CXX_STR("Hello"));
          std::wstring encoded;
          Transcoder::encode(greeting, encoded);
          std::wstring manyAs(BUFSIZE - 3, L'A');
          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
          LOGUNIT_ASSERT_EQUAL(std::wstring(L"Hello"), encoded.substr(BUFSIZE - 3));
        }
#endif

        void encode4() {
          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
          greeting.append(LOG4CXX_STR("Hello"));
          std::string encoded;
          Transcoder::encode(greeting, encoded);
          std::string manyAs(BUFSIZE - 3, 'A');
          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
          LOGUNIT_ASSERT_EQUAL(std::string("Hello"), encoded.substr(BUFSIZE - 3));
        }

#if LOG4CXX_WCHAR_T_API
        void encode5() {
          //   arbitrary, hopefully meaningless, characters from
          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
          const wchar_t greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
          //
          //  decode to LogString (UTF-16 or UTF-8)
          //
          LogString decoded;
          Transcoder::decode(greeting, decoded);
          //
          //  decode to wstring
          //
          std::wstring encoded;
          Transcoder::encode(decoded, encoded);
          //
          //   should be lossless
          //
          LOGUNIT_ASSERT_EQUAL((std::wstring) greeting, encoded);
        }
#endif

        void encode6() {
#if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_LOGCHAR_IS_UNICHAR
          //   arbitrary, hopefully meaningless, characters from
          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
          const logchar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
#endif

#if LOG4CXX_LOGCHAR_IS_UTF8
          const char greeting[] = { 'A',
                                    (char) 0xD8, (char) 0x85,
                                    (char) 0xD4, (char) 0xB0,
                                    (char) 0xE0, (char) 0xCC, (char) 0x84,
                                    (char) 0xE8, (char) 0x87, (char) 0x83,
                                    (char) 0xD0, (char) 0x80,
                                    0 };
#endif

          //
          //  decode to LogString (UTF-16 or UTF-8)
          //
          LogString decoded;
          Transcoder::decode(greeting, decoded);
          //
          //  decode to wstring
          //
          std::string encoded;
          //
          //   likely 'A\u0605\u0530\u0984\u40E3\u0400'
          //
          Transcoder::encode(decoded, encoded);
        }

    void testDecodeUTF8_1() {
        std::string src("a");
        LogString out;
        Transcoder::decodeUTF8(src, out);
        LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("a")), out);
    }

    void testDecodeUTF8_2() {
        std::string src(1, 0x80);
        LogString out;
        Transcoder::decodeUTF8(src, out);
        LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
    }

    void testDecodeUTF8_3() {
        std::string src("\xC2");
        LogString out;
        Transcoder::decodeUTF8(src, out);
        LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
    }

    void testDecodeUTF8_4() {
        std::string src("\xC2\xA9");
        LogString out;
        Transcoder::decodeUTF8(src, out);
        LogString::const_iterator iter = out.begin();
        unsigned int sv = Transcoder::decode(out, iter);
        LOGUNIT_ASSERT_EQUAL((unsigned int) 0xA9, sv);
        LOGUNIT_ASSERT_EQUAL(true, iter == out.end());
    }


#if LOG4CXX_UNICHAR_API
        void udecode2() {
          const UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
          LogString decoded(LOG4CXX_STR("foo\n"));
          Transcoder::decode(greeting, decoded);
          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
        }

        void udecode4() {
            const UniChar nothing[] = { 0 };
            LogString decoded(LOG4CXX_STR("foo\n"));
            Transcoder::decode(nothing, decoded);
            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
        }

        void uencode1() {
          const LogString greeting(LOG4CXX_STR("Hello, World"));
          std::basic_string<UniChar> encoded;
          Transcoder::encode(greeting, encoded);
          const UniChar expected[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(expected), encoded);
        }

        void uencode3() {
          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
          greeting.append(LOG4CXX_STR("Hello"));
          std::basic_string<UniChar> encoded;
          Transcoder::encode(greeting, encoded);
          std::basic_string<UniChar> manyAs(BUFSIZE - 3, 'A');
          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
          const UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(hello), encoded.substr(BUFSIZE - 3));
        }

        void uencode5() {
          //   arbitrary, hopefully meaningless, characters from
          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
          const UniChar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
          //
          //  decode to LogString (UTF-16 or UTF-8)
          //
          LogString decoded;
          Transcoder::decode(greeting, decoded);
          //
          //  decode to basic_string<UniChar>
          //
          std::basic_string<UniChar> encoded;
          Transcoder::encode(decoded, encoded);
          //
          //   should be lossless
          //
          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(greeting), encoded);
        }
#endif

#if LOG4CXX_LOGCHAR_IS_UTF8
        void encodeCharsetName1() {
            const logchar utf8[] = { 0x75, 0x74, 0x66, 0x2D, 0x38, 0x00 };
            std::string encoded(Transcoder::encodeCharsetName(LogString(utf8)));
            LOGUNIT_ASSERT_EQUAL(std::string("utf-8"), encoded);
        }

        void encodeCharsetName2() {
            logchar lascii[0x60];
            char ascii[0x60];
            for(int i = 0; i < 0x5F; i++) {
                lascii[i] = i + 0x20;
                ascii[i] = i + 0x20;
            }
            lascii[0x5F] = 0;
            ascii[0x5F] = 0;
            std::string encoded(Transcoder::encodeCharsetName(LogString(ascii)));
            LOGUNIT_ASSERT_EQUAL(std::string(" !\"#$%&'()*+,-./"), encoded.substr(0, 0x10));
            if (0x40 == 'A') {
                LOGUNIT_ASSERT_EQUAL(std::string(ascii), encoded);
            }
        }

        void encodeCharsetName3() {
            logchar unsupported[] = { 0x1F, 0x7F, static_cast<logchar>(0x80), static_cast<logchar>(0x81), 0x00 };
            std::string encoded(Transcoder::encodeCharsetName(LogString(unsupported)));
            LOGUNIT_ASSERT_EQUAL(std::string("????"), encoded);
        }
#endif

};

LOGUNIT_TEST_SUITE_REGISTRATION(TranscoderTestCase);