Source for file utf8_bad.test.php

Documentation is available at utf8_bad.test.php

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

Documentation generated on Thu, 08 Jan 2009 17:49:15 +0100 by phpDocumentor 1.4.0a2