/*

 ** 2001 September 15

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** Code for testing the utf.c module in SQLite.  This code

 ** is not included in the SQLite library.  It is used for automated

 ** testing of the SQLite library. Specifically, the code in this file

 ** is used for testing the SQLite routines for converting between

 ** the various supported unicode encodings.

 **

 ** $Id: test5.c,v 1.22 2008/08/12 15:04:59 danielk1977 Exp $

 */

 #include "sqliteInt.h"

 #include "vdbeInt.h"

 #include "tcl.h"

 #include <stdlib.h>

 #include <string.h>

 /*

 ** The first argument is a TCL UTF-8 string. Return the byte array

 ** object with the encoded representation of the string, including

 ** the NULL terminator.

 */

 static int binarize(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int len;

   char *bytes;

   Tcl_Obj *pRet;

   assert(objc==2);

   bytes = Tcl_GetStringFromObj(objv[1], &len);

   pRet = Tcl_NewByteArrayObj((u8*)bytes, len+1);

   Tcl_SetObjResult(interp, pRet);

   return TCL_OK;

 }

 /*

 ** Usage: test_value_overhead <repeat-count> <do-calls>.

 **

 ** This routine is used to test the overhead of calls to

 ** sqlite3_value_text(), on a value that contains a UTF-8 string. The idea

 ** is to figure out whether or not it is a problem to use sqlite3_value

 ** structures with collation sequence functions.

 **

 ** If <do-calls> is 0, then the calls to sqlite3_value_text() are not

 ** actually made.

 */

 static int test_value_overhead(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int do_calls;

   int repeat_count;

   int i;

   Mem val;

   const char *zVal;

   if( objc!=3 ){

     Tcl_AppendResult(interp, "wrong # args: should be \"",

         Tcl_GetStringFromObj(objv[0], 0), " <repeat-count> <do-calls>", 0);

     return TCL_ERROR;

   }

   if( Tcl_GetIntFromObj(interp, objv[1], &repeat_count) ) return TCL_ERROR;

   if( Tcl_GetIntFromObj(interp, objv[2], &do_calls) ) return TCL_ERROR;

   val.flags = MEM_Str|MEM_Term|MEM_Static;

   val.z = "hello world";

   val.type = SQLITE_TEXT;

   val.enc = SQLITE_UTF8;

   for(i=0; i<repeat_count; i++){

     if( do_calls ){

       zVal = (char*)sqlite3_value_text(&val);

     }

   }

   return TCL_OK;

 }

 static u8 name_to_enc(Tcl_Interp *interp, Tcl_Obj *pObj){

   struct EncName {

     char *zName;

     u8 enc;

   } encnames[] = {

     { "UTF8", SQLITE_UTF8 },

     { "UTF16LE", SQLITE_UTF16LE },

     { "UTF16BE", SQLITE_UTF16BE },

     { "UTF16", SQLITE_UTF16 },

     { 0, 0 }

   };

   struct EncName *pEnc;

   char *z = Tcl_GetString(pObj);

   for(pEnc=&encnames[0]; pEnc->zName; pEnc++){

     if( 0==sqlite3StrICmp(z, pEnc->zName) ){

       break;

     }

   }

   if( !pEnc->enc ){

     Tcl_AppendResult(interp, "No such encoding: ", z, 0);

   }

   if( pEnc->enc==SQLITE_UTF16 ){

     return SQLITE_UTF16NATIVE;

   }

   return pEnc->enc;

 }

 /*

 ** Usage:   test_translate <string/blob> <from enc> <to enc> ?<transient>?

 **

 */

 static int test_translate(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   u8 enc_from;

   u8 enc_to;

   sqlite3_value *pVal;

   char *z;

   int len;

   void (*xDel)(void *p) = SQLITE_STATIC;

   if( objc!=4 && objc!=5 ){

     Tcl_AppendResult(interp, "wrong # args: should be \"",

         Tcl_GetStringFromObj(objv[0], 0), 

         " <string/blob> <from enc> <to enc>", 0

     );

     return TCL_ERROR;

   }

   if( objc==5 ){

     xDel = sqlite3_free;

   }

   enc_from = name_to_enc(interp, objv[2]);

   if( !enc_from ) return TCL_ERROR;

   enc_to = name_to_enc(interp, objv[3]);

   if( !enc_to ) return TCL_ERROR;

   pVal = sqlite3ValueNew(0);

   if( enc_from==SQLITE_UTF8 ){

     z = Tcl_GetString(objv[1]);

     if( objc==5 ){

       z = sqlite3DbStrDup(0, z);

     }

     sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);

   }else{

     z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len);

     if( objc==5 ){

       char *zTmp = z;

       z = sqlite3_malloc(len);

       memcpy(z, zTmp, len);

     }

     sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);

   }

   z = (char *)sqlite3ValueText(pVal, enc_to);

   len = sqlite3ValueBytes(pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);

   Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len));

   sqlite3ValueFree(pVal);

   return TCL_OK;

 }

 /*

 ** Usage: translate_selftest

 **

 ** Call sqlite3UtfSelfTest() to run the internal tests for unicode

 ** translation. If there is a problem an assert() will fail.

 **/

 void sqlite3UtfSelfTest(void);

 static int test_translate_selftest(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

 #ifndef SQLITE_OMIT_UTF16

   sqlite3UtfSelfTest();

 #endif

   return SQLITE_OK;

 }

 /*

 ** Register commands with the TCL interpreter.

 */

 int Sqlitetest5_Init(Tcl_Interp *interp){

   static struct {

     char *zName;

     Tcl_ObjCmdProc *xProc;

   } aCmd[] = {

     { "binarize",                (Tcl_ObjCmdProc*)binarize },

     { "test_value_overhead",     (Tcl_ObjCmdProc*)test_value_overhead },

     { "test_translate",          (Tcl_ObjCmdProc*)test_translate     },

     { "translate_selftest",      (Tcl_ObjCmdProc*)test_translate_selftest},

   };

   int i;

   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){

     Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);

   }

   return SQLITE_OK;

 }