projects.mako.cc - scuttle/blob - includes/utf8/tests/cases/utf8_bad.test.php

   1 <?php
   2 /**
   3 * @version $Id: utf8_bad.test.php,v 1.6 2006/02/26 13:39:37 harryf Exp $
   4 * @package utf8
   5 * @subpackage Tests
   6 */
   7
   8 //--------------------------------------------------------------------
   9 /**
  10 * Includes
  11 * @package utf8
  12 * @subpackage Tests
  13 */
  14 require_once(dirname(__FILE__).'/../config.php');
  15 require_once UTF8 . '/utils/bad.php';
  16
  17 //--------------------------------------------------------------------
  18 /**
  19 * @package utf8
  20 * @subpackage Tests
  21 */
  22 class test_utf8_bad_find extends UnitTestCase {
  23
  24     function test_utf8_bad_find() {
  25         $this->UnitTestCase('utf8_bad_find()');
  26     }
  27
  28     function testValidUtf8() {
  29         $str = 'Iñtërnâtiônàlizætiøn';
  30         $this->assertFalse(utf8_bad_find($str));
  31     }
  32
  33     function testValidUtf8Ascii() {
  34         $str = 'testing';
  35         $this->assertFalse(utf8_bad_find($str));
  36     }
  37
  38     function testInvalidUtf8() {
  39         $str = "Iñtërnâtiôn\xe9àlizætiøn";
  40         $this->assertEqual(utf8_bad_find($str),15);
  41     }
  42
  43     function testInvalidUtf8Ascii() {
  44         $str = "this is an invalid char '\xe9' here";
  45         $this->assertEqual(utf8_bad_find($str),25);
  46     }
  47
  48     function testInvalidUtf8Start() {
  49         $str = "\xe9Iñtërnâtiônàlizætiøn";
  50         $this->assertEqual(utf8_bad_find($str),0);
  51     }
  52
  53     function testInvalidUtf8End() {
  54         $str = "Iñtërnâtiônàlizætiøn\xe9";
  55         $this->assertEqual(utf8_bad_find($str),27);
  56     }
  57
  58     function testValidTwoOctetId() {
  59         $str = "abc\xc3\xb1";
  60         $this->assertFalse(utf8_bad_find($str));
  61     }
  62
  63     function testInvalidTwoOctetSequence() {
  64         $str = "Iñtërnâtiônàlizætiøn \xc3\x28 Iñtërnâtiônàlizætiøn";
  65         $this->assertEqual(utf8_bad_find($str),28);
  66     }
  67
  68     function testInvalidIdBetweenTwoAndThree() {
  69         $str = "Iñtërnâtiônàlizætiøn\xa0\xa1Iñtërnâtiônàlizætiøn";
  70         $this->assertEqual(utf8_bad_find($str),27);
  71     }
  72
  73
  74     function testValidThreeOctetId() {
  75         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\xa1Iñtërnâtiônàlizætiøn";
  76         $this->assertFalse(utf8_bad_find($str));
  77     }
  78
  79
  80     function testInvalidThreeOctetSequenceSecond() {
  81         $str = "Iñtërnâtiônàlizætiøn\xe2\x28\xa1Iñtërnâtiônàlizætiøn";
  82         $this->assertEqual(utf8_bad_find($str),27);
  83     }
  84
  85     function testInvalidThreeOctetSequenceThird() {
  86         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\x28Iñtërnâtiônàlizætiøn";
  87         $this->assertEqual(utf8_bad_find($str),27);
  88     }
  89
  90     function testValidFourOctetId() {
  91         $str = "Iñtërnâtiônàlizætiøn\xf0\x90\x8c\xbcIñtërnâtiônàlizætiøn";
  92         $this->assertFalse(utf8_bad_find($str));
  93     }
  94
  95     function testInvalidFourOctetSequence() {
  96         $str = "Iñtërnâtiônàlizætiøn\xf0\x28\x8c\xbcIñtërnâtiônàlizætiøn";
  97         $this->assertEqual(utf8_bad_find($str),27);
  98     }
  99
 100     function testInvalidFiveOctetSequence() {
 101         $str = "Iñtërnâtiônàlizætiøn\xf8\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 102         $this->assertEqual(utf8_bad_find($str),27);
 103     }
 104
 105     function testInvalidSixOctetSequence() {
 106         $str = "Iñtërnâtiônàlizætiøn\xfc\xa1\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 107         $this->assertEqual(utf8_bad_find($str),27);
 108     }
 109
 110
 111 }
 112
 113 //--------------------------------------------------------------------
 114 /**
 115 * @package utf8
 116 * @subpackage Tests
 117 */
 118 class test_utf8_bad_findall extends UnitTestCase {
 119
 120     function test_utf8_bad_findall() {
 121         $this->UnitTestCase('test_utf8_bad_findall()');
 122     }
 123
 124     function testValidUtf8() {
 125         $str = 'Iñtërnâtiônàlizætiøn';
 126         $this->assertFalse(utf8_bad_findall($str));
 127     }
 128
 129     function testValidUtf8Ascii() {
 130         $str = 'testing';
 131         $this->assertFalse(utf8_bad_findall($str));
 132     }
 133
 134     function testInvalidUtf8() {
 135         $str = "Iñtërnâtiôn\xe9àlizætiøn";
 136         $test = array(15);
 137         $this->assertEqual(utf8_bad_findall($str),$test);
 138     }
 139
 140     function testInvalidUtf8Ascii() {
 141         $str = "this is an invalid char '\xe9' here";
 142         $test = array(25);
 143         $this->assertEqual(utf8_bad_findall($str),$test);
 144     }
 145
 146     function testInvalidUtf8Multiple() {
 147         $str = "\xe9Iñtërnâtiôn\xe9àlizætiøn\xe9";
 148         $test = array(0,16,29);
 149         $this->assertEqual(utf8_bad_findall($str),$test);
 150     }
 151
 152     function testValidTwoOctetId() {
 153         $str = "abc\xc3\xb1";
 154         $this->assertFalse(utf8_bad_findall($str));
 155     }
 156
 157     function testInvalidTwoOctetSequence() {
 158         $str = "Iñtërnâtiônàlizætiøn \xc3\x28 Iñtërnâtiônàlizætiøn";
 159         $this->assertEqual(utf8_bad_findall($str),array(28));
 160     }
 161
 162     function testInvalidIdBetweenTwoAndThree() {
 163         $str = "Iñtërnâtiônàlizætiøn\xa0\xa1Iñtërnâtiônàlizætiøn";
 164         $this->assertEqual(utf8_bad_findall($str),array(27,28));
 165     }
 166
 167     function testValidThreeOctetId() {
 168         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\xa1Iñtërnâtiônàlizætiøn";
 169         $this->assertFalse(utf8_bad_findall($str));
 170     }
 171
 172     function testInvalidThreeOctetSequenceSecond() {
 173         $str = "Iñtërnâtiônàlizætiøn\xe2\x28\xa1Iñtërnâtiônàlizætiøn";
 174         $this->assertEqual(utf8_bad_findall($str),array(27,29));
 175     }
 176
 177     function testInvalidThreeOctetSequenceThird() {
 178         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\x28Iñtërnâtiônàlizætiøn";
 179         $this->assertEqual(utf8_bad_find($str),27);
 180     }
 181
 182     function testValidFourOctetId() {
 183         $str = "Iñtërnâtiônàlizætiøn\xf0\x90\x8c\xbcIñtërnâtiônàlizætiøn";
 184         $this->assertFalse(utf8_bad_findall($str));
 185     }
 186
 187     function testInvalidFourOctetSequence() {
 188         $str = "Iñtërnâtiônàlizætiøn\xf0\x28\x8c\xbcIñtërnâtiônàlizætiøn";
 189         $this->assertEqual(utf8_bad_findall($str),array(27,29,30));
 190     }
 191
 192     function testInvalidFiveOctetSequence() {
 193         $str = "Iñtërnâtiônàlizætiøn\xf8\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 194         $this->assertEqual(utf8_bad_findall($str),range(27,31));
 195     }
 196
 197     function testInvalidSixOctetSequence() {
 198         $str = "Iñtërnâtiônàlizætiøn\xfc\xa1\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 199         $this->assertEqual(utf8_bad_findall($str),range(27,32));
 200     }
 201
 202
 203 }
 204
 205 //--------------------------------------------------------------------
 206 /**
 207 * @package utf8
 208 * @subpackage Tests
 209 */
 210 class test_utf8_bad_strip extends UnitTestCase {
 211
 212     function test_utf8_bad_strip() {
 213         $this->UnitTestCase('test_utf8_bad_strip()');
 214     }
 215
 216     function testValidUtf8() {
 217         $str = 'Iñtërnâtiônàlizætiøn';
 218         $this->assertEqual(utf8_bad_strip($str),$str);
 219     }
 220
 221     function testValidUtf8Ascii() {
 222         $str = 'testing';
 223         $this->assertEqual(utf8_bad_strip($str),$str);
 224     }
 225
 226     function testInvalidUtf8() {
 227         $str = "Iñtërnâtiôn\xe9àlizætiøn";
 228         $this->assertEqual(utf8_bad_strip($str),'Iñtërnâtiônàlizætiøn');
 229     }
 230
 231     function testInvalidUtf8Ascii() {
 232         $str = "this is an invalid char '\xe9' here";
 233         $this->assertEqual(utf8_bad_strip($str),"this is an invalid char '' here");
 234     }
 235
 236     function testInvalidUtf8Multiple() {
 237         $str = "\xe9Iñtërnâtiôn\xe9àlizætiøn\xe9";
 238         $this->assertEqual(utf8_bad_strip($str),'Iñtërnâtiônàlizætiøn');
 239     }
 240
 241     function testValidTwoOctetId() {
 242         $str = "abc\xc3\xb1";
 243         $this->assertEqual(utf8_bad_strip($str),$str);
 244     }
 245
 246     function testInvalidTwoOctetSequence() {
 247         $str = "Iñtërnâtiônàlizætiøn \xc3\x28 Iñtërnâtiônàlizætiøn";
 248         $stripped = "Iñtërnâtiônàlizætiøn \x28 Iñtërnâtiônàlizætiøn";
 249         $this->assertEqual(utf8_bad_strip($str),$stripped);
 250     }
 251
 252     function testInvalidIdBetweenTwoAndThree() {
 253         $str = "Iñtërnâtiônàlizætiøn\xa0\xa1Iñtërnâtiônàlizætiøn";
 254         $stripped = "IñtërnâtiônàlizætiønIñtërnâtiônàlizætiøn";
 255         $this->assertEqual(utf8_bad_strip($str),$stripped);
 256     }
 257
 258     function testValidThreeOctetId() {
 259         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\xa1Iñtërnâtiônàlizætiøn";
 260         $this->assertEqual(utf8_bad_strip($str),$str);
 261     }
 262
 263     function testInvalidThreeOctetSequenceSecond() {
 264         $str = "Iñtërnâtiônàlizætiøn\xe2\x28\xa1Iñtërnâtiônàlizætiøn";
 265         $stripped = "Iñtërnâtiônàlizætiøn(Iñtërnâtiônàlizætiøn";
 266         $this->assertEqual(utf8_bad_strip($str),$stripped);
 267     }
 268
 269     function testInvalidThreeOctetSequenceThird() {
 270         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\x28Iñtërnâtiônàlizætiøn";
 271         $stripped = "Iñtërnâtiônàlizætiøn(Iñtërnâtiônàlizætiøn";
 272         $this->assertEqual(utf8_bad_strip($str),$stripped);
 273     }
 274
 275     function testValidFourOctetId() {
 276         $str = "Iñtërnâtiônàlizætiøn\xf0\x90\x8c\xbcIñtërnâtiônàlizætiøn";
 277         $this->assertEqual(utf8_bad_strip($str),$str);
 278     }
 279
 280     function testInvalidFourOctetSequence() {
 281         $str = "Iñtërnâtiônàlizætiøn\xf0\x28\x8c\xbcIñtërnâtiônàlizætiøn";
 282         $stripped = "Iñtërnâtiônàlizætiøn(Iñtërnâtiônàlizætiøn";
 283         $this->assertEqual(utf8_bad_strip($str),$stripped);
 284     }
 285
 286     function testInvalidFiveOctetSequence() {
 287         $str = "Iñtërnâtiônàlizætiøn\xf8\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 288         $stripped = "IñtërnâtiônàlizætiønIñtërnâtiônàlizætiøn";
 289         $this->assertEqual(utf8_bad_strip($str),$stripped);
 290     }
 291
 292     function testInvalidSixOctetSequence() {
 293         $str = "Iñtërnâtiônàlizætiøn\xfc\xa1\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 294         $stripped = "IñtërnâtiônàlizætiønIñtërnâtiônàlizætiøn";
 295         $this->assertEqual(utf8_bad_strip($str),$stripped);
 296     }
 297
 298 }
 299
 300 //--------------------------------------------------------------------
 301 /**
 302 * @package utf8
 303 * @subpackage Tests
 304 */
 305 class test_utf8_bad_replace extends UnitTestCase {
 306
 307     function test_utf8_bad_replace() {
 308         $this->UnitTestCase('test_utf8_bad_replace()');
 309     }
 310
 311     function testValidUtf8() {
 312         $str = 'Iñtërnâtiônàlizætiøn';
 313         $this->assertEqual(utf8_bad_replace($str),$str);
 314     }
 315
 316     function testValidUtf8Ascii() {
 317         $str = 'testing';
 318         $this->assertEqual(utf8_bad_replace($str),$str);
 319     }
 320
 321     function testInvalidUtf8() {
 322         $str = "Iñtërnâtiôn\xe9àlizætiøn";
 323         $this->assertEqual(utf8_bad_replace($str),'Iñtërnâtiôn?àlizætiøn');
 324     }
 325
 326     function testInvalidUtf8WithX() {
 327         $str = "Iñtërnâtiôn\xe9àlizætiøn";
 328         $this->assertEqual(utf8_bad_replace($str,'X'),'IñtërnâtiônXàlizætiøn');
 329     }
 330
 331     function testInvalidUtf8Ascii() {
 332         $str = "this is an invalid char '\xe9' here";
 333         $this->assertEqual(utf8_bad_replace($str),"this is an invalid char '?' here");
 334     }
 335
 336     function testInvalidUtf8Multiple() {
 337         $str = "\xe9Iñtërnâtiôn\xe9àlizætiøn\xe9";
 338         $this->assertEqual(utf8_bad_replace($str),'?Iñtërnâtiôn?àlizætiøn?');
 339     }
 340
 341     function testValidTwoOctetId() {
 342         $str = "abc\xc3\xb1";
 343         $this->assertEqual(utf8_bad_replace($str),$str);
 344     }
 345
 346     function testInvalidTwoOctetSequence() {
 347         $str = "Iñtërnâtiônàlizætiøn \xc3\x28 Iñtërnâtiônàlizætiøn";
 348         $replaced= "Iñtërnâtiônàlizætiøn ?( Iñtërnâtiônàlizætiøn";
 349         $this->assertEqual(utf8_bad_replace($str),$replaced);
 350     }
 351
 352     function testInvalidIdBetweenTwoAndThree() {
 353         $str = "Iñtërnâtiônàlizætiøn\xa0\xa1Iñtërnâtiônàlizætiøn";
 354         $replaced= "Iñtërnâtiônàlizætiøn??Iñtërnâtiônàlizætiøn";
 355         $this->assertEqual(utf8_bad_replace($str),$replaced);
 356     }
 357
 358     function testValidThreeOctetId() {
 359         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\xa1Iñtërnâtiônàlizætiøn";
 360         $this->assertEqual(utf8_bad_replace($str),$str);
 361     }
 362
 363     function testInvalidThreeOctetSequenceSecond() {
 364         $str = "Iñtërnâtiônàlizætiøn\xe2\x28\xa1Iñtërnâtiônàlizætiøn";
 365         $replaced= "Iñtërnâtiônàlizætiøn?(?Iñtërnâtiônàlizætiøn";
 366         $this->assertEqual(utf8_bad_replace($str),$replaced);
 367     }
 368
 369     function testInvalidThreeOctetSequenceThird() {
 370         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\x28Iñtërnâtiônàlizætiøn";
 371         $replaced= "Iñtërnâtiônàlizætiøn??(Iñtërnâtiônàlizætiøn";
 372         $this->assertEqual(utf8_bad_replace($str),$replaced);
 373     }
 374
 375     function testValidFourOctetId() {
 376         $str = "Iñtërnâtiônàlizætiøn\xf0\x90\x8c\xbcIñtërnâtiônàlizætiøn";
 377         $this->assertEqual(utf8_bad_replace($str),$str);
 378     }
 379
 380     function testInvalidFourOctetSequence() {
 381         $str = "Iñtërnâtiônàlizætiøn\xf0\x28\x8c\xbcIñtërnâtiônàlizætiøn";
 382         $replaced= "Iñtërnâtiônàlizætiøn?(??Iñtërnâtiônàlizætiøn";
 383         $this->assertEqual(utf8_bad_replace($str),$replaced);
 384     }
 385
 386     function testInvalidFiveOctetSequence() {
 387         $str = "Iñtërnâtiônàlizætiøn\xf8\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 388         $replaced= "Iñtërnâtiônàlizætiøn?????Iñtërnâtiônàlizætiøn";
 389         $this->assertEqual(utf8_bad_replace($str),$replaced);
 390     }
 391
 392     function testInvalidSixOctetSequence() {
 393         $str = "Iñtërnâtiônàlizætiøn\xfc\xa1\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 394         $replaced= "Iñtërnâtiônàlizætiøn??????Iñtërnâtiônàlizætiøn";
 395         $this->assertEqual(utf8_bad_replace($str),$replaced);
 396     }
 397
 398 }
 399
 400 //--------------------------------------------------------------------
 401 /**
 402 * @package utf8
 403 * @subpackage Tests
 404 */
 405 class test_utf8_bad_identify extends UnitTestCase {
 406
 407     function test_utf8_bad_identify() {
 408         $this->UnitTestCase('utf8_bad_identify()');
 409     }
 410
 411     function testValidUtf8() {
 412         $str = 'Iñtërnâtiônàlizætiøn';
 413         $this->assertFalse(utf8_bad_identify($str,$i));
 414         $this->assertNull($i);
 415     }
 416
 417     function testValidUtf8Ascii() {
 418         $str = 'testing';
 419         $this->assertFalse(utf8_bad_identify($str,$i));
 420         $this->assertNull($i);
 421     }
 422
 423     function testInvalidUtf8() {
 424         $str = "Iñtërnâtiôn\xe9àlizætiøn";
 425         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 426         $this->assertEqual($i,15);
 427     }
 428
 429     function testInvalidUtf8Ascii() {
 430         $str = "this is an invalid char '\xe9' here";
 431         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 432         $this->assertEqual($i,25);
 433     }
 434
 435     function testInvalidUtf8Start() {
 436         $str = "\xe9Iñtërnâtiônàlizætiøn";
 437         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 438         $this->assertEqual($i,0);
 439     }
 440
 441     function testInvalidUtf8End() {
 442         $str = "Iñtërnâtiônàlizætiøn\xe9";
 443         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 444         $this->assertEqual($i,27);
 445     }
 446
 447     function testValidTwoOctetId() {
 448         $str = "abc\xc3\xb1";
 449         $this->assertFalse(utf8_bad_identify($str,$i));
 450         $this->assertNull($i);
 451     }
 452
 453     function testInvalidTwoOctetSequence() {
 454         $str = "Iñtërnâtiônàlizætiøn \xc3\x28 Iñtërnâtiônàlizætiøn";
 455         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 456         $this->assertEqual($i,28);
 457     }
 458
 459     function testInvalidIdBetweenTwoAndThree() {
 460         $str = "Iñtërnâtiônàlizætiøn\xa0\xa1Iñtërnâtiônàlizætiøn";
 461         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQID);
 462         $this->assertEqual($i,27);
 463     }
 464
 465
 466     function testValidThreeOctetId() {
 467         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\xa1Iñtërnâtiônàlizætiøn";
 468         $this->assertFalse(utf8_bad_identify($str,$i));
 469         $this->assertNull($i);
 470     }
 471
 472
 473     function testInvalidThreeOctetSequenceSecond() {
 474         $str = "Iñtërnâtiônàlizætiøn\xe2\x28\xa1Iñtërnâtiônàlizætiøn";
 475         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 476         $this->assertEqual($i,27);
 477     }
 478
 479     function testInvalidThreeOctetSequenceThird() {
 480         $str = "Iñtërnâtiônàlizætiøn\xe2\x82\x28Iñtërnâtiônàlizætiøn";
 481         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 482         $this->assertEqual($i,28);
 483     }
 484
 485     function testValidFourOctetId() {
 486         $str = "Iñtërnâtiônàlizætiøn\xf0\x90\x8c\xbcIñtërnâtiônàlizætiøn";
 487         $this->assertFalse(utf8_bad_identify($str,$i));
 488         $this->assertNull($i);
 489     }
 490
 491     function testInvalidFourOctetSequence() {
 492         $str = "Iñtërnâtiônàlizætiøn\xf0\x28\x8c\xbcIñtërnâtiônàlizætiøn";
 493         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_SEQINCOMPLETE);
 494         $this->assertEqual($i,27);
 495     }
 496
 497     function testInvalidFiveOctetSequence() {
 498         $str = "Iñtërnâtiônàlizætiøn\xf8\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 499         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_5OCTET);
 500         $this->assertEqual($i,27);
 501     }
 502
 503     function testInvalidSixOctetSequence() {
 504         $str = "Iñtërnâtiônàlizætiøn\xfc\xa1\xa1\xa1\xa1\xa1Iñtërnâtiônàlizætiøn";
 505         $this->assertEqual(utf8_bad_identify($str,$i),UTF8_BAD_6OCTET);
 506         $this->assertEqual($i,27);
 507     }
 508
 509
 510 }
 511
 512 //--------------------------------------------------------------------
 513 /**
 514 * @package utf8
 515 * @subpackage Tests
 516 */
 517 if (!defined('TEST_RUNNING')) {
 518     define('TEST_RUNNING', true);
 519     $test = &new GroupTest('utf8_bad');
 520     $test->addTestCase(new test_utf8_bad_find());
 521     $test->addTestCase(new test_utf8_bad_findall());
 522     $test->addTestCase(new test_utf8_bad_strip());
 523     $test->addTestCase(new test_utf8_bad_replace());
 524     $test->addTestCase(new test_utf8_bad_identify());
 525     $reporter = & getTestReporter();
 526     $test->run($reporter);
 527 }