tests/phpunit/includes/json/FormatJsonTest.php

   1 <?php
   2
   3 /**
   4  * @covers FormatJson
   5  */
   6 class FormatJsonTest extends MediaWikiTestCase {
   7
   8         public static function provideEncoderPrettyPrinting() {
   9                 return array(
  10                         // Four spaces
  11                         array( true, '    ' ),
  12                         array( '    ', '    ' ),
  13                         // Two spaces
  14                         array( '  ', '  ' ),
  15                         // One tab
  16                         array( "\t", "\t" ),
  17                 );
  18         }
  19
  20         /**
  21          * @dataProvider provideEncoderPrettyPrinting
  22          */
  23         public function testEncoderPrettyPrinting( $pretty, $expectedIndent ) {
  24                 $obj = array(
  25                         'emptyObject' => new stdClass,
  26                         'emptyArray' => array(),
  27                         'string' => 'foobar\\',
  28                         'filledArray' => array(
  29                                 array(
  30                                         123,
  31                                         456,
  32                                 ),
  33                                 // Nested json works without problems
  34                                 '"7":["8",{"9":"10"}]',
  35                                 // Whitespace clean up doesn't touch strings that look alike
  36                                 "{\n\t\"emptyObject\": {\n\t},\n\t\"emptyArray\": [ ]\n}",
  37                         ),
  38                 );
  39
  40                 // No trailing whitespace, no trailing linefeed
  41                 $json = '{
  42         "emptyObject": {},
  43         "emptyArray": [],
  44         "string": "foobar\\\\",
  45         "filledArray": [
  46                 [
  47                         123,
  48                         456
  49                 ],
  50                 "\"7\":[\"8\",{\"9\":\"10\"}]",
  51                 "{\n\t\"emptyObject\": {\n\t},\n\t\"emptyArray\": [ ]\n}"
  52         ]
  53 }';
  54
  55                 $json = str_replace( "\r", '', $json ); // Windows compat
  56                 $json = str_replace( "\t", $expectedIndent, $json );
  57                 $this->assertSame( $json, FormatJson::encode( $obj, $pretty ) );
  58         }
  59
  60         public static function provideEncodeDefault() {
  61                 return self::getEncodeTestCases( array() );
  62         }
  63
  64         /**
  65          * @dataProvider provideEncodeDefault
  66          */
  67         public function testEncodeDefault( $from, $to ) {
  68                 $this->assertSame( $to, FormatJson::encode( $from ) );
  69         }
  70
  71         public static function provideEncodeUtf8() {
  72                 return self::getEncodeTestCases( array( 'unicode' ) );
  73         }
  74
  75         /**
  76          * @dataProvider provideEncodeUtf8
  77          */
  78         public function testEncodeUtf8( $from, $to ) {
  79                 $this->assertSame( $to, FormatJson::encode( $from, false, FormatJson::UTF8_OK ) );
  80         }
  81
  82         public static function provideEncodeXmlMeta() {
  83                 return self::getEncodeTestCases( array( 'xmlmeta' ) );
  84         }
  85
  86         /**
  87          * @dataProvider provideEncodeXmlMeta
  88          */
  89         public function testEncodeXmlMeta( $from, $to ) {
  90                 $this->assertSame( $to, FormatJson::encode( $from, false, FormatJson::XMLMETA_OK ) );
  91         }
  92
  93         public static function provideEncodeAllOk() {
  94                 return self::getEncodeTestCases( array( 'unicode', 'xmlmeta' ) );
  95         }
  96
  97         /**
  98          * @dataProvider provideEncodeAllOk
  99          */
 100         public function testEncodeAllOk( $from, $to ) {
 101                 $this->assertSame( $to, FormatJson::encode( $from, false, FormatJson::ALL_OK ) );
 102         }
 103
 104         public function testEncodePhpBug46944() {
 105                 $this->assertNotEquals(
 106                         '\ud840\udc00',
 107                         strtolower( FormatJson::encode( "\xf0\xa0\x80\x80" ) ),
 108                         'Test encoding an broken json_encode character (U+20000)'
 109                 );
 110         }
 111
 112         public function testDecodeReturnType() {
 113                 $this->assertInternalType(
 114                         'object',
 115                         FormatJson::decode( '{"Name": "Cheeso", "Rank": 7}' ),
 116                         'Default to object'
 117                 );
 118
 119                 $this->assertInternalType(
 120                         'array',
 121                         FormatJson::decode( '{"Name": "Cheeso", "Rank": 7}', true ),
 122                         'Optional array'
 123                 );
 124         }
 125
 126         /**
 127          * Generate a set of test cases for a particular combination of encoder options.
 128          *
 129          * @param array $unescapedGroups List of character groups to leave unescaped
 130          * @return array Arrays of unencoded strings and corresponding encoded strings
 131          */
 132         private static function getEncodeTestCases( array $unescapedGroups ) {
 133                 $groups = array(
 134                         'always' => array(
 135                                 // Forward slash (always unescaped)
 136                                 '/' => '/',
 137
 138                                 // Control characters
 139                                 "\0" => '\u0000',
 140                                 "\x08" => '\b',
 141                                 "\t" => '\t',
 142                                 "\n" => '\n',
 143                                 "\r" => '\r',
 144                                 "\f" => '\f',
 145                                 "\x1f" => '\u001f', // representative example
 146
 147                                 // Double quotes
 148                                 '"' => '\"',
 149
 150                                 // Backslashes
 151                                 '\\' => '\\\\',
 152                                 '\\\\' => '\\\\\\\\',
 153                                 '\\u00e9' => '\\\u00e9', // security check for Unicode unescaping
 154
 155                                 // Line terminators
 156                                 "\xe2\x80\xa8" => '\u2028',
 157                                 "\xe2\x80\xa9" => '\u2029',
 158                         ),
 159                         'unicode' => array(
 160                                 "\xc3\xa9" => '\u00e9',
 161                                 "\xf0\x9d\x92\x9e" => '\ud835\udc9e', // U+1D49E, outside the BMP
 162                         ),
 163                         'xmlmeta' => array(
 164                                 '<' => '\u003C', // JSON_HEX_TAG uses uppercase hex digits
 165                                 '>' => '\u003E',
 166                                 '&' => '\u0026',
 167                         ),
 168                 );
 169
 170                 $cases = array();
 171                 foreach ( $groups as $name => $rules ) {
 172                         $leaveUnescaped = in_array( $name, $unescapedGroups );
 173                         foreach ( $rules as $from => $to ) {
 174                                 $cases[] = array( $from, '"' . ( $leaveUnescaped ? $from : $to ) . '"' );
 175                         }
 176                 }
 177
 178                 return $cases;
 179         }
 180 }