]> projects.mako.cc - scuttle/blob - includes/utf8/tests/cases/utf8_bad.test.php
- Override privacy status on bookmark file import, if specified (i.e. Delicious)
[scuttle] / 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 }

Benjamin Mako Hill || Want to submit a patch?