/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
 */

/*
 * This program tests that wcsrtombs and friends work properly.
 * In order for it to work, it requires that some additional locales
 * be installed.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <wchar.h>
#include <err.h>
#include <errno.h>
#include <unistd.h>
#include <xlocale.h>
#include <note.h>
#include "test_common.h"

int extra_debug = 0;

#define NUMTHR  300
#define NUMITR  300

/*
 * Note that this file is easiest edited with a UTF-8 capable editor,
 * as there are embedded UTF-8 symbols in some of the strings.
 */
struct wcsrtombs_test {
        char            mbs[32];
        wchar_t         wcs[32];
};

#define TESTING_MBS     "TESTING"
#define TESTING_WCS     { 'T', 'E', 'S', 'T', 'I', 'N', 'G', 0 }
#define HELLO_RU_MBS    "ПРИВЕТ"
#define HELLO_RU_WCS    { 1055, 1056, 1048, 1042, 1045, 1058, 0 }
#define HELLO_EN_MBS    "HELLO"
#define HELLO_EN_WCS    { 'H', 'E', 'L', 'L', 'O', 0 }

/* Unicode values never have the high order bit set */
#define BAD_WCS         { 'B', 'A', 'D', (wchar_t)0xf000f000, 'W', 'C', 'S' }

struct wcsrtombs_test C_data[] = {
        { TESTING_MBS,  TESTING_WCS },
        { HELLO_EN_MBS, HELLO_EN_WCS },
        { 0, 0 },
};

struct wcsrtombs_test utf8_data[] = {
        { TESTING_MBS,  TESTING_WCS },
        { HELLO_EN_MBS, HELLO_EN_WCS },
        { HELLO_RU_MBS, HELLO_RU_WCS },
        { 0, 0 },
};

struct {
        const char *locale;
        struct wcsrtombs_test *test;
} locales[] =  {
        { "C",                  C_data },
        { "en_US.UTF-8",        utf8_data },
        { NULL,                 NULL }
};

void
test_wcsrtombs_1(const char *locale, struct wcsrtombs_test *test)
{
        test_t          t;
        char            *v;
        mbstate_t       ms;

        t = test_start("wcsrtombs (locale %s)", locale);

        v = setlocale(LC_ALL, locale);
        if (v == NULL) {
                test_failed(t, "setlocale failed: %s", strerror(errno));
        }
        if (strcmp(v, locale) != 0) {
                test_failed(t, "setlocale got %s instead of %s", v, locale);
        }

        for (int i = 0; test[i].mbs[0] != 0; i++) {
                char mbs[32];
                const wchar_t *wcs = test[i].wcs;
                size_t cnt;

                (void) memset(&ms, 0, sizeof (ms));
                (void) memset(mbs, 0, sizeof (mbs));
                cnt = wcsrtombs(mbs, &wcs, sizeof (mbs), &ms);
                if (cnt != strlen(test[i].mbs)) {
                        test_failed(t, "incorrect return value: %d != %d",
                            cnt, strlen(test[i].mbs));
                }
                if (strcmp(mbs, test[i].mbs) != 0) {
                        test_failed(t, "wrong result: %s != %s",
                            mbs, test[i].mbs);
                }
                if (extra_debug) {
                        test_debugf(t, "mbs is %s", mbs);
                }
        }
        test_passed(t);
}

void
test_wcsrtombs_l(const char *locale, struct wcsrtombs_test *test)
{
        test_t  t;
        locale_t loc;
        char    *v;
        mbstate_t       ms;

        t = test_start("wcsrtombs_l (locale %s)", locale);

        v = setlocale(LC_ALL, "C");
        if (v == NULL) {
                test_failed(t, "setlocale failed: %s", strerror(errno));
        }
        if (strcmp(v, "C") != 0) {
                test_failed(t, "setlocale got %s instead of %s", v, "C");
        }

        loc = newlocale(LC_ALL_MASK, locale, NULL);
        if (loc == NULL) {
                test_failed(t, "newlocale failed: %s", strerror(errno));
        }

        for (int i = 0; test[i].mbs[0] != 0; i++) {
                char mbs[32];
                const wchar_t *wcs = test[i].wcs;
                size_t cnt;

                (void) memset(&ms, 0, sizeof (ms));
                (void) memset(mbs, 0, sizeof (mbs));
                cnt = wcsrtombs_l(mbs, &wcs, sizeof (mbs), &ms, loc);
                if (cnt != strlen(test[i].mbs)) {
                        test_failed(t, "incorrect return value: %d != %d",
                            cnt, strlen(test[i].mbs));
                }
                if (strcmp(mbs, test[i].mbs) != 0) {
                        test_failed(t, "wrong result: %s != %s", mbs,
                            test[i].mbs);
                }
                if (extra_debug) {
                        test_debugf(t, "mbs is %s", mbs);
                }
        }
        test_passed(t);
}

void
test_wcsrtombs_thr_iter(test_t t, const char *locale,
    struct wcsrtombs_test *test)
{
        locale_t loc;
        mbstate_t       ms;

        loc = newlocale(LC_ALL_MASK, locale, NULL);
        if (loc == NULL) {
                test_failed(t, "newlocale failed: %s", strerror(errno));
        }

        for (int i = 0; test[i].mbs[0] != 0; i++) {
                char mbs[32];
                const wchar_t *wcs = test[i].wcs;
                size_t cnt;

                (void) memset(&ms, 0, sizeof (ms));
                (void) memset(mbs, 0, sizeof (mbs));
                cnt = wcsrtombs_l(mbs, &wcs, sizeof (mbs), &ms, loc);
                if (cnt != strlen(test[i].mbs)) {
                        test_failed(t, "incorrect return value: %d != %d",
                            cnt, strlen(test[i].mbs));
                }
                if (strcmp(mbs, test[i].mbs) != 0) {
                        test_failed(t, "wrong result: %s != %s", mbs,
                            test[i].mbs);
                }
                if (extra_debug) {
                        test_debugf(t, "mbs is %s", mbs);
                }
        }

        freelocale(loc);
}

void
test_wcsrtombs_thr_work(test_t t, void *arg)
{
        _NOTE(ARGUNUSED(arg));
        for (int j = 0; j < NUMITR; j++) {
                test_debugf(t, "iteration %d", j);
                for (int i = 0; locales[i].locale != NULL; i++) {
                        test_wcsrtombs_thr_iter(t, locales[i].locale,
                            locales[i].test);
                }
        }
        test_passed(t);
}

void
test_wcsrtombs_threaded(void)
{
        (void) setlocale(LC_ALL, "C");
        test_run(NUMTHR, test_wcsrtombs_thr_work, NULL, "wcsrtombs_threaded");
}

void
test_wcsrtombs_partial(void)
{
        test_t          t;
        mbstate_t       ms;
        wchar_t         src[32] = HELLO_RU_WCS;
        char            mbs[32];
        char            *dst;
        const wchar_t   *wcs;
        size_t          cnt;


        (void) memset(&ms, 0, sizeof (ms));
        t = test_start("wcsrtombs_partial");

        if (setlocale(LC_ALL, "ru_RU.UTF-8") == NULL) {
                test_failed(t, "setlocale failed: %s", strerror(errno));
        }

        wcs = src;
        dst = mbs;
        cnt = wcsrtombs(dst, &wcs, 1, &ms);
        if (cnt != 0) {
                test_failed(t, "gave back a conversion cnt %d != 0", cnt);
        }
        if (wcs != src) {
                test_failed(t, "incorrectly advanced wcs");
        }

        cnt = wcsrtombs(dst, &wcs, 2, &ms);
        if (cnt != 2) {
                test_failed(t, "gave back a conversion cnt %d != 2", cnt);
        }
        dst += cnt;

        cnt = wcsrtombs(dst, &wcs, 4, &ms);
        dst += cnt;

        cnt = wcsrtombs(dst, &wcs, sizeof (mbs) - strlen(mbs), &ms);
        if (extra_debug) {
                test_debugf(t, "mbs is %s", mbs);
        }
        if (strcmp(mbs, HELLO_RU_MBS) != 0) {
                test_failed(t, "wrong result: %s != %s", mbs, HELLO_RU_MBS);
        }
        test_passed(t);
}

void
test_wcsrtombs_negative(void)
{
        mbstate_t       ms;
        const wchar_t   *wcs;
        char            mbs[32];
        char            *dst;
        int             e;
        wchar_t         src[32] = BAD_WCS;
        test_t          t;
        int             cnt;

        t = test_start("wcsrtombs_negative");

        (void) memset(&ms, 0, sizeof (ms));
        if (setlocale(LC_ALL, "ru_RU.UTF-8") == NULL) {
                test_failed(t, "setlocale failed: %s", strerror(errno));
        }

        wcs = src;
        dst = mbs;
        cnt = wcsrtombs(dst, &wcs, sizeof (mbs), &ms);
        if (cnt != -1) {
                test_failed(t, "bogus success (%d)", cnt);
        }
        if ((e = errno) != EILSEQ) {
                test_failed(t, "wrong errno, wanted %d (EILSEQ), got %d: %s",
                    EILSEQ, e, strerror(e));
        }
        test_passed(t);
}

void
test_wcsnrtombs_partial(void)
{
        test_t          t;
        mbstate_t       ms;
        wchar_t         src[32] = HELLO_RU_WCS;
        char            mbs[32];
        char            *dst;
        const wchar_t   *wcs;
        size_t          cnt;


        (void) memset(&ms, 0, sizeof (ms));
        t = test_start("wcsrntombs_partial");

        if (setlocale(LC_ALL, "ru_RU.UTF-8") == NULL) {
                test_failed(t, "setlocale failed: %s", strerror(errno));
        }

        wcs = src;
        dst = mbs;
        cnt = wcsnrtombs(dst, &wcs, 1, 1, &ms);
        if (cnt != 0) {
                test_failed(t, "gave back a conversion cnt %d != 0", cnt);
        }
        if (wcs != src) {
                test_failed(t, "incorrectly advanced wcs");
        }

        /* we should get just 2 wide characters (expanding to 4 bytes) */
        cnt = wcsnrtombs(dst, &wcs, 2, sizeof (mbs), &ms);
        if (cnt != 4) {
                test_failed(t, "gave back a conversion cnt %d != 4", cnt);
        }
        dst += cnt;

        cnt = wcsnrtombs(dst, &wcs, 32, sizeof (mbs) - strlen(mbs), &ms);
        if (extra_debug) {
                test_debugf(t, "mbs is %s", mbs);
        }
        if (strcmp(mbs, HELLO_RU_MBS) != 0) {
                test_failed(t, "wrong result: %s != %s", mbs, HELLO_RU_MBS);
        }
        test_passed(t);
}

void
test_wcsrtombs(void)
{
        for (int i = 0; locales[i].locale != NULL; i++) {
                test_wcsrtombs_1(locales[i].locale, locales[i].test);
                test_wcsrtombs_l(locales[i].locale, locales[i].test);
        }
}

int
main(int argc, char **argv)
{
        int optc;

        while ((optc = getopt(argc, argv, "dfD")) != EOF) {
                switch (optc) {
                case 'd':
                        test_set_debug();
                        break;
                case 'f':
                        test_set_force();
                        break;
                case 'D':
                        test_set_debug();
                        extra_debug++;
                        break;
                default:
                        (void) fprintf(stderr, "Usage: %s [-dfD]\n", argv[0]);
                        exit(1);
                }
        }

        test_wcsrtombs();
        test_wcsrtombs_partial();
        test_wcsrtombs_negative();
        test_wcsrtombs_threaded();
        test_wcsnrtombs_partial();

        exit(0);
}