1#ifndef lint 2static char *rcsid = "Id: mapselector.tsy,v 1.1 2003/06/04 00:26:55 marka Exp "; 3#endif 4 5/* 6 * Copyright (c) 2002 Japan Network Information Center. 7 * All rights reserved. 8 * 9 * By using this file, you agree to the terms and conditions set forth bellow. 10 * 11 * LICENSE TERMS AND CONDITIONS 12 * 13 * The following License Terms and Conditions apply, unless a different 14 * license is obtained from Japan Network Information Center ("JPNIC"), 15 * a Japanese association, Kokusai-Kougyou-Kanda Bldg 6F, 2-3-4 Uchi-Kanda, 16 * Chiyoda-ku, Tokyo 101-0047, Japan. 17 * 18 * 1. Use, Modification and Redistribution (including distribution of any 19 * modified or derived work) in source and/or binary forms is permitted 20 * under this License Terms and Conditions. 21 * 22 * 2. Redistribution of source code must retain the copyright notices as they 23 * appear in each source code file, this License Terms and Conditions. 24 * 25 * 3. Redistribution in binary form must reproduce the Copyright Notice, 26 * this License Terms and Conditions, in the documentation and/or other 27 * materials provided with the distribution. For the purposes of binary 28 * distribution the "Copyright Notice" refers to the following language: 29 * "Copyright (c) 2000-2002 Japan Network Information Center. All rights reserved." 30 * 31 * 4. The name of JPNIC may not be used to endorse or promote products 32 * derived from this Software without specific prior written approval of 33 * JPNIC. 34 * 35 * 5. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY JPNIC 36 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 37 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 38 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JPNIC BE LIABLE 39 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 40 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 41 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 42 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 43 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 44 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 45 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 46 */ 47 48#include <stddef.h> 49#include <stdio.h> 50#include <stdlib.h> 51#include <stdarg.h> 52#include <idn/mapselector.h> 53#include <idn/ucs4.h> 54#include <idn/log.h> 55 56#include "testutil.h" 57 58#define CONF_FILENAME "test.conf" 59#define MAP_FILENAME "test.map" 60 61/* 62 * Sample TLDs. 63 */ 64static const char *utf8_tlds_jp[] = {"jp", ".jp", "JP", ".JP"}; 65static const char *utf8_tlds_tw[] = {"tw", ".tw", "TW", ".TW"}; 66 67static const unsigned long ucs4_tlds_jp[][4] = {{'j', 'p', '\0', '\0'}, 68 {'.', 'j', 'p', '\0'}, 69 {'J', 'P', '\0', '\0'}, 70 {'.', 'J', 'P', '\0'}}; 71 72static const unsigned long ucs4_tlds_tw[][4] = {{'t', 'w', '\0', '\0'}, 73 {'.', 't', 'w', '\0'}, 74 {'T', 'W', '\0', '\0'}, 75 {'.', 'T', 'W', '\0'}}; 76 77/* How many elements in `utf8_tlds_{jp|tw}[]' and `ucs4_tlds_{jp|tw}[]'. */ 78#define TLD_NVARIANTS 4 79 80/* 81 * Sample input string for mapping. (UCS4) 82 */ 83static const unsigned long in_string[] = {0x00C0, 0x2212, 0}; 84 85/* 86 * Sample mapping results of IN_STRING. 87 * 88 * OUT_STRING_FILEMAP is the result of file-mapping (U+2212 -> U+002D). 89 * OUT_STRING_NAMEPREP is the result of the latest nameprep 90 * OUT_STRING_BOTH is the result of both file-mapping and nameprep. 91 */ 92static const unsigned long out_string_filemap[] = {0x00C0, 0x002D, 0}; 93static const unsigned long out_string_nameprep[] = {0x00E0, 0x2212, 0}; 94static const unsigned long out_string_both[] = {0x00E0, 0x002D, 0}; 95 96#define MAP_FILENAME "test.map" 97 98//-------------------------------------------------------------------- 99// Setups and Teardowns. 100//-------------------------------------------------------------------- 101 102//# SETUP 103// group: generic-init 104{ 105 idn_result_t r; 106 idn_mapselector_t ctxs[TLD_NVARIANTS]; 107 unsigned long to[256]; 108 109 { 110 int i; 111 for (i = 0; i < TLD_NVARIANTS; i++) 112 ctxs[i] = NULL; 113 } 114 115 r = idn_mapselector_initialize(); 116 ASSERT_RESULT(r, idn_success); 117 118 { 119 int i; 120 for (i = 0; i < TLD_NVARIANTS; i++) { 121 r = idn_mapselector_create(&ctxs[i]); 122 ASSERT_RESULT(r, idn_success); 123 } 124 } 125} 126 127//# TEARDOWN 128// group: generic-init 129{ 130 { 131 int i; 132 133 for (i = 0; i < TLD_NVARIANTS; i++) { 134 if (ctxs[i] != NULL) 135 idn_mapselector_destroy(ctxs[i]); 136 remove(CONF_FILENAME); 137 } 138 } 139} 140 141//# SETUP 142// group: quiet 143{ 144 int saved_log_level; 145 146 saved_log_level = idn_log_getlevel(); 147 idn_log_setlevel(idn_log_level_fatal); 148} 149 150//# TEARDOWN 151// group: quiet 152{ 153 idn_log_setlevel(saved_log_level); 154} 155 156//# SETUP 157// group: generic-filemap 158{ 159 create_conf_file(MAP_FILENAME, 0, 160 "U+2212; U+002D", 161 NULL); 162} 163 164//# TEARDOWN 165// group: generic-filemap 166{ 167 remove(MAP_FILENAME); 168} 169 170//-------------------------------------------------------------------- 171// Testcases. 172//-------------------------------------------------------------------- 173 174//# TESTCASE 175// title: call initialize() twice. 176// 177{ 178 idn_result_t r; 179 180 r = idn_mapselector_initialize(); 181 ASSERT_RESULT(r, idn_success); 182 183 r = idn_mapselector_initialize(); 184 ASSERT_RESULT(r, idn_success); 185} 186 187//# TESTCASE 188// title: call create() 189{ 190 idn_result_t r; 191 idn_mapselector_t ctx; 192 193 r = idn_mapselector_initialize(); 194 ASSERT_RESULT(r, idn_success); 195 196 r = idn_mapselector_create(&ctx); 197 ASSERT_RESULT(r, idn_success); 198 199 idn_mapselector_destroy(ctx); 200} 201 202//# TESTCASE 203// title: call add(filemap) and map() 204// group: generic-init generic-filemap 205{ 206 int i, j; 207 208 for (i = 0; i < TLD_NVARIANTS; i++) { 209 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 210 "filemap:" MAP_FILENAME); 211 ASSERT_RESULT(r, idn_success); 212 } 213 214 for (i = 0; i < TLD_NVARIANTS; i++) { 215 for (j = 0; j < TLD_NVARIANTS; j++) { 216 r = idn_mapselector_map(ctxs[i], in_string, 217 utf8_tlds_jp[j], to, 218 sizeof(to) / sizeof(*to)); 219 ASSERT_RESULT(r, idn_success); 220 ASSERT_UCS4STRING(to, out_string_filemap); 221 222 r = idn_mapselector_map(ctxs[i], in_string, 223 utf8_tlds_tw[j], to, 224 sizeof(to) / sizeof(*to)); 225 ASSERT_RESULT(r, idn_success); 226 ASSERT_UCS4STRING(to, in_string); 227 } 228 } 229} 230 231//# TESTCASE 232// title: call add(nameprep) and map() 233// group: generic-init generic-filemap 234{ 235 int i, j; 236 237 for (i = 0; i < TLD_NVARIANTS; i++) { 238 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 239 IDN_NAMEPREP_CURRENT); 240 ASSERT_RESULT(r, idn_success); 241 } 242 243 for (i = 0; i < TLD_NVARIANTS; i++) { 244 for (j = 0; j < TLD_NVARIANTS; j++) { 245 r = idn_mapselector_map(ctxs[i], in_string, 246 utf8_tlds_jp[j], to, 247 sizeof(to) / sizeof(*to)); 248 ASSERT_RESULT(r, idn_success); 249 ASSERT_UCS4STRING(to, out_string_nameprep); 250 251 r = idn_mapselector_map(ctxs[i], in_string, 252 utf8_tlds_tw[j], to, 253 sizeof(to) / sizeof(*to)); 254 ASSERT_RESULT(r, idn_success); 255 ASSERT_UCS4STRING(to, in_string); 256 } 257 } 258} 259 260//# TESTCASE 261// title: call add(filemap) and map2() 262// group: generic-init generic-filemap 263{ 264 int i, j; 265 266 for (i = 0; i < TLD_NVARIANTS; i++) { 267 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 268 "filemap:" MAP_FILENAME); 269 ASSERT_RESULT(r, idn_success); 270 } 271 272 for (i = 0; i < TLD_NVARIANTS; i++) { 273 for (j = 0; j < TLD_NVARIANTS; j++) { 274 r = idn_mapselector_map2(ctxs[i], in_string, 275 ucs4_tlds_jp[j], to, 276 sizeof(to) / sizeof(*to)); 277 ASSERT_RESULT(r, idn_success); 278 ASSERT_UCS4STRING(to, out_string_filemap); 279 280 r = idn_mapselector_map2(ctxs[i], in_string, 281 ucs4_tlds_tw[j], to, 282 sizeof(to) / sizeof(*to)); 283 ASSERT_RESULT(r, idn_success); 284 ASSERT_UCS4STRING(to, in_string); 285 } 286 } 287} 288 289//# TESTCASE 290// title: call add(nameprep) and map2() 291// group: generic-init generic-filemap 292{ 293 int i, j; 294 295 for (i = 0; i < TLD_NVARIANTS; i++) { 296 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 297 IDN_NAMEPREP_CURRENT); 298 ASSERT_RESULT(r, idn_success); 299 } 300 301 for (i = 0; i < TLD_NVARIANTS; i++) { 302 for (j = 0; j < TLD_NVARIANTS; j++) { 303 r = idn_mapselector_map2(ctxs[i], in_string, 304 ucs4_tlds_jp[j], to, 305 sizeof(to) / sizeof(*to)); 306 ASSERT_RESULT(r, idn_success); 307 ASSERT_UCS4STRING(to, out_string_nameprep); 308 309 r = idn_mapselector_map2(ctxs[i], in_string, 310 ucs4_tlds_tw[j], to, 311 sizeof(to) / sizeof(*to)); 312 ASSERT_RESULT(r, idn_success); 313 ASSERT_UCS4STRING(to, in_string); 314 } 315 } 316} 317 318//# TESTCASE 319// title: call add(filemap) and map() 320// group: generic-init generic-filemap 321{ 322 int i, j; 323 324 for (i = 0; i < TLD_NVARIANTS; i++) { 325 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 326 "filemap:" MAP_FILENAME); 327 ASSERT_RESULT(r, idn_success); 328 } 329 330 for (i = 0; i < TLD_NVARIANTS; i++) { 331 for (j = 0; j < TLD_NVARIANTS; j++) { 332 r = idn_mapselector_map(ctxs[i], in_string, 333 utf8_tlds_jp[j], to, 334 sizeof(to) / sizeof(*to)); 335 ASSERT_RESULT(r, idn_success); 336 ASSERT_UCS4STRING(to, out_string_filemap); 337 338 r = idn_mapselector_map(ctxs[i], in_string, 339 utf8_tlds_tw[j], to, 340 sizeof(to) / sizeof(*to)); 341 ASSERT_RESULT(r, idn_success); 342 ASSERT_UCS4STRING(to, in_string); 343 } 344 } 345} 346 347//# TESTCASE 348// title: call add(nameprep) and map() 349// group: generic-init generic-filemap 350{ 351 int i, j; 352 353 for (i = 0; i < TLD_NVARIANTS; i++) { 354 r = idn_mapselector_add(ctxs[i], utf8_tlds_jp[i], 355 IDN_NAMEPREP_CURRENT); 356 ASSERT_RESULT(r, idn_success); 357 } 358 359 for (i = 0; i < TLD_NVARIANTS; i++) { 360 for (j = 0; j < TLD_NVARIANTS; j++) { 361 r = idn_mapselector_map(ctxs[i], in_string, 362 utf8_tlds_jp[j], to, 363 sizeof(to) / sizeof(*to)); 364 ASSERT_RESULT(r, idn_success); 365 ASSERT_UCS4STRING(to, out_string_nameprep); 366 367 r = idn_mapselector_map(ctxs[i], in_string, 368 utf8_tlds_tw[j], to, 369 sizeof(to) / sizeof(*to)); 370 ASSERT_RESULT(r, idn_success); 371 ASSERT_UCS4STRING(to, in_string); 372 } 373 } 374} 375 376//# TESTCASE 377// title: call addall() 378// group: generic-init generic-filemap 379{ 380 static const char *names[] = { 381 "filemap:" MAP_FILENAME, 382 IDN_NAMEPREP_CURRENT 383 }; 384 int i, j; 385 386 for (i = 0; i < TLD_NVARIANTS; i++) { 387 r = idn_mapselector_addall(ctxs[i], utf8_tlds_jp[i], names, 388 sizeof(names) / sizeof(*names)); 389 ASSERT_RESULT(r, idn_success); 390 } 391 392 for (i = 0; i < TLD_NVARIANTS; i++) { 393 for (j = 0; j < TLD_NVARIANTS; j++) { 394 r = idn_mapselector_map2(ctxs[i], in_string, 395 ucs4_tlds_jp[j], to, 396 sizeof(to) / sizeof(*to)); 397 ASSERT_RESULT(r, idn_success); 398 ASSERT_UCS4STRING(to, out_string_both); 399 400 r = idn_mapselector_map2(ctxs[i], in_string, 401 ucs4_tlds_tw[j], to, 402 sizeof(to) / sizeof(*to)); 403 ASSERT_RESULT(r, idn_success); 404 ASSERT_UCS4STRING(to, in_string); 405 } 406 } 407} 408 409//# TESTCASE 410// title: call addall() with nnames=0 411// group: generic-init 412{ 413 static const char *names[] = {IDN_NAMEPREP_CURRENT}; 414 415 r = idn_mapselector_addall(ctxs[0], ".", names, 0); 416 ASSERT_RESULT(r, idn_success); 417} 418 419//# TESTCASE 420// title: call add() with empty tld 421// group: generic-init 422{ 423 r = idn_mapselector_add(ctxs[0], "", IDN_NAMEPREP_CURRENT); 424 ASSERT_RESULT(r, idn_success); 425} 426 427//# TESTCASE 428// title: call addall() with empty tld 429// group: generic-init 430{ 431 static const char *names[] = {IDN_NAMEPREP_CURRENT}; 432 433 r = idn_mapselector_addall(ctxs[0], "", names, 1); 434 ASSERT_RESULT(r, idn_success); 435} 436 437//# TESTCASE 438// title: call add() with too long tld 439// group: generic-init quiet 440{ 441 r = idn_mapselector_add(ctxs[0], 442 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 443 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 444 "ABCDEFGHIJK", 445 IDN_NAMEPREP_CURRENT); 446 ASSERT_RESULT(r, idn_success); 447 448 r = idn_mapselector_add(ctxs[0], 449 "." 450 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 451 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 452 "ABCDEFGHIJK", 453 IDN_NAMEPREP_CURRENT); 454 ASSERT_RESULT(r, idn_success); 455 456 r = idn_mapselector_add(ctxs[0], 457 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 458 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 459 "ABCDEFGHIJKL", 460 IDN_NAMEPREP_CURRENT); 461 ASSERT_RESULT(r, idn_invalid_name); 462 463 r = idn_mapselector_add(ctxs[0], 464 "." 465 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 466 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 467 "ABCDEFGHIJKL", 468 IDN_NAMEPREP_CURRENT); 469 ASSERT_RESULT(r, idn_invalid_name); 470} 471 472//# TESTCASE 473// title: call addall() with too long tld 474// group: generic-init quiet 475{ 476 static const char *names[] = {IDN_NAMEPREP_CURRENT}; 477 478 r = idn_mapselector_addall(ctxs[0], 479 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 480 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 481 "ABCDEFGHIJK", 482 names, 1); 483 ASSERT_RESULT(r, idn_success); 484 485 r = idn_mapselector_addall(ctxs[0], 486 "." 487 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 488 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 489 "ABCDEFGHIJK", 490 names, 1); 491 ASSERT_RESULT(r, idn_success); 492 493 r = idn_mapselector_addall(ctxs[0], 494 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 495 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 496 "ABCDEFGHIJKL", 497 names, 1); 498 ASSERT_RESULT(r, idn_invalid_name); 499 500 r = idn_mapselector_addall(ctxs[0], 501 "." 502 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 503 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 504 "ABCDEFGHIJKL", 505 names, 1); 506 ASSERT_RESULT(r, idn_invalid_name); 507} 508 509//# TESTCASE 510// title: overrun test for arg `to' of map() 511// group: generic-init 512{ 513 r = idn_mapselector_add(ctxs[0], utf8_tlds_jp[0], 514 IDN_NAMEPREP_CURRENT); 515 ASSERT_RESULT(r, idn_success); 516 517 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_jp[0], to, 518 idn_ucs4_strlen(out_string_nameprep) + 1); 519 ASSERT_RESULT(r, idn_success); 520 ASSERT_UCS4STRING(to, out_string_nameprep); 521 522 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_tw[0], to, 523 idn_ucs4_strlen(in_string) + 1); 524 ASSERT_RESULT(r, idn_success); 525 ASSERT_UCS4STRING(to, in_string); 526 527 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_jp[0], to, 528 idn_ucs4_strlen(out_string_nameprep)); 529 ASSERT_RESULT(r, idn_buffer_overflow); 530 531 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_tw[0], to, 532 idn_ucs4_strlen(in_string)); 533 ASSERT_RESULT(r, idn_buffer_overflow); 534} 535 536//# TESTCASE 537// title: overrun test for arg `to' of map2() 538// group: generic-init 539{ 540 r = idn_mapselector_add(ctxs[0], utf8_tlds_jp[0], 541 IDN_NAMEPREP_CURRENT); 542 ASSERT_RESULT(r, idn_success); 543 544 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_jp[0], to, 545 idn_ucs4_strlen(out_string_nameprep) + 1); 546 ASSERT_RESULT(r, idn_success); 547 ASSERT_UCS4STRING(to, out_string_nameprep); 548 549 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_tw[0], to, 550 idn_ucs4_strlen(in_string) + 1); 551 ASSERT_RESULT(r, idn_success); 552 ASSERT_UCS4STRING(to, in_string); 553 554 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_jp[0], to, 555 idn_ucs4_strlen(out_string_nameprep)); 556 ASSERT_RESULT(r, idn_buffer_overflow); 557 558 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_tw[0], to, 559 idn_ucs4_strlen(in_string)); 560 ASSERT_RESULT(r, idn_buffer_overflow); 561} 562 563//# TESTCASE 564// title: call map() with tolen=0 565// group: generic-init 566{ 567 r = idn_mapselector_add(ctxs[0], utf8_tlds_jp[0], 568 IDN_NAMEPREP_CURRENT); 569 ASSERT_RESULT(r, idn_success); 570 571 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_jp[0], to, 0); 572 ASSERT_RESULT(r, idn_buffer_overflow); 573 574 r = idn_mapselector_map(ctxs[0], in_string, utf8_tlds_tw[0], to, 0); 575 ASSERT_RESULT(r, idn_buffer_overflow); 576} 577 578//# TESTCASE 579// title: call map2() with tolen=0 580// group: generic-init 581{ 582 r = idn_mapselector_add(ctxs[0], utf8_tlds_jp[0], 583 IDN_NAMEPREP_CURRENT); 584 ASSERT_RESULT(r, idn_success); 585 586 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_jp[0], to, 0); 587 ASSERT_RESULT(r, idn_buffer_overflow); 588 589 r = idn_mapselector_map2(ctxs[0], in_string, ucs4_tlds_tw[0], to, 0); 590 ASSERT_RESULT(r, idn_buffer_overflow); 591} 592 593