database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Merge branch '10.4' into 10.5

Browse Source
This commit is contained in:
Oleksandr Byelkin
2022-02-01 20:33:04 +01:00
parent fb40a2fabf c04a203a10
commit cf63eecef4
460 changed files with 9909 additions and 2408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

508
unittest/strings/strings-t.c
View File

@ -19,6 +19,30 @@
#include <my_sys.h>
/*
U+00DF LATIN SMALL LETTER SHARP S = _utf8 x'C39F' = _latin1 x'DF'
*/
#define UTF8_sz "\xC3\x9F"
#define LATIN1_sz "\xDF"
/*
U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE = _utf8 x'C385'
*/
#define UTF8_ARING "\xC3\x85"
/*
U+00E4 LATIN SMALL LETTER A WITH DIAERESIS = _utf8 x'C3A4'
*/
#define UTF8_auml "\xC3\xA4"
#define LATIN1_auml "\xE4"
#define UCS2_a "\x00\x61"
#define UCS2_b "\x00\x62"
#define UCS2_sp "\x00\x20"
/*
Test that like_range() returns well-formed results.
*/
@ -759,11 +783,483 @@ test_strcollsp()
}
int main()
typedef struct
{
LEX_CSTRING a;
LEX_CSTRING b;
size_t nchars;
int res;
} STRNNCOLLSP_CHAR_PARAM;
/*
Some lines in the below test data are marked as follows:
IF - An ignorable failure. The scanner finds an ignorable character
followed by a normal character (or by a contraction),
but the "nchars" limit allows only one character to be scanned.
The whole sequence is ignored an is treated as end-of-line.
CF - A contraction failure. The scanner finds a contraction consisting
of two characters, but the "nchars" limit allows only one character
to be scanned. The whole contraction is ignored and is treated
as end-of-line.
*/
/*
Tests for mbminlen1 character sets,
for both PAD SPACE and NOPAD collations
*/
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_mbminlen1_xpad_common[]=
{
{{CSTR("a")}, {CSTR("a")}, 0, 0},
{{CSTR("a")}, {CSTR("a")}, 1, 0},
{{CSTR("a")}, {CSTR("a")}, 2, 0},
{{CSTR("a")}, {CSTR("a")}, 3, 0},
{{CSTR("a")}, {CSTR("a")}, 100, 0},
{{CSTR("a")}, {CSTR("ab")}, 0, 0},
{{CSTR("a")}, {CSTR("ab")}, 1, 0},
{{CSTR("a")}, {CSTR("ab")}, 2, -1},
{{CSTR("a")}, {CSTR("ab")}, 3, -1},
{{CSTR("a")}, {CSTR("ab")}, 100, -1},
{{CSTR("a")}, {CSTR("a ")}, 0, 0},
{{CSTR("a")}, {CSTR("a ")}, 1, 0},
{{CSTR("a")}, {CSTR("a ")}, 2, 0},
{{CSTR("a")}, {CSTR("a ")}, 3, 0},
{{CSTR("a")}, {CSTR("a ")}, 100, 0},
{{CSTR("a")}, {CSTR("a ")}, 0, 0},
{{CSTR("a")}, {CSTR("a ")}, 1, 0},
{{CSTR("a")}, {CSTR("a ")}, 2, 0},
{{CSTR("a")}, {CSTR("a ")}, 3, 0},
{{CSTR("a")}, {CSTR("a ")}, 100, 0},
{{CSTR("ss")}, {CSTR("ss")}, 0, 0},
{{CSTR("ss")}, {CSTR("ss")}, 1, 0},
{{CSTR("ss")}, {CSTR("ss")}, 2, 0},
{{CSTR("ss")}, {CSTR("ss")}, 3, 0},
{{CSTR("ss")}, {CSTR("ss")}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
/* Tests for utf8, for both PAD SPACE and NOPAD collations */
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mbx_xpad_common[]=
{
{{CSTR(UTF8_sz)}, {CSTR(UTF8_sz)}, 0, 0},
{{CSTR(UTF8_sz)}, {CSTR(UTF8_sz)}, 1, 0},
{{CSTR(UTF8_sz)}, {CSTR(UTF8_sz)}, 2, 0},
{{CSTR(UTF8_sz)}, {CSTR(UTF8_sz)}, 3, 0},
{{CSTR(UTF8_sz)}, {CSTR(UTF8_sz)}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
/* Tests for latin1, for both PAD and NOPAD collations */
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_latin1_xpad_common[]=
{
{{CSTR(LATIN1_sz)}, {CSTR(LATIN1_sz)}, 0, 0},
{{CSTR(LATIN1_sz)}, {CSTR(LATIN1_sz)}, 1, 0},
{{CSTR(LATIN1_sz)}, {CSTR(LATIN1_sz)}, 2, 0},
{{CSTR(LATIN1_sz)}, {CSTR(LATIN1_sz)}, 3, 0},
{{CSTR(LATIN1_sz)}, {CSTR(LATIN1_sz)}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
/* Tests for utf8 collations that sort "A WITH DIAERESIS" equal to "A" */
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mbx_xpad_a_eq_auml[]=
{
{{CSTR(UTF8_auml "h")}, {CSTR("ah")}, 0, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah")}, 1, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah")}, 2, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah")}, 3, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah")}, 100, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah ")}, 0, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah ")}, 1, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah ")}, 2, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah ")}, 3, 0},
{{CSTR(UTF8_auml "h")}, {CSTR("ah ")}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mb3_unicode_ci[]=
{
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 0, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 1, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}/*IF*/, 2, 1},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 3, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 4, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 100, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 0, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 1, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 2, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 3, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 4, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mb3_unicode_nopad_ci[]=
{
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 0, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 1, 0},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}/*IF*/, 2, 1},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 3, 1},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 4, 1},
{{CSTR("ss")}, {CSTR("s" "\x00" "s")}, 100, 1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 0, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 1, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 2, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 3, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 4, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 100, -1},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mb3_danish_ci[]=
{
{{CSTR("aa")}, {CSTR("")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("")}, 1, 1},
{{CSTR("aa")}, {CSTR("")}, 2, 1},
{{CSTR("aa")}, {CSTR("")}, 3, 1},
{{CSTR("aa")}, {CSTR("")}, 100, 1},
{{CSTR("aa")}, {CSTR("a")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("a")}, 1, 0},
{{CSTR("aa")}, {CSTR("a")}, 2, 1},
{{CSTR("aa")}, {CSTR("a")}, 3, 1},
{{CSTR("aa")}, {CSTR("a")}, 100, 1},
{{CSTR("aa")}, {CSTR("aa")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("aa")}/*CF*/, 1, 0},
{{CSTR("aa")}, {CSTR("aa")}, 2, 0},
{{CSTR("aa")}, {CSTR("aa")}, 3, 0},
{{CSTR("aa")}, {CSTR("aa")}, 100, 0},
{{CSTR("aa")}, {CSTR("\x00" "a")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("\x00" "a")}/*IF*/, 1, 1},
{{CSTR("aa")}, {CSTR("\x00" "a")}, 2, 1},
{{CSTR("aa")}, {CSTR("\x00" "a")}, 3, 1},
{{CSTR("aa")}, {CSTR("\x00" "a")}, 100, 1},
{{CSTR("aa")}, {CSTR("\x00" "aa")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("\x00" "aa")}/*IF*/, 1, 1},
{{CSTR("aa")}, {CSTR("\x00" "aa")}/*IF*/, 2, 1},
{{CSTR("aa")}, {CSTR("\x00" "aa")}, 3, 0},
{{CSTR("aa")}, {CSTR("\x00" "aa")}, 100, 0},
{{CSTR("aa")}, {CSTR("a" "\x00" "a")}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR("a" "\x00" "a")}, 1, 0},
{{CSTR("aa")}, {CSTR("a" "\x00" "a")}/*IF*/, 2, 1},
{{CSTR("aa")}, {CSTR("a" "\x00" "a")}, 3, 1},
{{CSTR("aa")}, {CSTR("a" "\x00" "a")}, 100, 1},
{{CSTR("aa")}, {CSTR(UTF8_ARING)}, 0, 0},
{{CSTR("aa")}/*CF*/, {CSTR(UTF8_ARING)}, 1, -1},
{{CSTR("aa")}, {CSTR(UTF8_ARING)}, 2, 0},
{{CSTR("aa")}, {CSTR(UTF8_ARING)}, 3, 0},
{{CSTR("aa")}, {CSTR(UTF8_ARING)}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_latin1_german2_ci[]=
{
{{CSTR("ss")}, {CSTR(LATIN1_sz)}, 0, 0},
{{CSTR("ss")}, {CSTR(LATIN1_sz)}, 1, -1},
{{CSTR("ss")}, {CSTR(LATIN1_sz)}, 2, 0},
{{CSTR("ss")}, {CSTR(LATIN1_sz)}, 3, 0},
{{CSTR("ss")}, {CSTR(LATIN1_sz)}, 100, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml)}, 0, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml)}, 1, -1},
{{CSTR("ae")}, {CSTR(LATIN1_auml)}, 2, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml)}, 3, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml)}, 100, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml " ")}, 0, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml " ")}, 1, -1},
{{CSTR("ae")}, {CSTR(LATIN1_auml " ")}, 2, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml " ")}, 3, 0},
{{CSTR("ae")}, {CSTR(LATIN1_auml " ")}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_utf8mbx_german2_ci[]=
{
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 0, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 1, -1},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 2, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 3, 0},
{{CSTR("ss")}, {CSTR(UTF8_sz)}, 100, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml)}, 0, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml)}, 1, -1},
{{CSTR("ae")}, {CSTR(UTF8_auml)}, 2, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml)}, 3, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml)}, 100, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml " ")}, 0, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml " ")}, 1, -1},
{{CSTR("ae")}, {CSTR(UTF8_auml " ")}, 2, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml " ")}, 3, 0},
{{CSTR("ae")}, {CSTR(UTF8_auml " ")}, 100, 0},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_mbminlen1_xpad_czech[]=
{
{{CSTR("c")}, {CSTR("ch")}, 0, 0},
{{CSTR("c")}, {CSTR("ch")}, 1, 0},
{{CSTR("c")}, {CSTR("ch")}, 2, -1},
{{CSTR("h")}, {CSTR("ch")}, 0, 0},
{{CSTR("h")}, {CSTR("ch")}, 1, 1},
{{CSTR("h")}, {CSTR("ch")}, 2, -1},
{{CSTR("i")}, {CSTR("ch")}, 0, 0},
{{CSTR("i")}, {CSTR("ch")}, 1, 1},
{{CSTR("i")}, {CSTR("ch")}, 2, 1},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static STRNNCOLLSP_CHAR_PARAM strnncollsp_char_mbminlen2_xpad_common[]=
{
{{CSTR(UCS2_a)}, {CSTR(UCS2_a)}, 0, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a)}, 1, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a)}, 2, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a)}, 3, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a)}, 100, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp)}, 0, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp)}, 1, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp)}, 2, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp)}, 3, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp)}, 100, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp UCS2_sp)}, 0, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp UCS2_sp)}, 1, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp UCS2_sp)}, 2, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp UCS2_sp)}, 3, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_sp UCS2_sp)}, 100, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_b)}, 0, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_b)}, 1, 0},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_b)}, 2, -1},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_b)}, 3, -1},
{{CSTR(UCS2_a)}, {CSTR(UCS2_a UCS2_b)}, 100, -1},
{{NULL, 0}, {NULL, 0}, 0, 0}
};
static int
strnncollsp_char_one(CHARSET_INFO *cs, const STRNNCOLLSP_CHAR_PARAM *p)
{
int failed= 0;
char ahex[64], bhex[64];
int res= cs->coll->strnncollsp_nchars(cs,
(uchar *) p->a.str, p->a.length,
(uchar *) p->b.str, p->b.length,
p->nchars);
str2hex(ahex, sizeof(ahex), p->a.str, p->a.length);
str2hex(bhex, sizeof(bhex), p->b.str, p->b.length);
diag("%-25s %-12s %-12s %3d %7d %7d%s",
cs->name, ahex, bhex, (int) p->nchars, p->res, res,
eqres(res, p->res) ? "" : " FAILED");
if (!eqres(res, p->res))
{
failed++;
}
else
{
/* Test in reverse order */
res= cs->coll->strnncollsp_nchars(cs,
(uchar *) p->b.str, p->b.length,
(uchar *) p->a.str, p->a.length,
p->nchars);
if (!eqres(res, -p->res))
{
diag("Comparison in reverse order failed. Expected %d, got %d",
-p->res, res);
failed++;
}
}
return failed;
}
static int
strnncollsp_char(const char *collation, const STRNNCOLLSP_CHAR_PARAM *param)
{
int failed= 0;
const STRNNCOLLSP_CHAR_PARAM *p;
CHARSET_INFO *cs= get_charset_by_name(collation, MYF(0));
if (!cs)
{
diag("get_charset_by_name() failed");
return 1;
}
diag("%-25s %-12s %-12s %-3s %7s %7s",
"Collation", "a", "b", "Nch", "ExpSign", "Actual");
for (p= param; p->a.str; p++)
{
failed+= strnncollsp_char_one(cs, p);
}
return failed;
}
static int
strnncollsp_char_mbminlen1(const char *collation,
const STRNNCOLLSP_CHAR_PARAM *specific)
{
int failed= 0;
failed+= strnncollsp_char(collation, strnncollsp_char_mbminlen1_xpad_common);
if (specific)
failed+= strnncollsp_char(collation, specific);
return failed;
}
static int
strnncollsp_char_mbminlen2(const char *collation,
const STRNNCOLLSP_CHAR_PARAM *specific)
{
int failed= 0;
failed+= strnncollsp_char(collation, strnncollsp_char_mbminlen2_xpad_common);
if (specific)
failed+= strnncollsp_char(collation, specific);
return failed;
}
static int
strnncollsp_char_latin1(const char *collation,
const STRNNCOLLSP_CHAR_PARAM *specific)
{
int failed= 0;
failed+= strnncollsp_char(collation, strnncollsp_char_mbminlen1_xpad_common);
failed+= strnncollsp_char(collation, strnncollsp_char_latin1_xpad_common);
if (specific)
failed+= strnncollsp_char(collation, specific);
return failed;
}
static int
strnncollsp_char_utf8mbx(const char *collation,
const STRNNCOLLSP_CHAR_PARAM *specific)
{
int failed= 0;
failed+= strnncollsp_char(collation, strnncollsp_char_mbminlen1_xpad_common);
failed+= strnncollsp_char(collation, strnncollsp_char_utf8mbx_xpad_common);
if (!strstr(collation, "_bin") &&
!strstr(collation, "_german2") &&
!strstr(collation, "_danish"))
failed+= strnncollsp_char(collation,
strnncollsp_char_utf8mbx_xpad_a_eq_auml);
if (specific)
failed+= strnncollsp_char(collation, specific);
return failed;
}
static int
test_strnncollsp_char()
{
int failed= 0;
failed+= strnncollsp_char_latin1("latin1_swedish_ci", NULL);
failed+= strnncollsp_char_latin1("latin1_swedish_nopad_ci", NULL);
failed+= strnncollsp_char_latin1("latin1_bin", NULL);
failed+= strnncollsp_char_latin1("latin1_nopad_bin", NULL);
failed+= strnncollsp_char_latin1("latin1_german2_ci",
strnncollsp_char_latin1_german2_ci);
#ifdef HAVE_CHARSET_cp1250
failed+= strnncollsp_char_mbminlen1("cp1250_czech_cs",
strnncollsp_char_mbminlen1_xpad_czech);
#endif
#ifdef HAVE_CHARSET_latin2
failed+= strnncollsp_char_mbminlen1("latin2_czech_cs",
strnncollsp_char_mbminlen1_xpad_czech);
#endif
#ifdef HAVE_CHARSET_tis620
failed+= strnncollsp_char_mbminlen1("tis620_thai_ci", NULL);
#endif
#ifdef HAVE_CHARSET_big5
failed+= strnncollsp_char_mbminlen1("big5_chinese_ci", NULL);
failed+= strnncollsp_char_mbminlen1("big5_chinese_nopad_ci", NULL);
failed+= strnncollsp_char_mbminlen1("big5_bin", NULL);
failed+= strnncollsp_char_mbminlen1("big5_nopad_bin", NULL);
#endif
failed+= strnncollsp_char_utf8mbx("utf8mb3_general_ci", NULL);
failed+= strnncollsp_char_utf8mbx("utf8mb3_general_nopad_ci", NULL);
failed+= strnncollsp_char_utf8mbx("utf8mb3_bin", NULL);
failed+= strnncollsp_char_utf8mbx("utf8mb3_nopad_bin", NULL);
failed+= strnncollsp_char_utf8mbx("utf8mb3_unicode_ci",
strnncollsp_char_utf8mb3_unicode_ci);
failed+= strnncollsp_char_utf8mbx("utf8mb3_unicode_nopad_ci",
strnncollsp_char_utf8mb3_unicode_nopad_ci);
failed+= strnncollsp_char_utf8mbx("utf8mb3_danish_ci",
strnncollsp_char_utf8mb3_danish_ci);
failed+= strnncollsp_char_utf8mbx("utf8mb3_german2_ci",
strnncollsp_char_utf8mbx_german2_ci);
failed+= strnncollsp_char_utf8mbx("utf8mb3_czech_ci",
strnncollsp_char_mbminlen1_xpad_czech);
#ifdef HAVE_CHARSET_ucs2
failed+= strnncollsp_char_mbminlen2("ucs2_general_ci", NULL);
failed+= strnncollsp_char_mbminlen2("ucs2_general_nopad_ci", NULL);
failed+= strnncollsp_char_mbminlen2("ucs2_bin", NULL);
failed+= strnncollsp_char_mbminlen2("ucs2_nopad_bin", NULL);
failed+= strnncollsp_char_mbminlen2("ucs2_unicode_ci", NULL);
failed+= strnncollsp_char_mbminlen2("ucs2_unicode_nopad_ci", NULL);
#endif
return failed;
}
int main(int ac, char **av)
{
size_t i, failed= 0;
plan(2);
MY_INIT(av[0]);
plan(3);
diag("Testing my_like_range_xxx() functions");
for (i= 0; i < array_elements(charset_list); i++)
@ -781,5 +1277,11 @@ int main()
failed= test_strcollsp();
ok(failed == 0, "Testing my_ci_strnncollsp()");
diag("Testing cs->coll->strnncollsp_char()");
failed= test_strnncollsp_char();
ok(failed == 0, "Testing cs->coll->strnncollsp_char()");
my_end(0);
return exit_status();
}