gecko/intl/uconv/tests/nsTestUConv.cpp
2012-10-04 02:14:06 -04:00

1132 lines
28 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <string.h>
#include "nsXPCOM.h"
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsISupports.h"
#include "nsICharsetConverterManager.h"
#include "nsIPlatformCharset.h"
#include "nsReadableUtils.h"
static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
static NS_DEFINE_CID(kPlatformCharsetCID, NS_PLATFORMCHARSET_CID);
/**
* Test program for the Unicode Converters.
*
* Error messages format inside of a test.
*
* - silent while all is OK.
*
* - "ERROR at T001.easyConversion.Convert() code=0xfffd.\n"
* - "ERROR at T001.easyConversion.ConvResLen expected=0x02 result=0x04.\n"
*
* - "Test Passed.\n" for a successful end.
*
* @created 01/Dec/1998
* @author Catalin Rotaru [CATA]
*/
//----------------------------------------------------------------------
// Global variables and macros
#define GENERAL_BUFFER 20000 // general purpose buffer; for Unicode divide by 2
#define ARRAY_SIZE(_array) \
(sizeof(_array) / sizeof(_array[0]))
nsICharsetConverterManager * ccMan = nullptr;
/**
* Test data for Latin1 charset.
*/
char bLatin1_d0[] = {
"\x00\x0d\x7f\x80\xff"
};
PRUnichar cLatin1_d0[] = {
0x0000,0x000d,0x007f,0x20ac,0x00ff
};
int32_t bLatin1_s0 = ARRAY_SIZE(bLatin1_d0)-1;
int32_t cLatin1_s0 = ARRAY_SIZE(cLatin1_d0);
//----------------------------------------------------------------------
// Converter Manager test code
nsresult testCharsetConverterManager()
{
printf("\n[T001] CharsetConverterManager\n");
return NS_OK;
}
//----------------------------------------------------------------------
// Helper functions and macros for testing decoders and encoders
#define CREATE_DECODER(_charset) \
nsIUnicodeDecoder * dec; \
nsAutoString str;str.AssignASCII(_charset); \
nsresult res = ccMan->GetUnicodeDecoder(&str,&dec); \
if (NS_FAILED(res)) { \
printf("ERROR at GetUnicodeDecoder() code=0x%x.\n",res); \
return res; \
}
#define CREATE_ENCODER(_charset) \
nsIUnicodeEncoder * enc; \
nsAutoString str; str.AssignASCII(_charset); \
nsresult res = ccMan->GetUnicodeEncoder(&str,&enc); \
if (NS_FAILED(res)) { \
printf("ERROR at GetUnicodeEncoder() code=0x%x.\n",res); \
return res; \
}
/**
* Decoder test.
*
* This method will test the conversion only.
*/
nsresult testDecoder(nsIUnicodeDecoder * aDec,
const char * aSrc, int32_t aSrcLength,
const PRUnichar * aRes, int32_t aResLength,
const char * aTestName)
{
nsresult res;
// prepare for conversion
int32_t srcLen = aSrcLength;
PRUnichar dest[GENERAL_BUFFER/2];
int32_t destLen = GENERAL_BUFFER/2;
// conversion
res = aDec->Convert(aSrc, &srcLen, dest, &destLen);
// we want a perfect result here - the test data should be complete!
if (res != NS_OK) {
printf("ERROR at %s.easy.Decode() code=0x%x.\n",aTestName,res);
return NS_ERROR_UNEXPECTED;
}
// compare results
if (aResLength != destLen) {
printf("ERROR at %s.easy.DecResLen expected=0x%x result=0x%x.\n",
aTestName, aResLength, destLen);
return NS_ERROR_UNEXPECTED;
}
for (int32_t i=0; i<aResLength; i++) if (aRes[i] != dest[i]) {
printf("ERROR at %s.easy.DecResChar[%d] expected=0x%x result=0x%x.\n",
aTestName, i, aRes[i], dest[i]);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
/**
* Encoder test.
*
* This method will test the conversion only.
*/
nsresult testEncoder(nsIUnicodeEncoder * aEnc,
const PRUnichar * aSrc, int32_t aSrcLength,
const char * aRes, int32_t aResLength,
const char * aTestName)
{
nsresult res;
// prepare for conversion
int32_t srcLen = 0;
char dest[GENERAL_BUFFER];
int32_t destLen = 0;
int32_t bcr, bcw;
// conversion
bcr = aSrcLength;
bcw = GENERAL_BUFFER;
res = aEnc->Convert(aSrc, &bcr, dest, &bcw);
srcLen += bcr;
destLen += bcw;
// we want a perfect result here - the test data should be complete!
if (res != NS_OK) {
printf("ERROR at %s.easy.Encode() code=0x%x.\n",aTestName,res);
return NS_ERROR_UNEXPECTED;
}
// finish
bcw = GENERAL_BUFFER - destLen;
res = aEnc->Finish(dest + destLen, &bcw);
destLen += bcw;
// we want a perfect result here - the test data should be complete!
if (res != NS_OK) {
printf("ERROR at %s.easy.Finish() code=0x%x.\n",aTestName,res);
return NS_ERROR_UNEXPECTED;
}
// compare results
if (aResLength != destLen) {
printf("ERROR at %s.easy.EncResLen expected=0x%x result=0x%x.\n",
aTestName, aResLength, destLen);
return NS_ERROR_UNEXPECTED;
}
for (int32_t i=0; i<aResLength; i++) if (aRes[i] != dest[i]) {
printf("ERROR at %s.easy.EncResChar[%d] expected=0x%x result=0x%x.\n",
aTestName, i, aRes[i], dest[i]);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
/**
* Decoder test.
*
* This method will test a given converter under a given set of data and some
* very stressful conditions.
*/
nsresult testStressDecoder(nsIUnicodeDecoder * aDec,
const char * aSrc, int32_t aSrcLength,
const PRUnichar * aRes, int32_t aResLength,
const char * aTestName)
{
nsresult res;
// get estimated length
int32_t estimatedLength;
res = aDec->GetMaxLength(aSrc, aSrcLength, &estimatedLength);
if (NS_FAILED(res)) {
printf("ERROR at %s.stress.Length() code=0x%x.\n",aTestName,res);
return res;
}
bool exactLength = (res == NS_EXACT_LENGTH);
// prepare for conversion
int32_t srcLen = 0;
int32_t srcOff = 0;
PRUnichar dest[1024];
int32_t destLen = 0;
int32_t destOff = 0;
// controlled conversion
for (;srcOff < aSrcLength;) {
res = aDec->Convert(aSrc + srcOff, &srcLen, dest + destOff, &destLen);
if (NS_FAILED(res)) {
printf("ERROR at %s.stress.Convert() code=0x%x.\n",aTestName,res);
return res;
}
srcOff+=srcLen;
destOff+=destLen;
// give a little input each time; it'll be consumed if enough output space
srcLen = 1;
// give output space only when requested: sadic!
if (res == NS_PARTIAL_MORE_OUTPUT) {
destLen = 1;
} else {
destLen = 0;
}
}
// we want perfect result here - the test data should be complete!
if (res != NS_OK) {
printf("ERROR at %s.stress.postConvert() code=0x%x.\n",aTestName,res);
return NS_ERROR_UNEXPECTED;
}
// compare lengths
if (exactLength) {
if (destOff != estimatedLength) {
printf("ERROR at %s.stress.EstimatedLen expected=0x%x result=0x%x.\n",
aTestName, estimatedLength, destOff);
return NS_ERROR_UNEXPECTED;
}
} else {
if (destOff > estimatedLength) {
printf("ERROR at %s.stress.EstimatedLen expected<=0x%x result=0x%x.\n",
aTestName, estimatedLength, destOff);
return NS_ERROR_UNEXPECTED;
}
}
// compare results
if (aResLength != destOff) {
printf("ERROR at %s.stress.ConvResLen expected=0x%x result=0x%x.\n",
aTestName, aResLength, destOff);
return NS_ERROR_UNEXPECTED;
}
for (int32_t i=0; i<aResLength; i++) if (aRes[i] != dest[i]) {
printf("ERROR at %s.stress.ConvResChar[%d] expected=0x%x result=0x%x.\n",
aTestName, i, aRes[i], dest[i]);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
/**
* Encoder test.
*
* This method will test a given converter under a given set of data and some
* very stressful conditions.
*/
nsresult testStressEncoder(nsIUnicodeEncoder * aEnc,
const PRUnichar * aSrc, int32_t aSrcLength,
const char * aRes, int32_t aResLength,
const char * aTestName)
{
nsresult res;
// get estimated length
int32_t estimatedLength;
res = aEnc->GetMaxLength(aSrc, aSrcLength, &estimatedLength);
if (NS_FAILED(res)) {
printf("ERROR at %s.stress.Length() code=0x%x.\n",aTestName,res);
return res;
}
bool exactLength = (res == NS_OK_UENC_EXACTLENGTH);
// prepare for conversion
int32_t srcLen = 0;
int32_t srcOff = 0;
char dest[GENERAL_BUFFER];
int32_t destLen = 0;
int32_t destOff = 0;
// controlled conversion
for (;srcOff < aSrcLength;) {
res = aEnc->Convert(aSrc + srcOff, &srcLen, dest + destOff, &destLen);
if (NS_FAILED(res)) {
printf("ERROR at %s.stress.Convert() code=0x%x.\n",aTestName,res);
return res;
}
srcOff+=srcLen;
destOff+=destLen;
// give a little input each time; it'll be consumed if enough output space
srcLen = 1;
// give output space only when requested: sadic!
if (res == NS_OK_UENC_MOREOUTPUT) {
destLen = 1;
} else {
destLen = 0;
}
}
if (res != NS_OK) if (res != NS_OK_UENC_MOREOUTPUT) {
printf("ERROR at %s.stress.postConvert() code=0x%x.\n",aTestName,res);
return NS_ERROR_UNEXPECTED;
}
for (;;) {
res = aEnc->Finish(dest + destOff, &destLen);
if (NS_FAILED(res)) {
printf("ERROR at %s.stress.Finish() code=0x%x.\n",aTestName,res);
return res;
}
destOff+=destLen;
// give output space only when requested: sadic!
if (res == NS_OK_UENC_MOREOUTPUT) {
destLen = 1;
} else break;
}
// compare lengths
if (exactLength) {
if (destOff != estimatedLength) {
printf("ERROR at %s.stress.EstimatedLen expected=0x%x result=0x%x.\n",
aTestName, estimatedLength, destOff);
return NS_ERROR_UNEXPECTED;
}
} else {
if (destOff > estimatedLength) {
printf("ERROR at %s.stress.EstimatedLen expected<=0x%x result=0x%x.\n",
aTestName, estimatedLength, destOff);
return NS_ERROR_UNEXPECTED;
}
}
// compare results
if (aResLength != destOff) {
printf("ERROR at %s.stress.ConvResLen expected=0x%x result=0x%x.\n",
aTestName, aResLength, destOff);
return NS_ERROR_UNEXPECTED;
}
for (int32_t i=0; i<aResLength; i++) if (aRes[i] != dest[i]) {
printf("ERROR at %s.stress.ConvResChar[%d] expected=0x%x result=0x%x.\n",
aTestName, i, aRes[i], dest[i]);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
/**
* Reset decoder.
*/
nsresult resetDecoder(nsIUnicodeDecoder * aDec, const char * aTestName)
{
nsresult res = aDec->Reset();
if (NS_FAILED(res)) {
printf("ERROR at %s.dec.Reset() code=0x%x.\n",aTestName,res);
return res;
}
return res;
}
/**
* Reset encoder.
*/
nsresult resetEncoder(nsIUnicodeEncoder * aEnc, const char * aTestName)
{
nsresult res = aEnc->Reset();
if (NS_FAILED(res)) {
printf("ERROR at %s.enc.Reset() code=0x%x.\n",aTestName,res);
return res;
}
return res;
}
/**
* A standard decoder test.
*/
nsresult standardDecoderTest(char * aTestName, char * aCharset, char * aSrc,
int32_t aSrcLen, PRUnichar * aRes, int32_t aResLen)
{
printf("\n[%s] Unicode <- %s\n", aTestName, aCharset);
// create converter
CREATE_DECODER(aCharset);
// test converter - easy test
res = testDecoder(dec, aSrc, aSrcLen, aRes, aResLen, aTestName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, aTestName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, aSrc, aSrcLen, aRes, aResLen, aTestName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
nsresult loadBinaryFile(char * aFile, char * aBuff, int32_t * aBuffLen)
{
FILE * f = fopen(aFile, "rb");
if (!f) {
printf("ERROR at opening file: \"%s\".\n", aFile);
return NS_ERROR_UNEXPECTED;
}
int32_t n = fread(aBuff, 1, *aBuffLen, f);
if (n >= *aBuffLen) {
printf("ERROR at reading from file \"%s\": too much input data.\n", aFile);
return NS_ERROR_UNEXPECTED;
}
*aBuffLen = n;
fclose(f);
return NS_OK;
}
nsresult loadUnicodeFile(char * aFile, PRUnichar * aBuff, int32_t * aBuffLen)
{
int32_t buffLen = 2*(*aBuffLen);
nsresult res = loadBinaryFile(aFile, (char *)aBuff, &buffLen);
if (NS_FAILED(res)) return res;
*aBuffLen = buffLen/2;
return NS_OK;
}
nsresult testDecoderFromFiles(char * aCharset, char * aSrcFile, char * aResultFile)
{
// create converter
CREATE_DECODER(aCharset);
int32_t srcLen = GENERAL_BUFFER;
char src[GENERAL_BUFFER];
int32_t expLen = GENERAL_BUFFER/2;
PRUnichar exp[GENERAL_BUFFER/2];
res = loadBinaryFile(aSrcFile, src, &srcLen);
if (NS_FAILED(res)) return res;
res = loadUnicodeFile(aResultFile, exp, &expLen);
if (NS_FAILED(res)) return res;
// test converter - easy test
res = testDecoder(dec, src, srcLen, exp, expLen, "dec");
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
return NS_OK;
}
nsresult testEncoderFromFiles(char * aCharset, char * aSrcFile, char * aResultFile)
{
// XXX write me
return NS_OK;
}
//----------------------------------------------------------------------
// Decoders testing functions
/**
* Test the ISO2022JP decoder.
*/
nsresult testISO2022JPDecoder()
{
char * testName = "T102";
printf("\n[%s] Unicode <- ISO2022JP\n", testName);
// create converter
CREATE_DECODER("iso-2022-jp");
// test data
char src[] = {"\x0d\x7f\xdd" "\x1b(J\xaa\xdc\x41" "\x1b$B\x21\x21" "\x1b$@\x32\x37" "\x1b(J\x1b(B\xcc"};
PRUnichar exp[] = {0x000d,0x007f,0xfffd, 0xff6a,0xFF9C,0x0041, 0x3000, 0x5378, 0xfffd};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the EUCJP decoder.
*/
nsresult testEUCJPDecoder()
{
char * testName = "T103";
printf("\n[%s] Unicode <- EUCJP\n", testName);
// create converter
CREATE_DECODER("euc-jp");
// test data
char src[] = {"\x45"};
PRUnichar exp[] = {0x0045};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the ISO88597 decoder.
*/
nsresult testISO88597Decoder()
{
char * testName = "T104";
printf("\n[%s] Unicode <- ISO88597\n", testName);
// create converter
CREATE_DECODER("iso-8859-7");
// test data
char src[] = {
"\x09\x0d\x20\x40"
"\x80\x98\xa3\xaf"
"\xa7\xb1\xb3\xc9"
"\xd9\xe3\xf4\xff"
};
PRUnichar exp[] = {
0x0009, 0x000d, 0x0020, 0x0040,
0xfffd, 0xfffd, 0x00a3, 0x2015,
0x00a7, 0x00b1, 0x00b3, 0x0399,
0x03a9, 0x03b3, 0x03c4, 0xfffd
};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the SJIS decoder.
*/
nsresult testSJISDecoder()
{
char * testName = "T105";
printf("\n[%s] Unicode <- SJIS\n", testName);
// create converter
CREATE_DECODER("Shift_JIS");
// test data
char src[] = {
"Japanese" /* English */
"\x8a\xbf\x8e\x9a" /* Kanji */
"\x83\x4a\x83\x5e\x83\x4a\x83\x69" /* Kantakana */
"\x82\xd0\x82\xe7\x82\xaa\x82\xc8" /* Hiragana */
"\x82\x50\x82\x51\x82\x52\x82\x60\x82\x61\x82\x62" /* full width 123ABC */
};
PRUnichar exp[] = {
0x004A, 0x0061, 0x0070, 0x0061, 0x006E, 0x0065, 0x0073, 0x0065,
0x6f22, 0x5b57,
0x30ab, 0x30bf, 0x30ab, 0x30ca,
0x3072, 0x3089, 0x304c, 0x306a,
0xff11, 0xff12, 0xff13, 0xff21, 0xff22, 0xff23
};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the UTF8 decoder.
*/
nsresult testUTF8Decoder()
{
char * testName = "T106";
printf("\n[%s] Unicode <- UTF8\n", testName);
// create converter
CREATE_DECODER("utf-8");
#ifdef NOPE // XXX decomment this when I have test data
// test data
char src[] = {};
PRUnichar exp[] = {};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
#endif
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the M-UTF-7 decoder.
*/
nsresult testMUTF7Decoder()
{
char * testName = "T107";
printf("\n[%s] Unicode <- MUTF7\n", testName);
// create converter
CREATE_DECODER("x-imap4-modified-utf7");
// test data
char src[] = {"\x50\x51\x52\x53&AAAAAAAA-&-&AAA-"};
PRUnichar exp[] = {0x0050,0x0051,0x0052,0x0053,0x0000,0x0000,0x0000,'&',0x0000};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the UTF-7 decoder.
*/
nsresult testUTF7Decoder()
{
char * testName = "T108";
printf("\n[%s] Unicode <- UTF7\n", testName);
// create converter
CREATE_DECODER("utf-7");
// test data
char src[] = {"+ADwAIQ-DOC"};
PRUnichar exp[] = {'<','!','D','O','C'};
// test converter - normal operation
res = testDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetDecoder(dec, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressDecoder(dec, src, ARRAY_SIZE(src)-1, exp, ARRAY_SIZE(exp), testName);
// release converter
NS_RELEASE(dec);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
//----------------------------------------------------------------------
// Encoders testing functions
/**
* Test the Latin1 encoder.
*/
nsresult testLatin1Encoder()
{
char * testName = "T201";
printf("\n[%s] Unicode -> Latin1\n", testName);
// create converter
CREATE_ENCODER("iso-8859-1");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {0x0001,0x0002,0xffff,0x00e3};
char exp[] = {"\x01\x02\xcc\xe3"};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the Shift-JIS encoder.
*/
nsresult testSJISEncoder()
{
char * testName = "T202";
printf("\n[%s] Unicode -> SJIS\n", testName);
// create converter
CREATE_ENCODER("Shift_JIS");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {
0x004A, 0x0061, 0x0070, 0x0061, 0x006E, 0x0065, 0x0073, 0x0065,
0x6f22, 0x5b57,
0x30ab, 0x30bf, 0x30ab, 0x30ca,
0x3072, 0x3089, 0x304c, 0x306a,
0xff11, 0xff12, 0xff13, 0xff21, 0xff22, 0xff23
};
char exp[] = {
"Japanese" /* English */
"\x8a\xbf\x8e\x9a" /* Kanji */
"\x83\x4a\x83\x5e\x83\x4a\x83\x69" /* Kantakana */
"\x82\xd0\x82\xe7\x82\xaa\x82\xc8" /* Hiragana */
"\x82\x50\x82\x51\x82\x52\x82\x60\x82\x61\x82\x62" /* full width 123ABC */
};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the EUC-JP encoder.
*/
nsresult testEUCJPEncoder()
{
char * testName = "T203";
printf("\n[%s] Unicode -> EUCJP\n", testName);
// create converter
CREATE_ENCODER("euc-jp");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {0x0045, 0x0054};
char exp[] = {"\x45\x54"};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the ISO-2022-JP encoder.
*/
nsresult testISO2022JPEncoder()
{
char * testName = "T204";
printf("\n[%s] Unicode -> ISO2022JP\n", testName);
// create converter
CREATE_ENCODER("iso-2022-jp");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {0x000d,0x007f, 0xff6a,0xFF9C, 0x3000, 0x5378};
char exp[] = {"\x0d\x7f" "\x1b(J\xaa\xdc" "\x1b$@\x21\x21\x32\x37\x1b(B"};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the M-UTF-7 encoder.
*/
nsresult testMUTF7Encoder()
{
char * testName = "T205";
printf("\n[%s] Unicode -> MUTF-7\n", testName);
// create converter
CREATE_ENCODER("x-imap4-modified-utf7");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {0x0050,0x0051,0x0052,0x0053,0x0000,0x0000,0x0000,'&',0x0000};
char exp[] = {"\x50\x51\x52\x53&AAAAAAAA-&-&AAA-"};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
/**
* Test the UTF-7 encoder.
*/
nsresult testUTF7Encoder()
{
char * testName = "T206";
printf("\n[%s] Unicode -> UTF-7\n", testName);
// create converter
CREATE_ENCODER("utf-7");
enc->SetOutputErrorBehavior(enc->kOnError_Replace, nullptr, 0x00cc);
// test data
PRUnichar src[] = {'e','t','i','r','a',0x0a};
char exp[] = {"etira\x0a"};
// test converter - easy test
res = testEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// reset converter
if (NS_SUCCEEDED(res)) res = resetEncoder(enc, testName);
// test converter - stress test
if (NS_SUCCEEDED(res))
res = testStressEncoder(enc, src, ARRAY_SIZE(src), exp, ARRAY_SIZE(exp)-1, testName);
// release converter
NS_RELEASE(enc);
if (NS_FAILED(res)) {
return res;
} else {
printf("Test Passed.\n");
return NS_OK;
}
}
nsresult testPlatformCharset()
{
nsIPlatformCharset *cinfo;
nsresult res = CallGetService(kPlatformCharsetCID, &cinfo);
if (NS_FAILED(res)) {
printf("ERROR at GetService() code=0x%x.\n",res);
return res;
}
nsString value;
res = cinfo->GetCharset(kPlatformCharsetSel_PlainTextInClipboard , value);
printf("Clipboard plain text encoding = %s\n", NS_LossyConvertUTF16toASCII(value).get());
res = cinfo->GetCharset(kPlatformCharsetSel_FileName , value);
printf("File Name encoding = %s\n", NS_LossyConvertUTF16toASCII(value).get());
res = cinfo->GetCharset(kPlatformCharsetSel_Menu , value);
printf("Menu encoding = %s\n", NS_LossyConvertUTF16toASCII(value).get());
cinfo->Release();
return res;
}
//----------------------------------------------------------------------
// Testing functions
nsresult testAll()
{
nsresult res;
// test the manager(s)
res = testCharsetConverterManager();
if (NS_FAILED(res)) return res;
testPlatformCharset();
// test decoders
standardDecoderTest("T101", "ISO-8859-1", bLatin1_d0, bLatin1_s0, cLatin1_d0, cLatin1_s0);
testISO2022JPDecoder();
testEUCJPDecoder();
testISO88597Decoder();
testSJISDecoder();
testUTF8Decoder();
testMUTF7Decoder();
testUTF7Decoder();
// test encoders
testLatin1Encoder();
testSJISEncoder();
testEUCJPEncoder();
testISO2022JPEncoder();
testMUTF7Encoder();
testUTF7Encoder();
// return
return NS_OK;
}
nsresult testFromArgs(int argc, char **argv)
{
nsresult res = NS_OK;
if ((argc == 5) && (!strcmp(argv[1], "-tdec"))) {
res = testDecoderFromFiles(argv[2], argv[3], argv[4]);
} else if ((argc == 5) && (!strcmp(argv[1], "-tenc"))) {
res = testEncoderFromFiles(argv[2], argv[3], argv[4]);
} else {
printf("Usage:\n");
printf(" TestUConv.exe\n");
printf(" TestUConv.exe -tdec encoding inputEncodedFile expectedResultUnicodeFile\n");
printf(" TestUConv.exe -tenc encoding inputUnicodeFile expectedResultEncodedFile\n");
}
return res;
}
//----------------------------------------------------------------------
// Main program functions
nsresult init()
{
nsresult rv = NS_InitXPCOM2(nullptr, nullptr, nullptr);
if (NS_FAILED(rv))
return rv;
return CallGetService(kCharsetConverterManagerCID, &ccMan);
}
nsresult done()
{
NS_RELEASE(ccMan);
return NS_OK;
}
int main(int argc, char **argv)
{
nsresult res;
res = init();
if (NS_FAILED(res)) return -1;
if (argc <= 1) {
printf("*** Unicode Converters Test ***\n");
res = testAll();
printf("\n***--------- Done --------***\n");
} else {
res = testFromArgs(argc, argv);
}
done();
if (NS_FAILED(res)) return -1;
else return 0;
}