root/lang/objective-cplusplus/i3/trunk/src/tests/TestNLS.cc @ 37684

#include <mil/PrecompiledHeaders.h>
#include <algorithm>
#include <boost/range.hpp>

#include <mil/MscCrt.h>
#include "Common.h"
#include "Mediator.h"
#include <quicktest/quicktest.h>

#ifdef ENABLE_NLS
#include <iconv.h>
#endif

using namespace std;
using namespace boost;
using namespace i3;

namespace test_nls {

#ifdef UNICODE
QT_TEST(iconv_ascii_to_utf16le) {
    iconv_t cd = iconv_open("UTF-16LE", "ASCII");
    if (cd == (iconv_t)-1) {
        QT_CHECK(0 && (int)"iconv_open() failed");
        return;
    }

    char ascii[] = "ABC+++";
    size_t ascii_bytes = sizeof(ascii) - 1;
    char* ascii_pointer = ascii;

    char utf16le[30] = {};
    size_t utf16le_bytes = sizeof(utf16le) - 2;
    char* utf16le_pointer = utf16le;

    iconv(cd,
          (ICONV_CONST char**)&ascii_pointer, &ascii_bytes,
          (char**)&utf16le_pointer, &utf16le_bytes);

    QT_CHECK(utf16le[0] == 0x41);
    QT_CHECK(utf16le[1] == 0);
    QT_CHECK(utf16le[2] == 0x42);
    QT_CHECK(utf16le[3] == 0);
    QT_CHECK(utf16le[4] == 0x43);
    QT_CHECK(utf16le[5] == 0);

    iconv_close(cd);
}
QT_TEST(wgettext_ascii7bit_to_utf16le) {
    const char* buf = (const char*)wgettext("DEF+++");
    QT_CHECK(buf[0] == 0x44);
    QT_CHECK(buf[1] == 0);
    QT_CHECK(buf[2] == 0x45);
    QT_CHECK(buf[3] == 0);
    QT_CHECK(buf[4] == 0x46);
    QT_CHECK(buf[5] == 0);
}
#endif

#ifdef ENABLE_NLS
void dump_string(const TCHAR* str) {
    int bytes = _tcslen(str) * sizeof(TCHAR);
    if (bytes >= 50) {
        bytes = 50;
    }
    printf("\"");
    for (int i = 0; i < bytes; i++) {
        unsigned char c = ((unsigned char*)str)[i];
        //if (isprint(c)) {
        if (isalnum(c)) {
            printf("%c", c);
        } else {
            printf(" ");
        }
    }        
    printf("\" {");
    for (int i = 0; i < bytes; i++) {
        if (i != 0) {
            printf(",");
        }
        unsigned char c = ((unsigned char*)str)[i];
        printf("%02x", c);
    }
    printf("}");
}

#define check_translation(key, expected) check_translation_(key, _(key), expected);

void check_translation_(const char* key, const TCHAR* got, const TCHAR* expected) {
    const int max_bytes = _tcslen(expected) * sizeof(TCHAR);
    bool is_translated = memcmp(got, expected, max_bytes) == 0; // XXX danger !
    
    QT_CHECK(is_translated);
    if (is_translated) {
        return;
    }

    printf("    expected = ");
    dump_string(expected);
    printf("\n");
    printf("    got      = ");
    dump_string(got);
    printf("\n");
}

/** Cygwin distcheck ok
const char* LOCALE_ENV_LIST[] = {
        "LC_ALL",
#if MIL_OS_UNIX
        "LANG",
        "LANGUAGE",
#endif
#if 0
        "LC_ADDRESS",
        "LC_COLLATE",
        "LC_CTYPE",
        "LC_IDENTIFICATION",
        "LC_MEASUREMENT",
        "LC_MESSAGES",
        "LC_MONETARY",
        "LC_NAME",
        "LC_NUMERIC",
        "LC_PAPER",
        "LC_TELEPHONE",
        "LC_TIME",
#endif
        0
    };
int set_locale(const char* locale) {
    for (unsigned int i = 0; LOCALE_ENV_LIST[i]; i++) {
        my_setenv(LOCALE_ENV_LIST[i], locale);
    }

#ifdef MIL_OS_UNIX
    setlocale(LC_ALL, locale);
    textdomain(PACKAGE_NAME);
#endif

    return 0;
}
*/

/** Cygwin distcheck ok 2
const char* LOCALE_ENV_LIST[] = {
        "LC_ALL",
        "LANG",
        "LANGUAGE",
        0
    };
int set_locale(const char* locale) {
    for (unsigned int i = 0; LOCALE_ENV_LIST[i]; i++) {
        my_setenv(LOCALE_ENV_LIST[i], locale);
    }
    return 0;
}
*/

const char* LOCALE_ENV_LIST[] = {
        "LC_ALL",
        "LANG",
        "LANGUAGE",
        0
    };

int set_locale(const char* locale) {
    for (unsigned int i = 0; LOCALE_ENV_LIST[i]; i++) {
        my_setenv(LOCALE_ENV_LIST[i], locale);
    }
    //if (setlocale(LC_ALL, locale) == -1) {
    //    return -1;
    //}
    setlocale(LC_ALL, "");
    //textdomain(PACKAGE_NAME);
    return 0;
}

void print_locale_env() {
    for (unsigned int i = 0; LOCALE_ENV_LIST[i]; i++) {
        printf("%s = %s\n", LOCALE_ENV_LIST[i], getenv(LOCALE_ENV_LIST[i]));
    }
}

QT_TEST(translation) {
    using namespace std;

    bool result = false;
#if UNICODE
    // UTF-16LE
    WCHAR hello_world_ja1[] = {
        0x4E16, 0x754C, 0x3088, 0x002C,
        0x0020, 0x3053, 0x3093, 0x306B,
        0x3061, 0x306F, 0x0021, 0
    };
    char hello_world_ja2[] = {
        0x16, 0x4e, 0x4c, 0x75, 0x88, 0x30, 0x01, 0x30,
        0x53, 0x30, 0x93, 0x30, 0x6b, 0x30, 0x61, 0x30,
        0x8f, 0x30, 0x28, 0x00, 0x60, 0x00, 0xfb, 0x30,
        0xc9, 0x03, 0xfb, 0x30, 0xb4, 0x00, 0x29, 0x00,
        0, 0
    };
    WCHAR* hello_world_ja = (WCHAR*)hello_world_ja2;
#else
    // UTF-8
    char hello_world_ja[] = {
        0xe4, 0xb8, 0x96, 0xe7, 0x95, 0x8c, 0xe3, 0x82,
        0x88, 0xe3, 0x80, 0x81, 0xe3, 0x81, 0x93, 0xe3,
        0x82, 0x93, 0xe3, 0x81, 0xab, 0xe3, 0x81, 0xa1,
        0xe3, 0x82, 0x8f, 0x28, 0x60, 0xe3, 0x83, 0xbb,
        0xcf, 0x89, 0xe3, 0x83, 0xbb, 0xc2, 0xb4, 0x29, 0
    };
#endif

    int argc = 0;
    char** argv = NULL;

    QT_CHECK(!init_common_global_data(argc, argv));
    QT_CHECK(!init_os_global_data(argc, argv));
    QT_CHECK(!init_gui_global_data(argc, argv));

#ifdef MIL_OS_UNIX
    {
        char cwd[mil::STACKABLE_MAX_PATH] = "";
        if (getcwd(cwd, _countof(cwd)) == NULL) {
            cerr << "getcwd() failed" << endl;
            QT_CHECK(false);
        }
        std::string test_localedir = cwd;
        test_localedir += "/locale";
        struct stat s;
        if (stat(test_localedir.c_str(), &s) == 0) {
            bindtextdomain(PACKAGE_NAME, test_localedir.c_str());
        }
    }
#endif

    QT_CHECK_NOT_EQUAL(set_locale("da_DK"), -1);
    check_translation("Hello, world!", _T("Hej verden!"));

#if MIL_OS_UNIX || defined(UNICODE)
    QT_CHECK_NOT_EQUAL(set_locale("ja_JP"), -1);
    check_translation("Hello, world!", hello_world_ja);
#endif

    QT_CHECK_NOT_EQUAL(set_locale("lv_LV"), -1);
    check_translation("Hello, world!", _T("Sveika, pasaule!"));
}

#endif

}