// Copyright (c) 2008-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:

//

#include <string>

#include <sstream>

#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)

#  include <fstream>

#  include <locale>

#  include "cppunit/cppunit_proxy.h"

#  if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)

using namespace std;

#  endif

//

// TestCase class

//

class CodecvtTest : public CPPUNIT_NS::TestCase

{

  CPPUNIT_TEST_SUITE(CodecvtTest);

#if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)

  CPPUNIT_IGNORE;

#endif

  CPPUNIT_TEST(variable_encoding);

  CPPUNIT_TEST(locale_cov1);

  CPPUNIT_TEST(locale_cov2);

  CPPUNIT_TEST(locale_cov3);

  CPPUNIT_TEST(locale_cov4);

  CPPUNIT_TEST(locale_cov5);

  CPPUNIT_TEST(locale_cov6);

  CPPUNIT_TEST(locale_cov7);

  CPPUNIT_TEST_SUITE_END();

protected:

  void variable_encoding();

  void locale_cov1();

  void locale_cov2();

  void locale_cov3();

  void locale_cov4();

  void locale_cov5();

  void locale_cov6();

  void locale_cov7();

};

CPPUNIT_TEST_SUITE_REGISTRATION(CodecvtTest);

#if defined (STLPORT)

#  define __NO_THROW _STLP_NOTHROW

#else

#  define __NO_THROW throw()

#endif

/* Codecvt facet eating some characters from the external buffer.

 * Transform '01' in 'a'

 */

struct eater_codecvt : public codecvt<char, char, mbstate_t> {

  typedef codecvt<char,char,mbstate_t> base;

  explicit eater_codecvt(size_t refs = 0) : base(refs) {}

  // primitive conversion

  virtual base::result

  do_in(mbstate_t& mb,

        const char* ebegin, const char* eend, const char*& ecur,

        char* ibegin, char* iend, char*& icur) const __NO_THROW {

      char *state = (char*)&mb;

      ecur = ebegin;

      icur = ibegin;

      while (ecur != eend) {

          if (icur == iend)

              return partial;

          if (*ecur == '0' || *state == 1) {

            if (*state != 1) {

              ++ecur;

            }

            if (ecur == eend) {

              *state = 1;

              return ok;

            }

            if (*ecur == '1') {

              *icur = 'a';

            }

            else {

              *(icur++) = '0';

              if (icur == iend) {

                if (*state != 1) {

                  --ecur;

                }

                return partial;

              }

              *icur = *ecur;

            }

          }

          else {

            *icur = *ecur;

          }

          *state = 0;

          ++icur;

          ++ecur;

      }

      return ok;

  }

  // claim it's not a null-conversion

  virtual bool do_always_noconv() const __NO_THROW

  { return false; }

  // claim it doesn't have a fixed-length encoding

  virtual int do_encoding() const __NO_THROW

  { return 0; }

  // implemented for consistency with do_in overload

  virtual int do_length(const mbstate_t &state,

                        const char *efrom, const char *eend, size_t m) const {

    char *ibegin = new char[m];

    const char *ecur = efrom;

    char *icur = ibegin;

    mbstate_t tmp = state;

    do_in(tmp, efrom, eend, ecur, ibegin, ibegin + m, icur);

    delete[] ibegin;

    return ecur - efrom;

  }

  virtual int do_max_length() const __NO_THROW

  { return 2; }

};

/* Codecvt facet generating more characters than the ones read from the

 * external buffer, transform '01' in 'abc'

 * This kind of facet do not allow systematical positionning in the external

 * buffer (tellg -> -1), when you just read a 'a' you are at an undefined

 * external buffer position.

 */

struct generator_codecvt : public codecvt<char, char, mbstate_t> {

  typedef codecvt<char,char,mbstate_t> base;

  explicit generator_codecvt(size_t refs = 0) : base(refs) {}

  // primitive conversion

  virtual base::result

  do_in(mbstate_t& mb,

        const char* ebegin, const char* eend, const char*& ecur,

        char* ibegin, char* iend, char*& icur) const __NO_THROW {

      //Access the mbstate information in a portable way:

      char *state = (char*)&mb;

      ecur = ebegin;

      icur = ibegin;

      if (icur == iend) return ok;

      if (*state == 2) {

        *(icur++) = 'b';

        if (icur == iend) {

          *state = 3;

          return ok;

        }

        *(icur++) = 'c';

        *state = 0;

      }

      else if (*state == 3) {

        *(icur++) = 'c';

        *state = 0;

      }

      while (ecur != eend) {

          if (icur == iend)

              return ok;

          if (*ecur == '0' || *state == 1) {

            if (*state != 1) {

              ++ecur;

            }

            if (ecur == eend) {

              *state = 1;

              return partial;

            }

            if (*ecur == '1') {

              *(icur++) = 'a';

              if (icur == iend) {

                *state = 2;

                return ok;

              }

              *(icur++) = 'b';

              if (icur == iend) {

                *state = 3;

                return ok;

              }

              *icur = 'c';

            }

            else {

              *(icur++) = '0';

              if (icur == iend) {

                if (*state != 1) {

                  --ecur;

                }

                return ok;

              }

              *icur = *ecur;

            }

          }

          else {

            *icur = *ecur;

          }

          *state = 0;

          ++icur;

          ++ecur;

      }

      return ok;

  }

  // claim it's not a null-conversion

  virtual bool do_always_noconv() const __NO_THROW

  { return false; }

  // claim it doesn't have a fixed-length encoding

  virtual int do_encoding() const __NO_THROW

  { return 0; }

  // implemented for consistency with do_in overload

  virtual int do_length(const mbstate_t &mb,

                        const char *efrom, const char *eend, size_t m) const {

    const char *state = (const char*)&mb;

    int offset = 0;

    if (*state == 2)

      offset = 2;

    else if (*state == 3)

      offset = 1;

    char *ibegin = new char[m + offset];

    const char *ecur = efrom;

    char *icur = ibegin;

    mbstate_t tmpState = mb;

    do_in(tmpState, efrom, eend, ecur, ibegin, ibegin + m + offset, icur);

    /*

    char *state = (char*)&tmpState;

    if (*state != 0) {

      if (*state == 1)

        --ecur;

      else if (*state == 2 || *state == 3) {

        //Undefined position, we return -1:

        ecur = efrom - 1;

      }

    }

    else {

      if (*((char*)&mb) != 0) {

        //We take into account the character that hasn't been counted yet in

        //the previous decoding step:

        ecur++;

      }

    }

    */

    delete[] ibegin;

    return (int)min((size_t)(ecur - efrom), m);

  }

  virtual int do_max_length() const __NO_THROW

  { return 0; }

};

//

// tests implementation

//

void CodecvtTest::variable_encoding()

{

#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)

  //We first generate the file used for test:

  const char* fileName = "c:\\test_file.txt";

  {

    ofstream ostr(fileName);

    //Maybe we simply do not have write access to repository

    CPPUNIT_ASSERT( ostr.good() );

    for (int i = 0; i < 2048; ++i) {

      ostr << "0123456789";

    }

    CPPUNIT_ASSERT( ostr.good() );

  }

  {

    ifstream istr(fileName);

    CPPUNIT_ASSERT( istr.good() );

    CPPUNIT_ASSERT( !istr.eof() );

    eater_codecvt codec(1);

    locale loc(locale::classic(), &codec);

    istr.imbue(loc);

    CPPUNIT_ASSERT( istr.good() );

    CPPUNIT_ASSERT( (int)istr.tellg() == 0 );

    int theoricalPos = 0;

    do {

      signed char c = (signed char)istr.get();

      if (c == char_traits<char>::eof()) {

        break;

      }

      ++theoricalPos;

      if (c == 'a') {

        ++theoricalPos;

      }

     CPPUNIT_ASSERT( (int)istr.tellg() == theoricalPos );

    }

    while (!istr.eof());

    CPPUNIT_ASSERT( istr.eof() );

  }

#  if 0

  /* This test is broken, not sure if it is really possible to get a position in

   * a locale having a codecvt such as generator_codecvt. Maybe generator_codecvt

   * is not a valid theorical example of codecvt implementation. */

  {

    ifstream istr(fileName);

    CPPUNIT_ASSERT( istr.good() );

    CPPUNIT_ASSERT( !istr.eof() );

    generator_codecvt codec(1);

    locale loc(locale::classic(), &codec);

    istr.imbue(loc);

    CPPUNIT_ASSERT( istr.good() );

    CPPUNIT_ASSERT( (int)istr.tellg() == 0 );

    int theoricalPos = 0;

    int theoricalTellg;

    do {

      char c = istr.get();

      if (c == char_traits<char>::eof()) {

        break;

      }

      switch (c) {

        case 'a':

        case 'b':

          theoricalTellg = -1;

          break;

        case 'c':

          ++theoricalPos;

        default:

          ++theoricalPos;

          theoricalTellg = theoricalPos;

          break;

      }

      if ((int)istr.tellg() != theoricalTellg) {

        CPPUNIT_ASSERT( (int)istr.tellg() == theoricalTellg );

      }

    }

    while (!istr.eof());

    CPPUNIT_ASSERT( istr.eof() );

  }

#  endif

#endif

}

void CodecvtTest::locale_cov1()

	{

	locale loc ( "fr_FR.ISO-8859-1" );

	locale loc1 ( "en_US.ISO-8859-1" );

	bool result1,result2;

		{

	    result1 = isalnum ( 'L', loc);

		result2 = isalnum ( '@', loc);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false);

		result1 = isalnum ( 'L', loc1);

		result2 = isalnum ( '@', loc1);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false);

		}

		{

	    result1 = isalpha ( 'L', loc);

		result2 = isalpha ( '@', loc);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false);

		result1 = isalpha ( 'L', loc1);

		result2 = isalpha ( '@', loc1);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false);

		}

		{

	    result1 = iscntrl ( 'L', loc);

		result2 = iscntrl ( '\n', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		result1 = iscntrl ( 'L', loc1);

		result2 = iscntrl ( '\n', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

		{

	    result1 = isdigit ( 'L', loc);

		result2 = isdigit ( '3', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

	    result1 = isdigit ( 'L', loc1);

		result2 = isdigit ( '3', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

	}

void CodecvtTest::locale_cov2()

	{

	locale loc ( "fr_FR.ISO-8859-1" );

	locale loc1 ( "en_US.ISO-8859-1" );

	bool result1,result2;

		{

	    result1 = isgraph ( ' ', loc);

		result2 = isgraph ( '.', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		result1 = isgraph ( ' ', loc1);

		result2 = isgraph ( '.', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

		{

	    result1 = islower ( 'L', loc);

		result2 = islower ( 'v', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		result1 = islower ( 'L', loc1);

		result2 = islower ( 'v', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

		{

	    result1 = isprint ( '\n', loc);

		result2 = isprint ( 't', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		result1 = isprint ( '\n', loc1);

		result2 = isprint ( 't', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

		{

	    result1 = ispunct ( 'L', loc);

		result2 = ispunct ( ';', loc);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		result1 = ispunct ( 'L', loc1);

		result2 = ispunct ( ';', loc1);

		CPPUNIT_ASSERT( result1 == false);

		CPPUNIT_ASSERT( result2 == true );

		}

	}

void CodecvtTest::locale_cov3()

	{

	locale loc ( "fr_FR.ISO-8859-1" );

	locale loc1 ( "en_US.ISO-8859-1" );

	bool result1,result2,result3;

		{

		result2 = isspace ( '\n', loc);

		result3 = isspace ( 'x', loc);

		CPPUNIT_ASSERT( result2 == true );

		CPPUNIT_ASSERT( result3 == false );

		result2 = isspace ( '\n', loc1);

		result3 = isspace ( 'x', loc1);

		CPPUNIT_ASSERT( result2 == true );

		CPPUNIT_ASSERT( result3 == false );

		}

		{

	    result1 = isupper ( 'L', loc);

		result2 = isupper ( ';', loc);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false );

		result1 = isupper ( 'L', loc1);

		result2 = isupper ( ';', loc1);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == false );

		}

		{

	    result1 = isxdigit ( 'f', loc);

		result2 = isxdigit ( 'd', loc);

		result3 = isxdigit ( 'q', loc);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == true );

		CPPUNIT_ASSERT( result3 == false );

		result1 = isxdigit ( 'f', loc1);

		result2 = isxdigit ( 'd', loc1);

		result3 = isxdigit ( 'q', loc1);

		CPPUNIT_ASSERT( result1 == true );

		CPPUNIT_ASSERT( result2 == true );

		CPPUNIT_ASSERT( result3 == false );

		}

	}

void CodecvtTest::locale_cov4()

	{

	locale loc ( "fr_FR.ISO-8859-1" );

	locale loc1 ( "en_US.ISO-8859-1" );

	char cresult1;

		{

		cresult1 = tolower ( 'H', loc );

		CPPUNIT_ASSERT( cresult1 == 'h' );

		cresult1 = tolower ( 'h', loc );

		CPPUNIT_ASSERT( cresult1 == 'h' );

		cresult1 = tolower ( '$', loc );

		CPPUNIT_ASSERT( cresult1 == '$' );

		cresult1 = tolower ( 'H', loc1 );

		CPPUNIT_ASSERT( cresult1 == 'h' );

		cresult1 = tolower ( 'h', loc1 );

		CPPUNIT_ASSERT( cresult1 == 'h' );

		cresult1 = tolower ( '$', loc1 );

		CPPUNIT_ASSERT( cresult1 == '$' );

		}

		{

		cresult1 = toupper ( 'H', loc );

		CPPUNIT_ASSERT( cresult1 == 'H' );

		cresult1 = toupper ( 'h', loc );

		CPPUNIT_ASSERT( cresult1 == 'H' );

		cresult1 = toupper ( '$', loc );

		CPPUNIT_ASSERT( cresult1 == '$' );

		cresult1 = toupper ( 'H', loc1 );

		CPPUNIT_ASSERT( cresult1 == 'H' );

		cresult1 = toupper ( 'h', loc1 );

		CPPUNIT_ASSERT( cresult1 == 'H' );

		cresult1 = toupper ( '$', loc1 );

		CPPUNIT_ASSERT( cresult1 == '$' );

		}

	}

void CodecvtTest::locale_cov5()

	{

		{

		char* str = "stdcpp with pips";

		mbstate_t state = {0};

		locale loc("C");

		int res = use_facet<codecvt<wchar_t, char, mbstate_t> > ( loc ).length( state,str, &str[strlen(str)], 50 );

		CPPUNIT_ASSERT( res == 16 );

		res = use_facet<codecvt<char, char, mbstate_t> >( loc ).max_length( );

		}

		{

		char* str = "stdcpp with pips";

		wchar_t wstr [50];

		memset(&wstr[0], 0, (sizeof(wchar_t))*(50));

		const char* pszNext;

		wchar_t* pwszNext;

		mbstate_t state = {0};

		locale loc("C");

		int res = use_facet<codecvt<wchar_t, char, mbstate_t> >( loc ).in( state,str, &str[strlen(str)], pszNext,wstr, &wstr[strlen(str)], pwszNext );

		wstr[strlen(str)] = 0; 

		CPPUNIT_ASSERT(res!=codecvt_base::error);

		}

		{

		locale loc ( "fr_FR.ISO-8859-1" );

		int result1 = use_facet<codecvt<char, char, mbstate_t> > ( loc ).encoding ( );

		CPPUNIT_ASSERT(result1 == 1);

		bool result2 = use_facet<codecvt<char, char, mbstate_t> >( loc ).always_noconv( );

		CPPUNIT_ASSERT(result2 == true);

		result2 = use_facet<codecvt<wchar_t, char, mbstate_t> >( loc ).always_noconv( );

		CPPUNIT_ASSERT(result2 == false);

		}

	}

void CodecvtTest::locale_cov6()

	{

		{

		locale loc( "en_US.ISO-8859-1" );

		const numpunct < char> &npunct = use_facet <numpunct <char> >( loc );

		string str = npunct.truename();

		CPPUNIT_ASSERT(str == "true");

		str = npunct.falsename();

		CPPUNIT_ASSERT(str == "false");

		CPPUNIT_ASSERT(npunct.thousands_sep( ) == ',');

		const numpunct < wchar_t> &npunct1 = use_facet <numpunct <wchar_t> >( loc );

		wstring str1 = npunct1.truename();

		CPPUNIT_ASSERT(str1 == L"true");

		str1 = npunct1.falsename();

		CPPUNIT_ASSERT(str1 == L"false");

		CPPUNIT_ASSERT(npunct1.thousands_sep( ) == L',');

		CPPUNIT_ASSERT(npunct1.decimal_point( ) == L'.');

		}

	}

void CodecvtTest::locale_cov7()

	{

		{

		locale loc( "en_US.ISO-8859-1" );

		const moneypunct <char, true> &mpunct = use_facet <moneypunct <char, true > >(loc);

		CPPUNIT_ASSERT(mpunct.thousands_sep( ) == ',');

		string str = mpunct.positive_sign( );

		str = mpunct.negative_sign( );

		char x = mpunct.neg_format().field[0];

		x = mpunct.neg_format().field[1];

		x = mpunct.neg_format().field[2];

		x = mpunct.neg_format().field[3];

		CPPUNIT_ASSERT(mpunct.decimal_point( ) == '.');

		str = mpunct.curr_symbol( );

		const moneypunct <char, false> &mpunct2 = use_facet <moneypunct <char, false> >(loc);

		CPPUNIT_ASSERT(mpunct2.thousands_sep( ) == ',');

		str = mpunct2.positive_sign( );

		str = mpunct2.negative_sign( );

		x = mpunct2.neg_format().field[0];

		x = mpunct2.neg_format().field[1];

		x = mpunct2.neg_format().field[2];

		x = mpunct2.neg_format().field[3];

		CPPUNIT_ASSERT(mpunct2.decimal_point( ) == '.');

		str = mpunct2.curr_symbol( );

		}

	}

#endif