lib/util/charset/tests/charset.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for the charcnv functions
   4
   5    Copyright (C) Jelmer Vernooij 2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "torture/torture.h"
  23
  24 #undef strcasecmp
  25 #undef strncasecmp
  26
  27 struct torture_suite *torture_local_charset(TALLOC_CTX *mem_ctx);
  28
  29 static bool test_toupper_m(struct torture_context *tctx)
  30 {
  31         torture_assert_int_equal(tctx, toupper_m('c'), 'C', "c");
  32         torture_assert_int_equal(tctx, toupper_m('Z'), 'Z', "z");
  33         torture_assert_int_equal(tctx, toupper_m(0xFFFF4565), 0xFFFF4565, "0xFFFF4565");
  34         return true;
  35 }
  36
  37 static bool test_tolower_m(struct torture_context *tctx)
  38 {
  39         torture_assert_int_equal(tctx, tolower_m('C'), 'c', "c");
  40         torture_assert_int_equal(tctx, tolower_m('z'), 'z', "z");
  41         torture_assert_int_equal(tctx, tolower_m(0xFFFF4565), 0xFFFF4565, "0xFFFF4565");
  42         return true;
  43 }
  44
  45 static bool test_codepoint_cmpi(struct torture_context *tctx)
  46 {
  47         torture_assert_int_equal(tctx, codepoint_cmpi('a', 'a'), 0, "same char");
  48         torture_assert_int_equal(tctx, codepoint_cmpi('A', 'a'), 0, "upcase version");
  49         torture_assert_int_equal(tctx, codepoint_cmpi('b', 'a'), 1, "right diff");
  50         torture_assert_int_equal(tctx, codepoint_cmpi('b', 'A'), 1, "left greater, mixed case");
  51         torture_assert_int_equal(tctx, codepoint_cmpi('C', 'a'), 1, "left greater, mixed case");
  52         torture_assert_int_equal(tctx, codepoint_cmpi('a', 'b'), -1, "right greater");
  53         torture_assert_int_equal(tctx, codepoint_cmpi('A', 'B'), -1, "right greater, upper case");
  54         torture_assert_int_equal(tctx, codepoint_cmpi(0xc5, 0xc5), 0,
  55                                  "Latin Capital Letter A with Ring Above");
  56         torture_assert_int_equal(tctx, codepoint_cmpi(0xc5, 0xe5), 0,
  57                                  "Latin both Letter A with Ring Above, lower right");
  58         torture_assert_int_equal(tctx, codepoint_cmpi(0xe5, 0xde), -1,
  59                                  "å < Þ");
  60         return true;
  61 }
  62
  63 static bool test_strcasecmp(struct torture_context *tctx)
  64 {
  65         torture_assert_int_equal(tctx, strcasecmp("foo", "bar"), 4, "different strings both lower");
  66         torture_assert_int_equal(tctx, strcasecmp("foo", "Bar"), 4, "different strings lower/upper");
  67         torture_assert_int_equal(tctx, strcasecmp("Foo", "bar"), 4, "different strings upper/lower");
  68         torture_assert_int_equal(tctx, strcasecmp("AFoo", "_bar"), 2, "different strings upper/lower");
  69         torture_assert_int_equal(tctx, strcasecmp("foo", "foo"), 0, "same case strings");
  70         torture_assert_int_equal(tctx, strcasecmp("foo", "Foo"), 0, "different case strings");
  71
  72         /*
  73          * Note that strcasecmp() doesn't allow NULL arguments
  74          */
  75         return true;
  76 }
  77
  78 static bool test_strcasecmp_m(struct torture_context *tctx)
  79 {
  80         /* file.{accented e} in iso8859-1 */
  81         const char file_iso8859_1[7] = { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xe9, 0 };
  82         /* file.{accented e} in utf8 */
  83         const char file_utf8[8] =      { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xc3, 0xa9, 0 };
  84         torture_assert_int_greater(tctx, strcasecmp_m("foo", "bar"), 0, "different strings both lower");
  85         torture_assert_int_less(tctx, strcasecmp_m("bar", "foo"), 0, "different strings both lower");
  86         torture_assert_int_greater(tctx, strcasecmp_m("foo", "Bar"), 0, "different strings lower/upper");
  87         torture_assert_int_greater(tctx, strcasecmp_m("Foo", "bar"), 0, "different strings upper/lower");
  88         torture_assert_int_greater(tctx, strcasecmp_m("AFoo", "_bar"), 0, "different strings upper/lower");
  89         torture_assert_int_equal(tctx, strcasecmp_m("foo", "foo"), 0, "same case strings");
  90         torture_assert_int_equal(tctx, strcasecmp_m("foo", "Foo"), 0, "different case strings");
  91         torture_assert_int_greater(tctx, strcasecmp_m("food", "Foo"), 0, "strings differ towards the end");
  92         torture_assert_int_less(tctx, strcasecmp_m("food", "Fool"), 0, "strings differ towards the end");
  93         torture_assert_int_less(tctx, strcasecmp_m(NULL, "Foo"),  0, "one NULL");
  94         torture_assert_int_greater(tctx, strcasecmp_m("foo", NULL),  0, "other NULL");
  95         torture_assert_int_equal(tctx, strcasecmp_m(NULL, NULL),   0, "both NULL");
  96         torture_assert_int_greater(tctx, strcasecmp_m(file_iso8859_1, file_utf8), 0,
  97                 "file.{accented e} should differ");
  98         return true;
  99 }
 100
 101
 102 static bool test_strequal_m(struct torture_context *tctx)
 103 {
 104         torture_assert(tctx, !strequal_m("foo", "bar"), "different strings");
 105         torture_assert(tctx, strequal_m("foo", "foo"), "same case strings");
 106         torture_assert(tctx, strequal_m("foo", "Foo"), "different case strings");
 107         torture_assert(tctx, !strequal_m(NULL, "Foo"), "one NULL");
 108         torture_assert(tctx, !strequal_m("foo", NULL), "other NULL");
 109         torture_assert(tctx, strequal_m(NULL, NULL), "both NULL");
 110         return true;
 111 }
 112
 113 static bool test_strcsequal(struct torture_context *tctx)
 114 {
 115         torture_assert(tctx, !strcsequal("foo", "bar"), "different strings");
 116         torture_assert(tctx, strcsequal("foo", "foo"), "same case strings");
 117         torture_assert(tctx, !strcsequal("foo", "Foo"), "different case strings");
 118         torture_assert(tctx, !strcsequal(NULL, "Foo"), "one NULL");
 119         torture_assert(tctx, !strcsequal("foo", NULL), "other NULL");
 120         torture_assert(tctx, strcsequal(NULL, NULL), "both NULL");
 121         return true;
 122 }
 123
 124 static bool test_string_replace_m(struct torture_context *tctx)
 125 {
 126         char data[6] = "bla";
 127         string_replace_m(data, 'b', 'c');
 128         torture_assert_str_equal(tctx, data, "cla", "first char replaced");
 129         memcpy(data, "bab", 4);
 130         string_replace_m(data, 'b', 'c');
 131         torture_assert_str_equal(tctx, data, "cac", "other chars replaced");
 132         memcpy(data, "bba", 4);
 133         string_replace_m(data, 'b', 'c');
 134         torture_assert_str_equal(tctx, data, "cca", "other chars replaced");
 135         memcpy(data, "blala", 6);
 136         string_replace_m(data, 'o', 'c');
 137         torture_assert_str_equal(tctx, data, "blala", "no chars replaced");
 138         string_replace_m(NULL, 'b', 'c');
 139         return true;
 140 }
 141
 142 static bool test_strncasecmp(struct torture_context *tctx)
 143 {
 144         torture_assert_int_equal(tctx, strncasecmp("foo", "bar", 3), 4, "different strings both lower");
 145         torture_assert_int_equal(tctx, strncasecmp("foo", "Bar", 3), 4, "different strings lower/upper");
 146         torture_assert_int_equal(tctx, strncasecmp("Foo", "bar", 3), 4, "different strings upper/lower");
 147         torture_assert_int_equal(tctx, strncasecmp("AFoo", "_bar", 4), 2, "different strings upper/lower");
 148         torture_assert_int_equal(tctx, strncasecmp("foo", "foo", 3), 0, "same case strings");
 149         torture_assert_int_equal(tctx, strncasecmp("foo", "Foo", 3), 0, "different case strings");
 150         torture_assert_int_equal(tctx, strncasecmp("fool", "Foo", 3),0, "different case strings");
 151         torture_assert_int_equal(tctx, strncasecmp("fool", "Fool", 40), 0, "over size");
 152         torture_assert_int_equal(tctx, strncasecmp("BLA", "Fool", 0),0, "empty");
 153
 154         /*
 155          * Note that strncasecmp() doesn't allow NULL arguments
 156          */
 157         return true;
 158 }
 159
 160 static bool test_strncasecmp_m(struct torture_context *tctx)
 161 {
 162         /* file.{accented e} in iso8859-1 */
 163         const char file_iso8859_1[7] = { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xe9, 0 };
 164         /* file.{accented e} in utf8 */
 165         const char file_utf8[8] =      { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xc3, 0xa9, 0 };
 166         torture_assert_int_greater(tctx, strncasecmp_m("foo", "bar", 3), 0, "different strings both lower");
 167         torture_assert_int_greater(tctx, strncasecmp_m("foo", "Bar", 3), 0, "different strings lower/upper");
 168         torture_assert_int_greater(tctx, strncasecmp_m("Foo", "bar", 3), 0, "different strings upper/lower");
 169         torture_assert_int_greater(tctx, strncasecmp_m("AFoo", "_bar", 4), 0, "different strings upper/lower");
 170         torture_assert_int_equal(tctx, strncasecmp_m("foo", "foo", 3), 0, "same case strings");
 171         torture_assert_int_equal(tctx, strncasecmp_m("foo", "Foo", 3), 0, "different case strings");
 172         torture_assert_int_equal(tctx, strncasecmp_m("fool", "Foo", 3),0, "different case strings");
 173         torture_assert_int_equal(tctx, strncasecmp_m("fool", "Fool", 40), 0, "over size");
 174         torture_assert_int_equal(tctx, strncasecmp_m("BLA", "Fool", 0),0, "empty");
 175         torture_assert_int_less(tctx, strncasecmp_m(NULL, "Foo", 3),  0, "one NULL");
 176         torture_assert_int_greater(tctx, strncasecmp_m("foo", NULL, 3),  0, "other NULL");
 177         torture_assert_int_equal(tctx, strncasecmp_m(NULL, NULL, 3),   0, "both NULL");
 178         torture_assert_int_greater(tctx, strncasecmp_m(file_iso8859_1, file_utf8, 6), 0,
 179                 "file.{accented e} should differ");
 180         return true;
 181 }
 182
 183 static bool test_next_token_null(struct torture_context *tctx)
 184 {
 185         char buf[20];
 186         torture_assert(tctx, !next_token(NULL, buf, " ", 20), "null ptr works");
 187         return true;
 188 }
 189
 190 static bool test_next_token(struct torture_context *tctx)
 191 {
 192         const char *teststr = "foo bar bla";
 193         char buf[20];
 194         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 195         torture_assert_str_equal(tctx, buf, "foo", "token matches");
 196         torture_assert_str_equal(tctx, teststr, "bar bla", "ptr modified correctly");
 197
 198         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 199         torture_assert_str_equal(tctx, buf, "bar", "token matches");
 200         torture_assert_str_equal(tctx, teststr, "bla", "ptr modified correctly");
 201
 202         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 203         torture_assert_str_equal(tctx, buf, "bla", "token matches");
 204         torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
 205
 206         torture_assert(tctx, !next_token(&teststr, buf, " ", 20), "finding token doesn't work");
 207         return true;
 208 }
 209
 210 static bool test_next_token_implicit_sep(struct torture_context *tctx)
 211 {
 212         const char *teststr = "foo\tbar\n bla";
 213         char buf[20];
 214         torture_assert(tctx, next_token(&teststr, buf, NULL, 20), "finding token works");
 215         torture_assert_str_equal(tctx, buf, "foo", "token matches");
 216         torture_assert_str_equal(tctx, teststr, "bar\n bla", "ptr modified correctly");
 217
 218         torture_assert(tctx, next_token(&teststr, buf, NULL, 20), "finding token works");
 219         torture_assert_str_equal(tctx, buf, "bar", "token matches");
 220         torture_assert_str_equal(tctx, teststr, " bla", "ptr modified correctly");
 221
 222         torture_assert(tctx, next_token(&teststr, buf, NULL, 20), "finding token works");
 223         torture_assert_str_equal(tctx, buf, "bla", "token matches");
 224         torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
 225
 226         torture_assert(tctx, !next_token(&teststr, buf, NULL, 20), "finding token doesn't work");
 227         return true;
 228 }
 229
 230 static bool test_next_token_seps(struct torture_context *tctx)
 231 {
 232         const char *teststr = ",foo bla";
 233         char buf[20];
 234         torture_assert(tctx, next_token(&teststr, buf, ",", 20), "finding token works");
 235         torture_assert_str_equal(tctx, buf, "foo bla", "token matches");
 236         torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
 237
 238         torture_assert(tctx, !next_token(&teststr, buf, ",", 20), "finding token doesn't work");
 239         return true;
 240 }
 241
 242 static bool test_next_token_quotes(struct torture_context *tctx)
 243 {
 244         const char *teststr = "\"foo bar\" bla";
 245         char buf[20];
 246         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 247         torture_assert_str_equal(tctx, buf, "foo bar", "token matches");
 248         torture_assert_str_equal(tctx, teststr, "bla", "ptr modified correctly");
 249
 250         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 251         torture_assert_str_equal(tctx, buf, "bla", "token matches");
 252         torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
 253
 254         torture_assert(tctx, !next_token(&teststr, buf, " ", 20), "finding token doesn't work");
 255         return true;
 256 }
 257
 258 static bool test_next_token_quote_wrong(struct torture_context *tctx)
 259 {
 260         const char *teststr = "\"foo bar bla";
 261         char buf[20];
 262         torture_assert(tctx, next_token(&teststr, buf, " ", 20), "finding token works");
 263         torture_assert_str_equal(tctx, buf, "foo bar bla", "token matches");
 264         torture_assert_str_equal(tctx, teststr, "", "ptr modified correctly");
 265
 266         torture_assert(tctx, !next_token(&teststr, buf, " ", 20), "finding token doesn't work");
 267         return true;
 268 }
 269
 270 static bool test_strlen_m(struct torture_context *tctx)
 271 {
 272         torture_assert_int_equal(tctx, strlen_m("foo"), 3, "simple len");
 273         torture_assert_int_equal(tctx, strlen_m("foo\x83l"), 6, "extended len");
 274         torture_assert_int_equal(tctx, strlen_m(""), 0, "empty");
 275         torture_assert_int_equal(tctx, strlen_m(NULL), 0, "NULL");
 276         return true;
 277 }
 278
 279 static bool test_strlen_m_term(struct torture_context *tctx)
 280 {
 281         torture_assert_int_equal(tctx, strlen_m_term("foo"), 4, "simple len");
 282         torture_assert_int_equal(tctx, strlen_m_term("foo\x83l"), 7, "extended len");
 283         torture_assert_int_equal(tctx, strlen_m_term(""), 1, "empty");
 284         torture_assert_int_equal(tctx, strlen_m_term(NULL), 0, "NULL");
 285         return true;
 286 }
 287
 288 static bool test_strlen_m_term_null(struct torture_context *tctx)
 289 {
 290         torture_assert_int_equal(tctx, strlen_m_term_null("foo"), 4, "simple len");
 291         torture_assert_int_equal(tctx, strlen_m_term_null("foo\x83l"), 7, "extended len");
 292         torture_assert_int_equal(tctx, strlen_m_term_null(""), 0, "empty");
 293         torture_assert_int_equal(tctx, strlen_m_term_null(NULL), 0, "NULL");
 294         return true;
 295 }
 296
 297 static bool test_strhaslower(struct torture_context *tctx)
 298 {
 299         torture_assert(tctx, strhaslower("a"), "one low char");
 300         torture_assert(tctx, strhaslower("aB"), "one low, one up char");
 301         torture_assert(tctx, !strhaslower("B"), "one up char");
 302         torture_assert(tctx, !strhaslower(""), "empty string");
 303         torture_assert(tctx, !strhaslower("3"), "one digit");
 304         return true;
 305 }
 306
 307 static bool test_strhasupper(struct torture_context *tctx)
 308 {
 309         torture_assert(tctx, strhasupper("B"), "one up char");
 310         torture_assert(tctx, strhasupper("aB"), "one low, one up char");
 311         torture_assert(tctx, !strhasupper("a"), "one low char");
 312         torture_assert(tctx, !strhasupper(""), "empty string");
 313         torture_assert(tctx, !strhasupper("3"), "one digit");
 314         return true;
 315 }
 316
 317 static bool test_count_chars_m(struct torture_context *tctx)
 318 {
 319         torture_assert_int_equal(tctx, count_chars_m("foo", 'o'), 2, "simple");
 320         torture_assert_int_equal(tctx, count_chars_m("", 'o'), 0, "empty");
 321         torture_assert_int_equal(tctx, count_chars_m("bla", 'o'), 0, "none");
 322         torture_assert_int_equal(tctx, count_chars_m("bla", '\0'), 0, "null");
 323         return true;
 324 }
 325
 326 struct torture_suite *torture_local_charset(TALLOC_CTX *mem_ctx)
 327 {
 328         struct torture_suite *suite = torture_suite_create(mem_ctx, "charset");
 329
 330         torture_suite_add_simple_test(suite, "toupper_m", test_toupper_m);
 331         torture_suite_add_simple_test(suite, "tolower_m", test_tolower_m);
 332         torture_suite_add_simple_test(suite, "codepoint_cmpi", test_codepoint_cmpi);
 333         torture_suite_add_simple_test(suite, "strcasecmp", test_strcasecmp);
 334         torture_suite_add_simple_test(suite, "strcasecmp_m", test_strcasecmp_m);
 335         torture_suite_add_simple_test(suite, "strequal_m", test_strequal_m);
 336         torture_suite_add_simple_test(suite, "strcsequal", test_strcsequal);
 337         torture_suite_add_simple_test(suite, "string_replace_m", test_string_replace_m);
 338         torture_suite_add_simple_test(suite, "strncasecmp", test_strncasecmp);
 339         torture_suite_add_simple_test(suite, "strncasecmp_m", test_strncasecmp_m);
 340         torture_suite_add_simple_test(suite, "next_token", test_next_token);
 341         torture_suite_add_simple_test(suite, "next_token_null", test_next_token_null);
 342         torture_suite_add_simple_test(suite, "next_token_implicit_sep", test_next_token_implicit_sep);
 343         torture_suite_add_simple_test(suite, "next_token_quotes", test_next_token_quotes);
 344         torture_suite_add_simple_test(suite, "next_token_seps", test_next_token_seps);
 345         torture_suite_add_simple_test(suite, "next_token_quote_wrong", test_next_token_quote_wrong);
 346         torture_suite_add_simple_test(suite, "strlen_m", test_strlen_m);
 347         torture_suite_add_simple_test(suite, "strlen_m_term", test_strlen_m_term);
 348         torture_suite_add_simple_test(suite, "strlen_m_term_null", test_strlen_m_term_null);
 349         torture_suite_add_simple_test(suite, "strhaslower", test_strhaslower);
 350         torture_suite_add_simple_test(suite, "strhasupper", test_strhasupper);
 351         torture_suite_add_simple_test(suite, "count_chars_m", test_count_chars_m);
 352
 353         return suite;
 354 }