// 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