case_test.c File Reference

#include "postgres_fe.h"
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wctype.h>
#include "common/unicode_case.h"
#include "common/unicode_category.h"
#include "common/unicode_version.h"
#include "mb/pg_wchar.h"

Include dependency graph for case_test.c:

Go to the source code of this file.

Data Structures
struct	WordBoundaryState

Macros
#define	BUFSZ   256

Typedefs
typedef size_t(*	TestFunc) (char *dst, size_t dstsize, const char *src, ssize_t srclen)

Functions
static size_t	initcap_wbnext (void *state)
static void	test_convert (TestFunc tfunc, const char *test_string, const char *expected)
static size_t	tfunc_lower (char *dst, size_t dstsize, const char *src, ssize_t srclen)
static size_t	tfunc_title (char *dst, size_t dstsize, const char *src, ssize_t srclen)
static size_t	tfunc_upper (char *dst, size_t dstsize, const char *src, ssize_t srclen)
static size_t	tfunc_fold (char *dst, size_t dstsize, const char *src, ssize_t srclen)
static void	test_convert_case ()
int	main (int argc, char **argv)

Macro Definition Documentation

BUFSZ

#define BUFSZ   256

Definition at line 30 of file case_test.c.

Typedef Documentation

TestFunc

typedef size_t(* TestFunc) (char *dst, size_t dstsize, const char *src, ssize_t srclen)

Definition at line 36 of file case_test.c.

Function Documentation

initcap_wbnext()

static size_t initcap_wbnext ( void *  state )

static

Definition at line 51 of file case_test.c.

{
    struct WordBoundaryState *wbstate = (struct WordBoundaryState *) state;
 
    while (wbstate->offset < wbstate->len &&
           wbstate->str[wbstate->offset] != '\0')
    {
        char32_t    u = utf8_to_unicode((unsigned char *) wbstate->str +
                                        wbstate->offset);
        bool        curr_alnum = pg_u_isalnum(u, wbstate->posix);
 
        if (!wbstate->init || curr_alnum != wbstate->prev_alnum)
        {
            size_t      prev_offset = wbstate->offset;
 
            wbstate->init = true;
            wbstate->offset += unicode_utf8len(u);
            wbstate->prev_alnum = curr_alnum;
            return prev_offset;
        }
 
        wbstate->offset += unicode_utf8len(u);
    }
 
    return wbstate->len;
}

References WordBoundaryState::init, WordBoundaryState::len, WordBoundaryState::offset, pg_u_isalnum(), WordBoundaryState::posix, WordBoundaryState::prev_alnum, WordBoundaryState::str, unicode_utf8len(), and utf8_to_unicode().

Referenced by tfunc_title().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 377 of file case_test.c.

{
#ifdef USE_ICU
    UErrorCode  status = U_ZERO_ERROR;
 
    /*
     * Disable ICU's word break adjustment for titlecase to match the expected
     * behavior of unicode_strtitle().
     */
    casemap = ucasemap_open("und", U_TITLECASE_NO_BREAK_ADJUSTMENT, &status);
    if (U_FAILURE(status))
    {
        printf("case_test: failure opening UCaseMap: %s\n",
               u_errorName(status));
        exit(1);
    }
#endif
 
    printf("case_test: Postgres Unicode version:\t%s\n", PG_UNICODE_VERSION);
#ifdef USE_ICU
    printf("case_test: ICU Unicode version:\t\t%s\n", U_UNICODE_VERSION);
    test_icu();
#else
    printf("case_test: ICU not available; skipping\n");
#endif
 
    test_convert_case();
 
#ifdef USE_ICU
    ucasemap_close(casemap);
#endif
    exit(0);
}

References casemap(), PG_UNICODE_VERSION, printf, and test_convert_case().

test_convert()

static void test_convert ( TestFunc  tfunc, const char *  test_string, const char *  expected  )

static

Definition at line 209 of file case_test.c.

{
    size_t      src1len = strlen(test_string);
    size_t      src2len = -1;   /* NUL-terminated */
    size_t      dst1len = strlen(expected);
    size_t      dst2len = strlen(expected) + 1; /* NUL-terminated */
    char       *src1 = malloc(src1len);
    char       *dst1 = malloc(dst1len);
    char       *src2 = strdup(test_string);
    char       *dst2 = malloc(dst2len);
    size_t      needed;
 
    memcpy(src1, test_string, src1len); /* not NUL-terminated */
 
    /* neither source nor destination are NUL-terminated */
    memset(dst1, 0x7F, dst1len);
    needed = tfunc(dst1, dst1len, src1, src1len);
    if (needed != strlen(expected))
    {
        printf("case_test: convert_case test1 FAILURE: '%s' needed %zu expected %zu\n",
               test_string, needed, strlen(expected));
        exit(1);
    }
    if (memcmp(dst1, expected, dst1len) != 0)
    {
        printf("case_test: convert_case test1 FAILURE: test: '%s' result: '%.*s' expected: '%s'\n",
               test_string, (int) dst1len, dst1, expected);
        exit(1);
    }
 
    /* destination is NUL-terminated and source is not */
    memset(dst2, 0x7F, dst2len);
    needed = tfunc(dst2, dst2len, src1, src1len);
    if (needed != strlen(expected))
    {
        printf("case_test: convert_case test2 FAILURE: '%s' needed %zu expected %zu\n",
               test_string, needed, strlen(expected));
        exit(1);
    }
    if (strcmp(dst2, expected) != 0)
    {
        printf("case_test: convert_case test2 FAILURE: test: '%s' result: '%s' expected: '%s'\n",
               test_string, dst2, expected);
        exit(1);
    }
 
    /* source is NUL-terminated and destination is not */
    memset(dst1, 0x7F, dst1len);
    needed = tfunc(dst1, dst1len, src2, src2len);
    if (needed != strlen(expected))
    {
        printf("case_test: convert_case test3 FAILURE: '%s' needed %zu expected %zu\n",
               test_string, needed, strlen(expected));
        printf("case_test: convert_case test3 FAILURE: needed %zu\n", needed);
        exit(1);
    }
    if (memcmp(dst1, expected, dst1len) != 0)
    {
        printf("case_test: convert_case test3 FAILURE: test: '%s' result: '%.*s' expected: '%s'\n",
               test_string, (int) dst1len, dst1, expected);
        exit(1);
    }
 
    /* both source and destination are NUL-terminated */
    memset(dst2, 0x7F, dst2len);
    needed = tfunc(dst2, dst2len, src2, src2len);
    if (needed != strlen(expected))
    {
        printf("case_test: convert_case test4 FAILURE: '%s' needed %zu expected %zu\n",
               test_string, needed, strlen(expected));
        exit(1);
    }
    if (strcmp(dst2, expected) != 0)
    {
        printf("case_test: convert_case test4 FAILURE: test: '%s' result: '%s' expected: '%s'\n",
               test_string, dst2, expected);
        exit(1);
    }
 
    free(src1);
    free(dst1);
    free(src2);
    free(dst2);
}

References free, malloc, and printf.

Referenced by test_convert_case().

test_convert_case()

static void test_convert_case ( )

static

Definition at line 332 of file case_test.c.

{
    /* test string with no case changes */
    test_convert(tfunc_lower, "√∞", "√∞");
    /* test adjust-to-cased behavior */
    test_convert(tfunc_title, "abc 123xyz", "Abc 123xyz");
    /* test string with case changes */
    test_convert(tfunc_upper, "abc", "ABC");
    /* test string with case changes and byte length changes */
    test_convert(tfunc_lower, "ȺȺȺ", "ⱥⱥⱥ");
    /* test special case conversions */
    test_convert(tfunc_upper, "ß", "SS");
    test_convert(tfunc_lower, "ıiIİ", "ıiii\u0307");
    test_convert(tfunc_upper, "ıiIİ", "IIIİ");
    test_convert(tfunc_fold, "ıiIİ", "ıiii\u0307");
    /* test final sigma */
    test_convert(tfunc_lower, "σςΣ ΣΣΣ", "σςς σσς");
    test_convert(tfunc_lower, "σς'Σ' ΣΣ'Σ'", "σς'ς' σσ'ς'");
    test_convert(tfunc_title, "σςΣ ΣΣΣ", "Σςς Σσς");
    test_convert(tfunc_fold, "σςΣ ΣΣΣ", "σσσ σσσ");
    /* test that alphanumerics are word characters */
    test_convert(tfunc_title, "λλ", "Λλ");
    test_convert(tfunc_title, "1a", "1a");
    /* U+FF11 FULLWIDTH ONE is alphanumeric for full case mapping */
    test_convert(tfunc_title, "\uFF11a", "\uFF11a");
 
 
#ifdef USE_ICU
    icu_test_full("");
    icu_test_full("ȺȺȺ");
    icu_test_full("ßßß");
    icu_test_full("√∞");
    icu_test_full("a b");
    icu_test_full("abc 123xyz");
    icu_test_full("σςΣ ΣΣΣ");
    icu_test_full("ıiIİ");
    icu_test_full("\uFF11a");
    /* test <alpha><iota_subscript><acute> */
    icu_test_full("\u0391\u0345\u0301");
#endif
 
    printf("case_test: convert_case: success\n");
}

References printf, test_convert(), tfunc_fold(), tfunc_lower(), tfunc_title(), and tfunc_upper().

Referenced by main().

tfunc_fold()

static size_t tfunc_fold ( char *  dst, size_t  dstsize, const char *  src, ssize_t  srclen  )

static

Definition at line 325 of file case_test.c.

{
    return unicode_strfold(dst, dstsize, src, srclen, true);
}

References unicode_strfold().

Referenced by test_convert_case().

tfunc_lower()

static size_t tfunc_lower ( char *  dst, size_t  dstsize, const char *  src, ssize_t  srclen  )

static

Definition at line 295 of file case_test.c.

{
    return unicode_strlower(dst, dstsize, src, srclen, true);
}

References unicode_strlower().

Referenced by test_convert_case().

tfunc_title()

static size_t tfunc_title ( char *  dst, size_t  dstsize, const char *  src, ssize_t  srclen  )

static

Definition at line 302 of file case_test.c.

{
    struct WordBoundaryState wbstate = {
        .str = src,
        .len = srclen,
        .offset = 0,
        .init = false,
        .prev_alnum = false,
    };
 
    return unicode_strtitle(dst, dstsize, src, srclen, true, initcap_wbnext,
                            &wbstate);
}

References initcap_wbnext(), WordBoundaryState::str, and unicode_strtitle().

Referenced by test_convert_case().

tfunc_upper()

static size_t tfunc_upper ( char *  dst, size_t  dstsize, const char *  src, ssize_t  srclen  )

static

Definition at line 318 of file case_test.c.

{
    return unicode_strupper(dst, dstsize, src, srclen, true);
}

References unicode_strupper().

Referenced by test_convert_case().