WordPress.org

Make WordPress Core

Ticket #53491: 53491.diff

File 53491.diff, 155.0 KB (added by SergeyBiryukov, 3 months ago)
  • tests/phpunit/includes/testcase.php

     
    3232        public static function assertEqualsWithDelta( $expected, $actual, $delta, $message = '' ) {
    3333                static::assertEquals( $expected, $actual, $message, $delta );
    3434        }
     35
     36        /**
     37         * Asserts that a variable is of type array.
     38         *
     39         * This method has been backported from a more recent PHPUnit version,
     40         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     41         *
     42         * @since 5.9.0
     43         *
     44         * @param mixed  $actual  The value to check.
     45         * @param string $message Optional. Message to display when the assertion fails.
     46         */
     47        public static function assertIsArray( $actual, $message = '' ) {
     48                static::assertInternalType( 'array', $actual, $message );
     49        }
     50
     51        /**
     52         * Asserts that a variable is of type bool.
     53         *
     54         * This method has been backported from a more recent PHPUnit version,
     55         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     56         *
     57         * @since 5.9.0
     58         *
     59         * @param mixed  $actual  The value to check.
     60         * @param string $message Optional. Message to display when the assertion fails.
     61         */
     62        public static function assertIsBool( $actual, $message = '' ) {
     63                static::assertInternalType( 'bool', $actual, $message );
     64        }
     65
     66        /**
     67         * Asserts that a variable is of type float.
     68         *
     69         * This method has been backported from a more recent PHPUnit version,
     70         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     71         *
     72         * @since 5.9.0
     73         *
     74         * @param mixed  $actual  The value to check.
     75         * @param string $message Optional. Message to display when the assertion fails.
     76         */
     77        public static function assertIsFloat( $actual, $message = '' ) {
     78                static::assertInternalType( 'float', $actual, $message );
     79        }
     80
     81        /**
     82         * Asserts that a variable is of type int.
     83         *
     84         * This method has been backported from a more recent PHPUnit version,
     85         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     86         *
     87         * @since 5.9.0
     88         *
     89         * @param mixed  $actual  The value to check.
     90         * @param string $message Optional. Message to display when the assertion fails.
     91         */
     92        public static function assertIsInt( $actual, $message = '' ) {
     93                static::assertInternalType( 'int', $actual, $message );
     94        }
     95
     96        /**
     97         * Asserts that a variable is of type numeric.
     98         *
     99         * This method has been backported from a more recent PHPUnit version,
     100         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     101         *
     102         * @since 5.9.0
     103         *
     104         * @param mixed  $actual  The value to check.
     105         * @param string $message Optional. Message to display when the assertion fails.
     106         */
     107        public static function assertIsNumeric( $actual, $message = '' ) {
     108                static::assertInternalType( 'numeric', $actual, $message );
     109        }
     110
     111        /**
     112         * Asserts that a variable is of type object.
     113         *
     114         * This method has been backported from a more recent PHPUnit version,
     115         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     116         *
     117         * @since 5.9.0
     118         *
     119         * @param mixed  $actual  The value to check.
     120         * @param string $message Optional. Message to display when the assertion fails.
     121         */
     122        public static function assertIsObject( $actual, $message = '' ) {
     123                static::assertInternalType( 'object', $actual, $message );
     124        }
     125
     126        /**
     127         * Asserts that a variable is of type resource.
     128         *
     129         * This method has been backported from a more recent PHPUnit version,
     130         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     131         *
     132         * @since 5.9.0
     133         *
     134         * @param mixed  $actual  The value to check.
     135         * @param string $message Optional. Message to display when the assertion fails.
     136         */
     137        public static function assertIsResource( $actual, $message = '' ) {
     138                static::assertInternalType( 'resource', $actual, $message );
     139        }
     140
     141        /**
     142         * Asserts that a variable is of type string.
     143         *
     144         * This method has been backported from a more recent PHPUnit version,
     145         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     146         *
     147         * @since 5.9.0
     148         *
     149         * @param mixed  $actual  The value to check.
     150         * @param string $message Optional. Message to display when the assertion fails.
     151         */
     152        public static function assertIsString( $actual, $message = '' ) {
     153                static::assertInternalType( 'string', $actual, $message );
     154        }
     155
     156        /**
     157         * Asserts that a variable is of type scalar.
     158         *
     159         * This method has been backported from a more recent PHPUnit version,
     160         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     161         *
     162         * @since 5.9.0
     163         *
     164         * @param mixed  $actual  The value to check.
     165         * @param string $message Optional. Message to display when the assertion fails.
     166         */
     167        public static function assertIsScalar( $actual, $message = '' ) {
     168                static::assertInternalType( 'scalar', $actual, $message );
     169        }
     170
     171        /**
     172         * Asserts that a variable is of type callable.
     173         *
     174         * This method has been backported from a more recent PHPUnit version,
     175         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     176         *
     177         * @since 5.9.0
     178         *
     179         * @param mixed  $actual  The value to check.
     180         * @param string $message Optional. Message to display when the assertion fails.
     181         */
     182        public static function assertIsCallable( $actual, $message = '' ) {
     183                static::assertInternalType( 'callable', $actual, $message );
     184        }
     185
     186        /**
     187         * Asserts that a variable is of type iterable.
     188         *
     189         * This method has been backported from a more recent PHPUnit version,
     190         * as tests running on PHP 5.6 use PHPUnit 5.7.x.
     191         *
     192         * @since 5.9.0
     193         *
     194         * @param mixed  $actual  The value to check.
     195         * @param string $message Optional. Message to display when the assertion fails.
     196         */
     197        public static function assertIsIterable( $actual, $message = '' ) {
     198                static::assertInternalType( 'iterable', $actual, $message );
     199        }
    35200}
  • tests/phpunit/tests/adminbar.php

     
    166166
    167167                // Get primary blog.
    168168                $primary = get_active_blog_for_user( self::$editor_id );
    169                 $this->assertInternalType( 'object', $primary );
     169                $this->assertIsObject( $primary );
    170170
    171171                // No Site menu as the user isn't a member of this blog.
    172172                $this->assertNull( $node_site_name );
  • tests/phpunit/tests/ajax/CustomizeManager.php

     
    286286                );
    287287                $this->make_ajax_call( 'customize_save' );
    288288                $this->assertTrue( $this->_last_response_parsed['success'] );
    289                 $this->assertInternalType( 'array', $this->_last_response_parsed['data'] );
     289                $this->assertIsArray( $this->_last_response_parsed['data'] );
    290290
    291291                $this->assertSame( 'publish', $this->_last_response_parsed['data']['changeset_status'] );
    292292                $this->assertArrayHasKey( 'next_changeset_uuid', $this->_last_response_parsed['data'] );
     
    325325                $_POST['customize_changeset_title']  = 'Published';
    326326                $this->make_ajax_call( 'customize_save' );
    327327                $this->assertTrue( $this->_last_response_parsed['success'] );
    328                 $this->assertInternalType( 'array', $this->_last_response_parsed['data'] );
     328                $this->assertIsArray( $this->_last_response_parsed['data'] );
    329329
    330330                $this->assertSame( 'publish', $this->_last_response_parsed['data']['changeset_status'] );
    331331                $this->assertArrayHasKey( 'next_changeset_uuid', $this->_last_response_parsed['data'] );
  • tests/phpunit/tests/blocks/block-editor.php

     
    172172
    173173                $this->assertCount( 16, $settings );
    174174                $this->assertFalse( $settings['alignWide'] );
    175                 $this->assertInternalType( 'array', $settings['allowedMimeTypes'] );
     175                $this->assertIsArray( $settings['allowedMimeTypes'] );
    176176                $this->assertTrue( $settings['allowedBlockTypes'] );
    177177                $this->assertSameSets(
    178178                        array(
     
    264264                        ),
    265265                        $settings['imageSizes']
    266266                );
    267                 $this->assertInternalType( 'int', $settings['maxUploadFileSize'] );
     267                $this->assertIsInt( $settings['maxUploadFileSize'] );
    268268        }
    269269
    270270        /**
  • tests/phpunit/tests/blocks/render.php

     
    324324                $rendered = $block_type->render();
    325325
    326326                $this->assertSame( '10', $rendered );
    327                 $this->assertInternalType( 'string', $rendered );
     327                $this->assertIsString( $rendered );
    328328        }
    329329
    330330        public function test_dynamic_block_gets_inner_html() {
  • tests/phpunit/tests/bookmark/getBookmark.php

     
    349349                foreach ( $contexts as $context ) {
    350350                        $bookmark = get_bookmark( self::$bookmark->link_id, OBJECT, $context );
    351351
    352                         $this->assertInternalType( 'int', $bookmark->link_id );
    353                         $this->assertInternalType( 'int', $bookmark->link_rating );
     352                        $this->assertIsInt( $bookmark->link_id );
     353                        $this->assertIsInt( $bookmark->link_rating );
    354354                }
    355355        }
    356356
  • tests/phpunit/tests/comment/metaCache.php

     
    233233
    234234                wp_cache_delete( 'last_changed', 'comment' );
    235235
    236                 $this->assertInternalType( 'integer', add_metadata( 'comment', $comment_id, 'foo', 'bar' ) );
     236                $this->assertIsInt( add_metadata( 'comment', $comment_id, 'foo', 'bar' ) );
    237237                $this->assertNotFalse( wp_cache_get_last_changed( 'comment' ) );
    238238        }
    239239
     
    245245
    246246                wp_cache_delete( 'last_changed', 'comment' );
    247247
    248                 $this->assertInternalType( 'integer', update_metadata( 'comment', $comment_id, 'foo', 'bar' ) );
     248                $this->assertIsInt( update_metadata( 'comment', $comment_id, 'foo', 'bar' ) );
    249249                $this->assertNotFalse( wp_cache_get_last_changed( 'comment' ) );
    250250        }
    251251
  • tests/phpunit/tests/comment/query.php

     
    17131713                );
    17141714
    17151715                // Ensure we are dealing with integers, and not objects.
    1716                 $this->assertInternalType( 'integer', $comment_1 );
    1717                 $this->assertInternalType( 'integer', $comment_2 );
    1718                 $this->assertInternalType( 'integer', $comment_3 );
     1716                $this->assertIsInt( $comment_1 );
     1717                $this->assertIsInt( $comment_2 );
     1718                $this->assertIsInt( $comment_3 );
    17191719
    17201720                $comment_ids = get_comments( array( 'fields' => 'ids' ) );
    17211721                $this->assertCount( 3, $comment_ids );
     
    33313331                $this->assertNull( $query1->query_vars );
    33323332                $this->assertEmpty( $query1->comments );
    33333333                $comments = $query1->query( array( 'status' => 'all' ) );
    3334                 $this->assertInternalType( 'array', $query1->query_vars );
     3334                $this->assertIsArray( $query1->query_vars );
    33353335                $this->assertNotEmpty( $query1->comments );
    3336                 $this->assertInternalType( 'array', $query1->comments );
     3336                $this->assertIsArray( $query1->comments );
    33373337
    33383338                $query2 = new WP_Comment_Query( array( 'status' => 'all' ) );
    33393339                $this->assertNotEmpty( $query2->query_vars );
  • tests/phpunit/tests/customize/custom-css-setting.php

     
    344344         * @return array Data.
    345345         */
    346346        function filter_update_custom_css_data( $data, $args ) {
    347                 $this->assertInternalType( 'array', $data );
     347                $this->assertIsArray( $data );
    348348                $this->assertSameSets( array( 'css', 'preprocessed' ), array_keys( $data ) );
    349349                $this->assertSame( '', $data['preprocessed'] );
    350                 $this->assertInternalType( 'array', $args );
     350                $this->assertIsArray( $args );
    351351                $this->assertSameSets( array( 'css', 'preprocessed', 'stylesheet' ), array_keys( $args ) );
    352352                $this->assertSame( $args['css'], $data['css'] );
    353353                $this->assertSame( $args['preprocessed'], $data['preprocessed'] );
  • tests/phpunit/tests/customize/manager.php

     
    677677                $this->assertSameSets( $expected_setting_ids, array_keys( $changeset_values ) );
    678678
    679679                foreach ( array( 'widget_text[2]', 'widget_meta[2]' ) as $setting_id ) {
    680                         $this->assertInternalType( 'array', $changeset_values[ $setting_id ] );
     680                        $this->assertIsArray( $changeset_values[ $setting_id ] );
    681681                        $instance_data = $wp_customize->widgets->sanitize_widget_instance( $changeset_values[ $setting_id ] );
    682                         $this->assertInternalType( 'array', $instance_data );
     682                        $this->assertIsArray( $instance_data );
    683683                        $this->assertArrayHasKey( 'title', $instance_data );
    684684                }
    685685
     
    731731                $this->assertNull( $wp_customize->changeset_post_id() );
    732732                $this->assertSame( 1000, has_action( 'customize_register', array( $wp_customize, '_save_starter_content_changeset' ) ) );
    733733                do_action( 'customize_register', $wp_customize ); // This will trigger the changeset save.
    734                 $this->assertInternalType( 'int', $wp_customize->changeset_post_id() );
     734                $this->assertIsInt( $wp_customize->changeset_post_id() );
    735735                $this->assertNotEmpty( $wp_customize->changeset_data() );
    736736                foreach ( $wp_customize->changeset_data() as $setting_id => $setting_params ) {
    737737                        $this->assertArrayHasKey( 'starter_content', $setting_params );
     
    787787                $this->assertSame( 'auto-draft', get_post( $posts_by_name['waffles'] )->post_status );
    788788                $this->assertNotEquals( $changeset_data['blogname']['value'], get_option( 'blogname' ) );
    789789                $r = $wp_customize->save_changeset_post( array( 'status' => 'publish' ) );
    790                 $this->assertInternalType( 'array', $r );
     790                $this->assertIsArray( $r );
    791791                $this->assertSame( 'publish', get_post( $posts_by_name['about'] )->post_status );
    792792                $this->assertSame( 'inherit', get_post( $posts_by_name['waffles'] )->post_status );
    793793                $this->assertSame( $changeset_data['blogname']['value'], get_option( 'blogname' ) );
     
    10411041                                'data'     => $pre_saved_data,
    10421042                        )
    10431043                );
    1044                 $this->assertInternalType( 'array', $r );
     1044                $this->assertIsArray( $r );
    10451045
    10461046                $this->assertSame( $did_action['customize_save_validation_before'] + 1, did_action( 'customize_save_validation_before' ) );
    10471047
     
    10981098                );
    10991099                $this->assertInstanceOf( 'WP_Error', $r );
    11001100                $this->assertSame( 'transaction_fail', $r->get_error_code() );
    1101                 $this->assertInternalType( 'array', $r->get_error_data() );
     1101                $this->assertIsArray( $r->get_error_data() );
    11021102                $this->assertArrayHasKey( 'setting_validities', $r->get_error_data() );
    11031103                $error_data = $r->get_error_data();
    11041104                $this->assertArrayHasKey( 'blogname', $error_data['setting_validities'] );
     
    11371137                                ),
    11381138                        )
    11391139                );
    1140                 $this->assertInternalType( 'array', $r );
     1140                $this->assertIsArray( $r );
    11411141                $this->assertArrayHasKey( 'setting_validities', $r );
    11421142                $this->assertTrue( $r['setting_validities']['blogname'] );
    11431143                $this->assertInstanceOf( 'WP_Error', $r['setting_validities']['bar_unknown'] );
     
    12051205                                ),
    12061206                        )
    12071207                );
    1208                 $this->assertInternalType( 'array', $r );
     1208                $this->assertIsArray( $r );
    12091209                $this->assertSame( 'Do it live \o/', get_option( 'blogname' ) );
    12101210                $this->assertSame( 'trash', get_post_status( $post_id ) ); // Auto-trashed.
    12111211                $this->assertSame( $original_capabilities, wp_list_pluck( $manager->settings(), 'capability' ) );
     
    14221422         */
    14231423        function filter_customize_changeset_save_data( $data, $context ) {
    14241424                $this->customize_changeset_save_data_call_count += 1;
    1425                 $this->assertInternalType( 'array', $data );
    1426                 $this->assertInternalType( 'array', $context );
     1425                $this->assertIsArray( $data );
     1426                $this->assertIsArray( $context );
    14271427                $this->assertArrayHasKey( 'uuid', $context );
    14281428                $this->assertArrayHasKey( 'title', $context );
    14291429                $this->assertArrayHasKey( 'status', $context );
     
    15131513                                ),
    15141514                        )
    15151515                );
    1516                 $this->assertInternalType( 'array', $r );
     1516                $this->assertIsArray( $r );
    15171517                $this->assertSame(
    15181518                        array_fill_keys( array( 'blogname', 'scratchpad', 'background_color' ), true ),
    15191519                        $r['setting_validities']
     
    15401540                                ),
    15411541                        )
    15421542                );
    1543                 $this->assertInternalType( 'array', $r );
     1543                $this->assertIsArray( $r );
    15441544                $this->assertSame(
    15451545                        array_fill_keys( array( 'blogname', 'background_color' ), true ),
    15461546                        $r['setting_validities']
     
    15691569                                'user_id' => self::$subscriber_user_id,
    15701570                        )
    15711571                );
    1572                 $this->assertInternalType( 'array', $r );
     1572                $this->assertIsArray( $r );
    15731573                $this->assertSame(
    15741574                        array_fill_keys( array( 'blogname', 'scratchpad' ), true ),
    15751575                        $r['setting_validities']
     
    18881888                                'autosave' => true,
    18891889                        )
    18901890                );
    1891                 $this->assertInternalType( 'array', $r );
     1891                $this->assertIsArray( $r );
    18921892
    18931893                // Verify that autosave happened.
    18941894                $autosave_revision = wp_get_post_autosave( $changeset_post_id, get_current_user_id() );
     
    27152715                $error->add( 'bad_letter', 'Bad letra', 123 );
    27162716                $error->add( 'bad_number', 'Bad number', array( 'number' => 123 ) );
    27172717                $validity = $this->manager->prepare_setting_validity_for_js( $error );
    2718                 $this->assertInternalType( 'array', $validity );
     2718                $this->assertIsArray( $validity );
    27192719                foreach ( $error->errors as $code => $messages ) {
    27202720                        $this->assertArrayHasKey( $code, $validity );
    2721                         $this->assertInternalType( 'array', $validity[ $code ] );
     2721                        $this->assertIsArray( $validity[ $code ] );
    27222722                        $this->assertSame( implode( ' ', $messages ), $validity[ $code ]['message'] );
    27232723                        $this->assertArrayHasKey( 'data', $validity[ $code ] );
    27242724                        $this->assertSame( $validity[ $code ]['data'], $error->get_error_data( $code ) );
     
    29102910         * @return array
    29112911         */
    29122912        function filter_customize_dynamic_setting_args_for_test_dynamic_settings( $setting_args, $setting_id ) {
    2913                 $this->assertInternalType( 'string', $setting_id );
     2913                $this->assertIsString( $setting_id );
    29142914                if ( in_array( $setting_id, array( 'foo', 'bar' ), true ) ) {
    29152915                        $setting_args = array( 'default' => "dynamic_{$setting_id}_default" );
    29162916                }
     
    29272927         */
    29282928        function filter_customize_dynamic_setting_class_for_test_dynamic_settings( $setting_class, $setting_id, $setting_args ) {
    29292929                $this->assertSame( 'WP_Customize_Setting', $setting_class );
    2930                 $this->assertInternalType( 'string', $setting_id );
    2931                 $this->assertInternalType( 'array', $setting_args );
     2930                $this->assertIsString( $setting_id );
     2931                $this->assertIsArray( $setting_args );
    29322932                return $setting_class;
    29332933        }
    29342934
     
    30393039         */
    30403040        function test_nonces() {
    30413041                $nonces = $this->manager->get_nonces();
    3042                 $this->assertInternalType( 'array', $nonces );
     3042                $this->assertIsArray( $nonces );
    30433043                $this->assertArrayHasKey( 'save', $nonces );
    30443044                $this->assertArrayHasKey( 'preview', $nonces );
    30453045
     
    32033203         * @return array Components.
    32043204         */
    32053205        function return_array_containing_widgets( $components, $customize_manager ) {
    3206                 $this->assertInternalType( 'array', $components );
     3206                $this->assertIsArray( $components );
    32073207                $this->assertContains( 'widgets', $components );
    32083208                $this->assertContains( 'nav_menus', $components );
    3209                 $this->assertInternalType( 'array', $components );
     3209                $this->assertIsArray( $components );
    32103210                $this->assertInstanceOf( 'WP_Customize_Manager', $customize_manager );
    32113211                return array( 'widgets' );
    32123212        }
     
    32203220         * @return array Components.
    32213221         */
    32223222        function return_array_containing_nav_menus( $components, $customize_manager ) {
    3223                 $this->assertInternalType( 'array', $components );
     3223                $this->assertIsArray( $components );
    32243224                $this->assertContains( 'widgets', $components );
    32253225                $this->assertContains( 'nav_menus', $components );
    3226                 $this->assertInternalType( 'array', $components );
     3226                $this->assertIsArray( $components );
    32273227                $this->assertInstanceOf( 'WP_Customize_Manager', $customize_manager );
    32283228                return array( 'nav_menus' );
    32293229        }
  • tests/phpunit/tests/customize/nav-menu-item-setting.php

     
    7373                $this->assertNull( $setting->previous_post_id );
    7474                $this->assertNull( $setting->update_status );
    7575                $this->assertNull( $setting->update_error );
    76                 $this->assertInternalType( 'array', $setting->default );
     76                $this->assertIsArray( $setting->default );
    7777
    7878                $default = array(
    7979                        'object_id'        => 0,
     
    533533                );
    534534                foreach ( $valid_urls as $valid_url ) {
    535535                        $url_setting = $setting->sanitize( array( 'url' => $valid_url ) );
    536                         $this->assertInternalType( 'array', $url_setting );
     536                        $this->assertIsArray( $url_setting );
    537537                        $this->assertSame( $valid_url, $url_setting['url'] );
    538538                }
    539539
  • tests/phpunit/tests/customize/nav-menu-setting.php

     
    7070                $this->assertNull( $setting->previous_term_id );
    7171                $this->assertNull( $setting->update_status );
    7272                $this->assertNull( $setting->update_error );
    73                 $this->assertInternalType( 'array', $setting->default );
     73                $this->assertIsArray( $setting->default );
    7474                foreach ( array( 'name', 'description', 'parent' ) as $key ) {
    7575                        $this->assertArrayHasKey( $key, $setting->default );
    7676                }
     
    149149                $setting    = new WP_Customize_Nav_Menu_Setting( $this->wp_customize, $setting_id );
    150150
    151151                $value = $setting->value();
    152                 $this->assertInternalType( 'array', $value );
     152                $this->assertIsArray( $value );
    153153                foreach ( array( 'name', 'description', 'parent' ) as $key ) {
    154154                        $this->assertArrayHasKey( $key, $value );
    155155                }
     
    225225                $menus     = wp_get_nav_menus();
    226226                $menus_ids = wp_list_pluck( $menus, 'term_id' );
    227227                $i         = array_search( $menu_id, $menus_ids, true );
    228                 $this->assertInternalType( 'int', $i, 'Update-previewed menu does not appear in wp_get_nav_menus()' );
     228                $this->assertIsInt( $i, 'Update-previewed menu does not appear in wp_get_nav_menus()' );
    229229                $filtered_menu = $menus[ $i ];
    230230                $this->assertSame( 'Name 2 \\o/', $filtered_menu->name );
    231231        }
     
    270270                $menus     = wp_get_nav_menus();
    271271                $menus_ids = wp_list_pluck( $menus, 'term_id' );
    272272                $i         = array_search( $menu_id, $menus_ids, true );
    273                 $this->assertInternalType( 'int', $i, 'Insert-previewed menu was not injected into wp_get_nav_menus()' );
     273                $this->assertIsInt( $i, 'Insert-previewed menu was not injected into wp_get_nav_menus()' );
    274274                $filtered_menu = $menus[ $i ];
    275275                $this->assertSame( 'New Menu Name 1 \\o/', $filtered_menu->name );
    276276        }
     
    304304
    305305                $this->wp_customize->set_post_value( $setting_id, false );
    306306
    307                 $this->assertInternalType( 'array', $setting->value() );
    308                 $this->assertInternalType( 'object', wp_get_nav_menu_object( $menu_id ) );
     307                $this->assertIsArray( $setting->value() );
     308                $this->assertIsObject( wp_get_nav_menu_object( $menu_id ) );
    309309                $setting->preview();
    310310                $this->assertFalse( $setting->value() );
    311311                $this->assertFalse( wp_get_nav_menu_object( $menu_id ) );
  • tests/phpunit/tests/customize/nav-menus.php

     
    381381                        )
    382382                );
    383383                $this->assertSame( $count + 1, $this->filter_count_customize_nav_menu_searched_items );
    384                 $this->assertInternalType( 'array', $results );
     384                $this->assertIsArray( $results );
    385385                $this->assertCount( 3, $results );
    386386                remove_filter( 'customize_nav_menu_searched_items', array( $this, 'filter_search' ), 10 );
    387387
     
    465465         * @return array Items.
    466466         */
    467467        function filter_search( $items, $args ) {
    468                 $this->assertInternalType( 'array', $items );
    469                 $this->assertInternalType( 'array', $args );
     468                $this->assertIsArray( $items );
     469                $this->assertIsArray( $args );
    470470                $this->assertArrayHasKey( 's', $args );
    471471                $this->assertArrayHasKey( 'pagenum', $args );
    472472                $this->filter_count_customize_nav_menu_searched_items += 1;
     
    804804                do_action( 'customize_register', $this->wp_customize );
    805805
    806806                $args = apply_filters( 'customize_dynamic_partial_args', false, 'nav_menu_instance[68b329da9893e34099c7d8ad5cb9c940]' );
    807                 $this->assertInternalType( 'array', $args );
     807                $this->assertIsArray( $args );
    808808                $this->assertSame( 'nav_menu_instance', $args['type'] );
    809809                $this->assertSame( array( $this->wp_customize->nav_menus, 'render_nav_menu_partial' ), $args['render_callback'] );
    810810                $this->assertTrue( $args['container_inclusive'] );
    811811
    812812                $args = apply_filters( 'customize_dynamic_partial_args', array( 'fallback_refresh' => false ), 'nav_menu_instance[4099c7d8ad5cb9c94068b329da9893e3]' );
    813                 $this->assertInternalType( 'array', $args );
     813                $this->assertIsArray( $args );
    814814                $this->assertSame( 'nav_menu_instance', $args['type'] );
    815815                $this->assertSame( array( $this->wp_customize->nav_menus, 'render_nav_menu_partial' ), $args['render_callback'] );
    816816                $this->assertTrue( $args['container_inclusive'] );
  • tests/phpunit/tests/customize/panel.php

     
    3131         */
    3232        function test_construct_default_args() {
    3333                $panel = new WP_Customize_Panel( $this->manager, 'foo' );
    34                 $this->assertInternalType( 'int', $panel->instance_number );
     34                $this->assertIsInt( $panel->instance_number );
    3535                $this->assertSame( $this->manager, $panel->manager );
    3636                $this->assertSame( 'foo', $panel->id );
    3737                $this->assertSame( 160, $panel->priority );
     
    125125                }
    126126                $this->assertEmpty( $data['content'] );
    127127                $this->assertTrue( $data['active'] );
    128                 $this->assertInternalType( 'int', $data['instanceNumber'] );
     128                $this->assertIsInt( $data['instanceNumber'] );
    129129        }
    130130
    131131        /**
  • tests/phpunit/tests/customize/partial.php

     
    166166        function filter_customize_partial_render( $rendered, $partial, $container_context ) {
    167167                $this->assertTrue( false === $rendered || is_string( $rendered ) );
    168168                $this->assertInstanceOf( 'WP_Customize_Partial', $partial );
    169                 $this->assertInternalType( 'array', $container_context );
     169                $this->assertIsArray( $container_context );
    170170                $this->count_filter_customize_partial_render += 1;
    171171                return $rendered;
    172172        }
     
    183183                $this->assertSame( sprintf( 'customize_partial_render_%s', $partial->id ), current_filter() );
    184184                $this->assertTrue( false === $rendered || is_string( $rendered ) );
    185185                $this->assertInstanceOf( 'WP_Customize_Partial', $partial );
    186                 $this->assertInternalType( 'array', $container_context );
     186                $this->assertIsArray( $container_context );
    187187                $this->count_filter_customize_partial_render_with_id += 1;
    188188                return $rendered;
    189189        }
  • tests/phpunit/tests/customize/section.php

     
    3838         */
    3939        function test_construct_default_args() {
    4040                $section = new WP_Customize_Section( $this->manager, 'foo' );
    41                 $this->assertInternalType( 'int', $section->instance_number );
     41                $this->assertIsInt( $section->instance_number );
    4242                $this->assertSame( $this->manager, $section->manager );
    4343                $this->assertSame( 'foo', $section->id );
    4444                $this->assertSame( 160, $section->priority );
     
    139139                }
    140140                $this->assertEmpty( $data['content'] );
    141141                $this->assertTrue( $data['active'] );
    142                 $this->assertInternalType( 'int', $data['instanceNumber'] );
     142                $this->assertIsInt( $data['instanceNumber'] );
    143143        }
    144144
    145145        /**
  • tests/phpunit/tests/customize/selective-refresh-ajax.php

     
    160160                }
    161161                $output = json_decode( ob_get_clean(), true );
    162162                $this->assertTrue( $output['success'] );
    163                 $this->assertInternalType( 'array', $output['data'] );
     163                $this->assertIsArray( $output['data'] );
    164164                $this->assertArrayHasKey( 'contents', $output['data'] );
    165165                $this->assertArrayHasKey( 'errors', $output['data'] );
    166166                $this->assertArrayHasKey( 'foo', $output['data']['contents'] );
     
    280280         * @return string
    281281         */
    282282        function render_callback_blogname( $partial, $context ) {
    283                 $this->assertInternalType( 'array', $context );
     283                $this->assertIsArray( $context );
    284284                $this->assertInstanceOf( 'WP_Customize_Partial', $partial );
    285285                return get_bloginfo( 'name', 'display' );
    286286        }
     
    293293         * @return string
    294294         */
    295295        function render_callback_blogdescription( $partial, $context ) {
    296                 $this->assertInternalType( 'array', $context );
     296                $this->assertIsArray( $context );
    297297                $this->assertInstanceOf( 'WP_Customize_Partial', $partial );
    298298                $x = get_bloginfo( 'description', 'display' );
    299299                return $x;
     
    374374         * @return array Response.
    375375         */
    376376        function filter_customize_render_partials_response( $response, $component, $partial_placements ) {
    377                 $this->assertInternalType( 'array', $response );
     377                $this->assertIsArray( $response );
    378378                $this->assertInstanceOf( 'WP_Customize_Selective_Refresh', $component );
    379379                if ( isset( $this->expected_partial_ids ) ) {
    380380                        $this->assertSameSets( $this->expected_partial_ids, array_keys( $partial_placements ) );
  • tests/phpunit/tests/customize/selective-refresh.php

     
    7171         * @see WP_Customize_Selective_Refresh::partials()
    7272         */
    7373        function test_partials() {
    74                 $this->assertInternalType( 'array', $this->selective_refresh->partials() );
     74                $this->assertIsArray( $this->selective_refresh->partials() );
    7575        }
    7676
    7777        /**
     
    163163                $html = ob_get_clean();
    164164                $this->assertTrue( (bool) preg_match( '/_customizePartialRefreshExports = ({.+})/s', $html, $matches ) );
    165165                $exported_data = json_decode( $matches[1], true );
    166                 $this->assertInternalType( 'array', $exported_data );
     166                $this->assertIsArray( $exported_data );
    167167                $this->assertArrayHasKey( 'partials', $exported_data );
    168                 $this->assertInternalType( 'array', $exported_data['partials'] );
     168                $this->assertIsArray( $exported_data['partials'] );
    169169                $this->assertArrayHasKey( 'blogname', $exported_data['partials'] );
    170170                $this->assertArrayNotHasKey( 'top_secret_message', $exported_data['partials'] );
    171171                $this->assertSame( '#site-title', $exported_data['partials']['blogname']['selector'] );
     
    208208         */
    209209        function filter_customize_dynamic_partial_args( $partial_args, $partial_id ) {
    210210                $this->assertTrue( false === $partial_args || is_array( $partial_args ) );
    211                 $this->assertInternalType( 'string', $partial_id );
     211                $this->assertIsString( $partial_id );
    212212
    213213                if ( preg_match( '/^recognized/', $partial_id ) ) {
    214214                        $partial_args = array(
     
    230230         * @return string
    231231         */
    232232        function filter_customize_dynamic_partial_class( $partial_class, $partial_id, $partial_args ) {
    233                 $this->assertInternalType( 'array', $partial_args );
    234                 $this->assertInternalType( 'string', $partial_id );
    235                 $this->assertInternalType( 'string', $partial_class );
     233                $this->assertIsArray( $partial_args );
     234                $this->assertIsString( $partial_id );
     235                $this->assertIsString( $partial_class );
    236236
    237237                if ( 'recognized-class' === $partial_id ) {
    238238                        $partial_class = 'Tested_Custom_Partial';
  • tests/phpunit/tests/customize/setting.php

     
    730730         */
    731731        public function filter_validate_for_test_validate( $validity, $value ) {
    732732                $this->assertInstanceOf( 'WP_Error', $validity );
    733                 $this->assertInternalType( 'string', $value );
     733                $this->assertIsString( $value );
    734734                if ( sanitize_key( $value ) !== $value ) {
    735735                        $validity->add( 'invalid_key', 'Invalid key' );
    736736                }
  • tests/phpunit/tests/customize/widgets.php

     
    235235                $this->do_customize_boot_actions();
    236236
    237237                $selective_refreshable_widgets = $this->manager->widgets->get_selective_refreshable_widgets();
    238                 $this->assertInternalType( 'array', $selective_refreshable_widgets );
     238                $this->assertIsArray( $selective_refreshable_widgets );
    239239                $this->assertSame( count( $wp_widget_factory->widgets ), count( $selective_refreshable_widgets ) );
    240240                $this->assertArrayHasKey( 'text', $selective_refreshable_widgets );
    241241                $this->assertTrue( $selective_refreshable_widgets['text'] );
     
    620620                $this->assertArrayHasKey( 'sidebar_id', $params );
    621621                $this->assertArrayHasKey( 'width', $params );
    622622                $this->assertArrayHasKey( 'height', $params );
    623                 $this->assertInternalType( 'bool', $params['is_wide'] );
     623                $this->assertIsBool( $params['is_wide'] );
    624624        }
    625625
    626626        /**
     
    677677                $this->assertArrayNotHasKey( $setting_id, $this->manager->unsanitized_post_values() );
    678678                $result = $this->manager->widgets->call_widget_update( $widget_id );
    679679
    680                 $this->assertInternalType( 'array', $result );
     680                $this->assertIsArray( $result );
    681681                $this->assertArrayHasKey( 'instance', $result );
    682682                $this->assertArrayHasKey( 'form', $result );
    683683                $this->assertSame( $instance, $result['instance'] );
     
    686686                $post_values = $this->manager->unsanitized_post_values();
    687687                $this->assertArrayHasKey( $setting_id, $post_values );
    688688                $post_value = $post_values[ $setting_id ];
    689                 $this->assertInternalType( 'array', $post_value );
     689                $this->assertIsArray( $post_value );
    690690                $this->assertArrayHasKey( 'title', $post_value );
    691691                $this->assertArrayHasKey( 'encoded_serialized_instance', $post_value );
    692692                $this->assertArrayHasKey( 'instance_hash_key', $post_value );
     
    703703                do_action( 'customize_register', $this->manager );
    704704
    705705                $args = apply_filters( 'customize_dynamic_partial_args', false, 'widget[search-2]' );
    706                 $this->assertInternalType( 'array', $args );
     706                $this->assertIsArray( $args );
    707707                $this->assertSame( 'widget', $args['type'] );
    708708                $this->assertSame( array( $this->manager->widgets, 'render_widget_partial' ), $args['render_callback'] );
    709709                $this->assertTrue( $args['container_inclusive'] );
    710710
    711711                $args = apply_filters( 'customize_dynamic_partial_args', array( 'fallback_refresh' => false ), 'widget[search-2]' );
    712                 $this->assertInternalType( 'array', $args );
     712                $this->assertIsArray( $args );
    713713                $this->assertSame( 'widget', $args['type'] );
    714714                $this->assertSame( array( $this->manager->widgets, 'render_widget_partial' ), $args['render_callback'] );
    715715                $this->assertTrue( $args['container_inclusive'] );
  • tests/phpunit/tests/date/currentTime.php

     
    9999                $this->assertEqualsWithDelta( $wp_timestamp, current_time( 'U' ), 2, 'The dates should be equal' );
    100100
    101101                // phpcs:ignore WordPress.DateTime.CurrentTimeTimestamp.Requested
    102                 $this->assertInternalType( 'int', current_time( 'timestamp' ) );
     102                $this->assertIsInt( current_time( 'timestamp' ) );
    103103        }
    104104
    105105        /**
  • tests/phpunit/tests/db.php

     
    560560                $this->assertNotEmpty( $wpdb->insert_id );
    561561
    562562                $row = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->users WHERE ID = %d", $wpdb->insert_id ) );
    563                 $this->assertInternalType( 'object', $row );
     563                $this->assertIsObject( $row );
    564564                $this->assertSame( 'Walter Sobchak', $row->display_name );
    565565        }
    566566
     
    16821682                if ( $expect_bail ) {
    16831683                        $this->assertFalse( $data );
    16841684                } else {
    1685                         $this->assertInternalType( 'array', $data );
     1685                        $this->assertIsArray( $data );
    16861686
    16871687                        list( $parsed_host, $parsed_port, $parsed_socket, $parsed_is_ipv6 ) = $data;
    16881688
  • tests/phpunit/tests/formatting/SanitizePost.php

     
    1919                );
    2020
    2121                foreach ( $int_fields as $field => $type ) {
    22                         $this->assertInternalType( $type, $post->$field, "field $field" );
     22                        switch ( $type ) {
     23                                case 'integer':
     24                                        $this->assertIsInt( $post->$field, "field $field" );
     25                                        break;
     26                                case 'string':
     27                                        $this->assertIsString( $post->$field, "field $field" );
     28                                        break;
     29                        }
    2330                }
    2431        }
    2532}
  • tests/phpunit/tests/functions.php

     
    8080         */
    8181        function test_wp_parse_args_boolean_strings() {
    8282                $args = wp_parse_args( 'foo=false&bar=true' );
    83                 $this->assertInternalType( 'string', $args['foo'] );
    84                 $this->assertInternalType( 'string', $args['bar'] );
     83                $this->assertIsString( $args['foo'] );
     84                $this->assertIsString( $args['bar'] );
    8585        }
    8686
    8787        /**
     
    581581        function test_get_allowed_mime_types() {
    582582                $mimes = get_allowed_mime_types();
    583583
    584                 $this->assertInternalType( 'array', $mimes );
     584                $this->assertIsArray( $mimes );
    585585                $this->assertNotEmpty( $mimes );
    586586
    587587                add_filter( 'upload_mimes', '__return_empty_array' );
    588588                $mimes = get_allowed_mime_types();
    589                 $this->assertInternalType( 'array', $mimes );
     589                $this->assertIsArray( $mimes );
    590590                $this->assertEmpty( $mimes );
    591591
    592592                remove_filter( 'upload_mimes', '__return_empty_array' );
    593593                $mimes = get_allowed_mime_types();
    594                 $this->assertInternalType( 'array', $mimes );
     594                $this->assertIsArray( $mimes );
    595595                $this->assertNotEmpty( $mimes );
    596596        }
    597597
     
    601601        function test_wp_get_mime_types() {
    602602                $mimes = wp_get_mime_types();
    603603
    604                 $this->assertInternalType( 'array', $mimes );
     604                $this->assertIsArray( $mimes );
    605605                $this->assertNotEmpty( $mimes );
    606606
    607607                add_filter( 'mime_types', '__return_empty_array' );
    608608                $mimes = wp_get_mime_types();
    609                 $this->assertInternalType( 'array', $mimes );
     609                $this->assertIsArray( $mimes );
    610610                $this->assertEmpty( $mimes );
    611611
    612612                remove_filter( 'mime_types', '__return_empty_array' );
    613613                $mimes = wp_get_mime_types();
    614                 $this->assertInternalType( 'array', $mimes );
     614                $this->assertIsArray( $mimes );
    615615                $this->assertNotEmpty( $mimes );
    616616
    617617                // 'upload_mimes' should not affect wp_get_mime_types().
    618618                add_filter( 'upload_mimes', '__return_empty_array' );
    619619                $mimes = wp_get_mime_types();
    620                 $this->assertInternalType( 'array', $mimes );
     620                $this->assertIsArray( $mimes );
    621621                $this->assertNotEmpty( $mimes );
    622622
    623623                remove_filter( 'upload_mimes', '__return_empty_array' );
    624624                $mimes2 = wp_get_mime_types();
    625                 $this->assertInternalType( 'array', $mimes2 );
     625                $this->assertIsArray( $mimes2 );
    626626                $this->assertNotEmpty( $mimes2 );
    627627                $this->assertSame( $mimes2, $mimes );
    628628        }
     
    910910
    911911                $urls = wp_extract_urls( $blob );
    912912                $this->assertNotEmpty( $urls );
    913                 $this->assertInternalType( 'array', $urls );
     913                $this->assertIsArray( $urls );
    914914                $this->assertCount( count( $original_urls ), $urls );
    915915                $this->assertSame( $original_urls, $urls );
    916916
     
    931931
    932932                $urls = wp_extract_urls( $blob );
    933933                $this->assertNotEmpty( $urls );
    934                 $this->assertInternalType( 'array', $urls );
     934                $this->assertIsArray( $urls );
    935935                $this->assertCount( 8, $urls );
    936936                $this->assertSame( array_slice( $original_urls, 0, 8 ), $urls );
    937937
     
    945945
    946946                $urls = wp_extract_urls( $blob );
    947947                $this->assertNotEmpty( $urls );
    948                 $this->assertInternalType( 'array', $urls );
     948                $this->assertIsArray( $urls );
    949949                $this->assertCount( 8, $urls );
    950950                $this->assertSame( array_slice( $original_urls, 0, 8 ), $urls );
    951951        }
     
    10661066        public function test_wp_get_ext_types() {
    10671067                $extensions = wp_get_ext_types();
    10681068
    1069                 $this->assertInternalType( 'array', $extensions );
     1069                $this->assertIsArray( $extensions );
    10701070                $this->assertNotEmpty( $extensions );
    10711071
    10721072                add_filter( 'ext2type', '__return_empty_array' );
     
    10751075
    10761076                remove_filter( 'ext2type', '__return_empty_array' );
    10771077                $extensions = wp_get_ext_types();
    1078                 $this->assertInternalType( 'array', $extensions );
     1078                $this->assertIsArray( $extensions );
    10791079                $this->assertNotEmpty( $extensions );
    10801080        }
    10811081
     
    11971197                $ids = array();
    11981198                for ( $i = 0; $i < 20; $i += 1 ) {
    11991199                        $id = wp_unique_id();
    1200                         $this->assertInternalType( 'string', $id );
     1200                        $this->assertIsString( $id );
    12011201                        $this->assertTrue( is_numeric( $id ) );
    12021202                        $ids[] = $id;
    12031203                }
  • tests/phpunit/tests/functions/listFiles.php

     
    1010
    1111        public function test_list_files_returns_a_list_of_files() {
    1212                $admin_files = list_files( ABSPATH . 'wp-admin/' );
    13                 $this->assertInternalType( 'array', $admin_files );
     13                $this->assertIsArray( $admin_files );
    1414                $this->assertNotEmpty( $admin_files );
    1515                $this->assertContains( ABSPATH . 'wp-admin/index.php', $admin_files );
    1616        }
  • tests/phpunit/tests/functions/wpGetMimeTypes.php

     
    1414        public function test_all_mime_match() {
    1515                $mime_types_start = wp_get_mime_types();
    1616
    17                 $this->assertInternalType( 'array', $mime_types_start );
     17                $this->assertIsArray( $mime_types_start );
    1818                $this->assertNotEmpty( $mime_types_start );
    1919
    2020                add_filter( 'mime_types', '__return_empty_array' );
     
    2323
    2424                remove_filter( 'mime_types', '__return_empty_array' );
    2525                $mime_types = wp_get_mime_types();
    26                 $this->assertInternalType( 'array', $mime_types );
     26                $this->assertIsArray( $mime_types );
    2727                $this->assertNotEmpty( $mime_types );
    2828                // Did it revert to the original after filter remove?
    2929                $this->assertSame( $mime_types_start, $mime_types );
  • tests/phpunit/tests/functions/wpRemoteFopen.php

     
    2929                $url      = 'https://asdftestblog1.files.wordpress.com/2007/09/2007-06-30-dsc_4700-1.jpg';
    3030                $response = wp_remote_fopen( $url );
    3131
    32                 $this->assertInternalType( 'string', $response );
     32                $this->assertIsString( $response );
    3333                $this->assertSame( 40148, strlen( $response ) );
    3434        }
    3535}
  • tests/phpunit/tests/general/template.php

     
    304304                $this->_set_custom_logo();
    305305                $custom_logo = get_custom_logo();
    306306                $this->assertNotEmpty( $custom_logo );
    307                 $this->assertInternalType( 'string', $custom_logo );
     307                $this->assertIsString( $custom_logo );
    308308
    309309                $this->_remove_custom_logo();
    310310                $this->assertEmpty( get_custom_logo() );
  • tests/phpunit/tests/general/wpGetArchives.php

     
    3131                                'echo' => false,
    3232                        )
    3333                );
    34                 $this->assertInternalType( 'string', $result );
     34                $this->assertIsString( $result );
    3535                $time1 = wp_cache_get( 'last_changed', 'posts' );
    3636                $this->assertNotEmpty( $time1 );
    3737                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     
    4545                                'echo' => false,
    4646                        )
    4747                );
    48                 $this->assertInternalType( 'string', $result );
     48                $this->assertIsString( $result );
    4949                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    5050                $this->assertSame( $num_queries, $wpdb->num_queries );
    5151
     
    5757                                'order' => 'ASC',
    5858                        )
    5959                );
    60                 $this->assertInternalType( 'string', $result );
     60                $this->assertIsString( $result );
    6161                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    6262                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    6363
     
    7171                                'order' => 'ASC',
    7272                        )
    7373                );
    74                 $this->assertInternalType( 'string', $result );
     74                $this->assertIsString( $result );
    7575                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    7676                $this->assertSame( $num_queries, $wpdb->num_queries );
    7777
     
    8484                                'echo' => false,
    8585                        )
    8686                );
    87                 $this->assertInternalType( 'string', $result );
     87                $this->assertIsString( $result );
    8888                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    8989                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    9090
     
    9797                                'echo' => false,
    9898                        )
    9999                );
    100                 $this->assertInternalType( 'string', $result );
     100                $this->assertIsString( $result );
    101101                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    102102                $this->assertSame( $num_queries, $wpdb->num_queries );
    103103
     
    108108                                'echo' => false,
    109109                        )
    110110                );
    111                 $this->assertInternalType( 'string', $result );
     111                $this->assertIsString( $result );
    112112                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    113113                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    114114
     
    121121                                'echo' => false,
    122122                        )
    123123                );
    124                 $this->assertInternalType( 'string', $result );
     124                $this->assertIsString( $result );
    125125                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    126126                $this->assertSame( $num_queries, $wpdb->num_queries );
    127127
     
    132132                                'echo' => false,
    133133                        )
    134134                );
    135                 $this->assertInternalType( 'string', $result );
     135                $this->assertIsString( $result );
    136136                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    137137                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    138138
     
    145145                                'echo' => false,
    146146                        )
    147147                );
    148                 $this->assertInternalType( 'string', $result );
     148                $this->assertIsString( $result );
    149149                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    150150                $this->assertSame( $num_queries, $wpdb->num_queries );
    151151
     
    156156                                'echo' => false,
    157157                        )
    158158                );
    159                 $this->assertInternalType( 'string', $result );
     159                $this->assertIsString( $result );
    160160                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    161161                $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    162162
     
    169169                                'echo' => false,
    170170                        )
    171171                );
    172                 $this->assertInternalType( 'string', $result );
     172                $this->assertIsString( $result );
    173173                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    174174                $this->assertSame( $num_queries, $wpdb->num_queries );
    175175        }
  • tests/phpunit/tests/http/base.php

     
    452452                $res = wp_remote_head( $url, array( 'timeout' => 30 ) );
    453453
    454454                $this->skipTestOnTimeout( $res );
    455                 $this->assertInternalType( 'array', wp_remote_retrieve_header( $res, 'location' ) );
     455                $this->assertIsArray( wp_remote_retrieve_header( $res, 'location' ) );
    456456                $this->assertCount( 2, wp_remote_retrieve_header( $res, 'location' ) );
    457457
    458458                $res = wp_remote_get( $url, array( 'timeout' => 30 ) );
  • tests/phpunit/tests/http/functions.php

     
    1919
    2020                $headers = wp_remote_retrieve_headers( $response );
    2121
    22                 $this->assertInternalType( 'array', $response );
     22                $this->assertIsArray( $response );
    2323
    2424                $this->assertSame( 'image/jpeg', $headers['content-type'] );
    2525                $this->assertSame( '40148', $headers['content-length'] );
     
    6363
    6464                $headers = wp_remote_retrieve_headers( $response );
    6565
    66                 $this->assertInternalType( 'array', $response );
     66                $this->assertIsArray( $response );
    6767
    6868                // Should return the same headers as a HEAD request.
    6969                $this->assertSame( 'image/jpeg', $headers['content-type'] );
  • tests/phpunit/tests/image/functions.php

     
    337337
    338338                // First, test with deprecated wp_load_image function.
    339339                $editor1 = wp_load_image( DIR_TESTDATA );
    340                 $this->assertInternalType( 'string', $editor1 );
     340                $this->assertIsString( $editor1 );
    341341
    342342                $editor2 = wp_get_image_editor( DIR_TESTDATA );
    343343                $this->assertInstanceOf( 'WP_Error', $editor2 );
  • tests/phpunit/tests/image/header.php

     
    147147
    148148                $cropped_id = $this->custom_image_header->insert_attachment( $object, $cropped );
    149149
    150                 $this->assertInternalType( 'int', $cropped_id );
     150                $this->assertIsInt( $cropped_id );
    151151                $this->assertGreaterThan( 0, $cropped_id );
    152152        }
    153153
  • tests/phpunit/tests/image/intermediateSize.php

     
    3434        function test_make_intermediate_size_width() {
    3535                $image = image_make_intermediate_size( DIR_TESTDATA . '/images/a2-small.jpg', 100, 0, false );
    3636
    37                 $this->assertInternalType( 'array', $image );
     37                $this->assertIsArray( $image );
    3838        }
    3939
    4040        /**
     
    4343        function test_make_intermediate_size_height() {
    4444                $image = image_make_intermediate_size( DIR_TESTDATA . '/images/a2-small.jpg', 0, 75, false );
    4545
    46                 $this->assertInternalType( 'array', $image );
     46                $this->assertIsArray( $image );
    4747        }
    4848
    4949        /**
     
    5454
    5555                unlink( DIR_TESTDATA . '/images/a2-small-100x75.jpg' );
    5656
    57                 $this->assertInternalType( 'array', $image );
     57                $this->assertIsArray( $image );
    5858                $this->assertSame( 100, $image['width'] );
    5959                $this->assertSame( 75, $image['height'] );
    6060                $this->assertSame( 'image/jpeg', $image['mime-type'] );
  • tests/phpunit/tests/image/siteIcon.php

     
    120120                $object     = $this->wp_site_icon->create_attachment_object( $cropped, $attachment_id );
    121121                $cropped_id = $this->wp_site_icon->insert_attachment( $object, $cropped );
    122122
    123                 $this->assertInternalType( 'int', $cropped_id );
     123                $this->assertIsInt( $cropped_id );
    124124                $this->assertGreaterThan( 0, $cropped_id );
    125125        }
    126126
  • tests/phpunit/tests/includes/factory.php

     
    3535        public function test_term_factory_create_and_get_should_return_term_object() {
    3636                register_taxonomy( 'wptests_tax', 'post' );
    3737                $term = self::factory()->term->create_and_get( array( 'taxonomy' => 'wptests_tax' ) );
    38                 $this->assertInternalType( 'object', $term );
     38                $this->assertIsObject( $term );
    3939                $this->assertNotEmpty( $term->term_id );
    4040        }
    4141}
  • tests/phpunit/tests/l10n.php

     
    5656         */
    5757        function test_get_available_languages() {
    5858                $array = get_available_languages();
    59                 $this->assertInternalType( 'array', $array );
     59                $this->assertIsArray( $array );
    6060
    6161                $array = get_available_languages( '.' );
    6262                $this->assertEmpty( $array );
     
    7070         */
    7171        function test_wp_get_installed_translations_for_core() {
    7272                $installed_translations = wp_get_installed_translations( 'core' );
    73                 $this->assertInternalType( 'array', $installed_translations );
     73                $this->assertIsArray( $installed_translations );
    7474                $textdomains_expected = array( 'admin', 'admin-network', 'continents-cities', 'default' );
    7575                $this->assertSameSets( $textdomains_expected, array_keys( $installed_translations ) );
    7676
  • tests/phpunit/tests/media.php

     
    381381                $post = get_post( $id );
    382382
    383383                $prepped = wp_prepare_attachment_for_js( $post );
    384                 $this->assertInternalType( 'array', $prepped );
     384                $this->assertIsArray( $prepped );
    385385                $this->assertSame( 0, $prepped['uploadedTo'] );
    386386                $this->assertSame( '', $prepped['mime'] );
    387387                $this->assertSame( '', $prepped['type'] );
     
    11641164         */
    11651165        function test_attachment_url_to_postid_with_empty_url() {
    11661166                $post_id = attachment_url_to_postid( '' );
    1167                 $this->assertInternalType( 'int', $post_id );
     1167                $this->assertIsInt( $post_id );
    11681168                $this->assertSame( 0, $post_id );
    11691169        }
    11701170
  • tests/phpunit/tests/media/getAttachmentTaxonomies.php

     
    119119                $found = get_attachment_taxonomies( $attachment, 'objects' );
    120120
    121121                $this->assertSame( array( 'wptests_tax2' ), array_keys( $found ) );
    122                 $this->assertInternalType( 'object', $found['wptests_tax2'] );
     122                $this->assertIsObject( $found['wptests_tax2'] );
    123123                $this->assertSame( 'wptests_tax2', $found['wptests_tax2']->name );
    124124        }
    125125
     
    143143                $found = get_attachment_taxonomies( $attachment, 'objects' );
    144144
    145145                $this->assertSame( array( 'wptests_tax2' ), array_keys( $found ) );
    146                 $this->assertInternalType( 'object', $found['wptests_tax2'] );
     146                $this->assertIsObject( $found['wptests_tax2'] );
    147147                $this->assertSame( 'wptests_tax2', $found['wptests_tax2']->name );
    148148        }
    149149}
  • tests/phpunit/tests/meta.php

     
    207207                $this->assertFalse( metadata_exists( 'user', $this->author->ID, $key ) );
    208208                $this->assertFalse( delete_metadata( 'user', $this->author->ID, $key ) );
    209209                $this->assertSame( '', get_metadata( 'user', $this->author->ID, $key, true ) );
    210                 $this->assertInternalType( 'int', add_metadata( 'user', $this->author->ID, $key, $value ) );
     210                $this->assertIsInt( add_metadata( 'user', $this->author->ID, $key, $value ) );
    211211                $this->assertSame( $expected, get_metadata( 'user', $this->author->ID, $key, true ) );
    212212                $this->assertTrue( delete_metadata( 'user', $this->author->ID, $key ) );
    213213                $this->assertSame( '', get_metadata( 'user', $this->author->ID, $key, true ) );
    214                 $this->assertInternalType( 'int', update_metadata( 'user', $this->author->ID, $key, $value ) );
     214                $this->assertIsInt( update_metadata( 'user', $this->author->ID, $key, $value ) );
    215215                $this->assertSame( $expected, get_metadata( 'user', $this->author->ID, $key, true ) );
    216216                $this->assertTrue( update_metadata( 'user', $this->author->ID, $key, 'blah' ) );
    217217                $this->assertSame( 'blah', get_metadata( 'user', $this->author->ID, $key, true ) );
     
    220220                $this->assertFalse( metadata_exists( 'user', $this->author->ID, $key ) );
    221221
    222222                // Test overslashing.
    223                 $this->assertInternalType( 'int', add_metadata( 'user', $this->author->ID, $key, $value2 ) );
     223                $this->assertIsInt( add_metadata( 'user', $this->author->ID, $key, $value2 ) );
    224224                $this->assertSame( $expected2, get_metadata( 'user', $this->author->ID, $key, true ) );
    225225                $this->assertTrue( delete_metadata( 'user', $this->author->ID, $key ) );
    226226                $this->assertSame( '', get_metadata( 'user', $this->author->ID, $key, true ) );
    227                 $this->assertInternalType( 'int', update_metadata( 'user', $this->author->ID, $key, $value2 ) );
     227                $this->assertIsInt( update_metadata( 'user', $this->author->ID, $key, $value2 ) );
    228228                $this->assertSame( $expected2, get_metadata( 'user', $this->author->ID, $key, true ) );
    229229        }
    230230
  • tests/phpunit/tests/multisite/cleanDirsizeCache.php

     
    206206
    207207                        // `dirsize_cache` should now be filled after upload and recurse_dirsize() call.
    208208                        $cache_path = untrailingslashit( $upload_dir['path'] );
    209                         $this->assertInternalType( 'array', get_transient( 'dirsize_cache' ) );
     209                        $this->assertIsArray( get_transient( 'dirsize_cache' ) );
    210210                        $this->assertSame( $size, get_transient( 'dirsize_cache' )[ $cache_path ] );
    211211
    212212                        // Cleanup.
  • tests/phpunit/tests/multisite/network.php

     
    352352                        // We can't use wp_schedule_update_network_counts() because WP_INSTALLING is set.
    353353                        wp_schedule_event( time(), 'twicedaily', 'update_network_counts' );
    354354
    355                         $this->assertInternalType( 'int', wp_next_scheduled( 'update_network_counts' ) );
     355                        $this->assertIsInt( wp_next_scheduled( 'update_network_counts' ) );
    356356                }
    357357
    358358                /**
     
    365365
    366366                        $user_id = self::factory()->user->create( array( 'role' => 'administrator' ) );
    367367                        $blog_id = self::factory()->blog->create( array( 'user_id' => $user_id ) );
    368                         $this->assertInternalType( 'int', $blog_id );
     368                        $this->assertIsInt( $blog_id );
    369369
    370370                        // Set the dashboard blog to another one.
    371371                        update_site_option( 'dashboard_blog', $blog_id );
  • tests/phpunit/tests/multisite/site.php

     
    9494                        $this->assertSame( array(), $_wp_switched_stack );
    9595                        $this->assertFalse( ms_is_switched() );
    9696                        $current_blog_id = get_current_blog_id();
    97                         $this->assertInternalType( 'integer', $current_blog_id );
     97                        $this->assertIsInt( $current_blog_id );
    9898
    9999                        wp_cache_set( 'switch-test', $current_blog_id, 'switch-test' );
    100100                        $this->assertSame( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     
    141141
    142142                        $blog_id = self::factory()->blog->create();
    143143
    144                         $this->assertInternalType( 'int', $blog_id );
     144                        $this->assertIsInt( $blog_id );
    145145                        $prefix = $wpdb->get_blog_prefix( $blog_id );
    146146
    147147                        // $get_all = false, only retrieve details from the blogs table.
     
    13281328                        remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    13291329                        $site_id = wp_insert_site( $site_data );
    13301330
    1331                         $this->assertInternalType( 'integer', $site_id );
     1331                        $this->assertIsInt( $site_id );
    13321332
    13331333                        $site = get_site( $site_id );
    13341334                        foreach ( $expected_data as $key => $value ) {
     
    14341434
    14351435                        remove_action( 'clean_site_cache', array( $this, 'action_database_insert_on_clean_site_cache' ) );
    14361436
    1437                         $this->assertInternalType( 'integer', $site_id );
     1437                        $this->assertIsInt( $site_id );
    14381438
    14391439                }
    14401440
     
    18191819                                        'network_id' => 1,
    18201820                                )
    18211821                        );
    1822                         $this->assertInternalType( 'integer', $site_id );
     1822                        $this->assertIsInt( $site_id );
    18231823
    18241824                        $site = get_site( $site_id );
    18251825                        $this->assertEqualsWithDelta( strtotime( $first_date ), strtotime( $site->registered ), 2, 'The dates should be equal' );
     
    18271827
    18281828                        $second_date = current_time( 'mysql', true );
    18291829                        $site_id     = wp_update_site( $site_id, array() );
    1830                         $this->assertInternalType( 'integer', $site_id );
     1830                        $this->assertIsInt( $site_id );
    18311831
    18321832                        $site = get_site( $site_id );
    18331833                        $this->assertEqualsWithDelta( strtotime( $first_date ), strtotime( $site->registered ), 2, 'The dates should be equal' );
  • tests/phpunit/tests/multisite/siteMeta.php

     
    157157                        }
    158158
    159159                        $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
    160                         $this->assertInternalType( 'int', $actual );
     160                        $this->assertIsInt( $actual );
    161161                        $this->assertNotEmpty( $actual );
    162162
    163163                        $meta = get_site_meta( self::$site_id, 'foo', true );
  • tests/phpunit/tests/oembed/controller.php

     
    169169                if ( ! is_string( $data ) && false !== $data ) {
    170170                        $this->fail( 'Unexpected type for $data.' );
    171171                }
    172                 $this->assertInternalType( 'string', $url );
    173                 $this->assertInternalType( 'array', $args );
     172                $this->assertIsString( $url );
     173                $this->assertIsArray( $args );
    174174                $this->oembed_result_filter_count++;
    175175                return $data;
    176176        }
     
    299299                $response = rest_get_server()->dispatch( $request );
    300300                $data     = $response->get_data();
    301301
    302                 $this->assertInternalType( 'array', $data );
     302                $this->assertIsArray( $data );
    303303                $this->assertNotEmpty( $data );
    304304        }
    305305
     
    323323                $response = rest_get_server()->dispatch( $request );
    324324                $data     = $response->get_data();
    325325
    326                 $this->assertInternalType( 'array', $data );
     326                $this->assertIsArray( $data );
    327327                $this->assertNotEmpty( $data );
    328328
    329329                $this->assertArrayHasKey( 'version', $data );
     
    366366                $response = rest_get_server()->dispatch( $request );
    367367                $data     = $response->get_data();
    368368
    369                 $this->assertInternalType( 'array', $data );
     369                $this->assertIsArray( $data );
    370370                $this->assertNotEmpty( $data );
    371371
    372372                $this->assertArrayHasKey( 'version', $data );
     
    411411                $response = rest_get_server()->dispatch( $request );
    412412                $data     = $response->get_data();
    413413
    414                 $this->assertInternalType( 'array', $data );
     414                $this->assertIsArray( $data );
    415415                $this->assertNotEmpty( $data );
    416416
    417417                $this->assertArrayHasKey( 'version', $data );
     
    454454                $response = rest_get_server()->dispatch( $request );
    455455                $data     = $response->get_data();
    456456
    457                 $this->assertInternalType( 'array', $data );
     457                $this->assertIsArray( $data );
    458458                $this->assertNotEmpty( $data );
    459459
    460460                restore_current_blog();
     
    603603                $data = $response->get_data();
    604604
    605605                $this->assertNotEmpty( $data );
    606                 $this->assertInternalType( 'object', $data );
     606                $this->assertIsObject( $data );
    607607                $this->assertSame( 'YouTube', $data->provider_name );
    608608                $this->assertSame( 'https://i.ytimg.com/vi/' . self::YOUTUBE_VIDEO_ID . '/hqdefault.jpg', $data->thumbnail_url );
    609609                $this->assertEquals( $data->width, $request['maxwidth'] );
     
    630630                $data = $response->get_data();
    631631
    632632                $this->assertNotEmpty( $data );
    633                 $this->assertInternalType( 'object', $data );
    634                 $this->assertInternalType( 'string', $data->html );
    635                 $this->assertInternalType( 'array', $data->scripts );
     633                $this->assertIsObject( $data );
     634                $this->assertIsString( $data->html );
     635                $this->assertIsArray( $data->scripts );
    636636        }
    637637
    638638        public function test_proxy_with_invalid_oembed_provider_no_discovery() {
     
    743743                $response = rest_get_server()->dispatch( $request );
    744744                $data     = $response->get_data();
    745745
    746                 $this->assertInternalType( 'object', $data );
     746                $this->assertIsObject( $data );
    747747
    748748                $data = (array) $data;
    749749
     
    786786                $data     = $response->get_data();
    787787
    788788                $this->assertSame( 1, $this->oembed_result_filter_count );
    789                 $this->assertInternalType( 'object', $data );
     789                $this->assertIsObject( $data );
    790790                $this->assertSame( 'Untrusted', $data->provider_name );
    791791                $this->assertSame( self::UNTRUSTED_PROVIDER_URL, $data->provider_url );
    792792                $this->assertSame( 'rich', $data->type );
     
    809809                $data     = $response->get_data();
    810810
    811811                $this->assertSame( 1, $this->oembed_result_filter_count );
    812                 $this->assertInternalType( 'object', $data );
     812                $this->assertIsObject( $data );
    813813
    814814                $this->assertStringStartsWith( '<b>Unfiltered</b>', $data->html );
    815815        }
  • tests/phpunit/tests/option/multisite.php

     
    9999
    100100                function test_with_another_site() {
    101101                        $user_id = self::factory()->user->create();
    102                         $this->assertInternalType( 'integer', $user_id );
     102                        $this->assertIsInt( $user_id );
    103103
    104104                        $blog_id = self::factory()->blog->create(
    105105                                array(
     
    107107                                        'public'  => 1,
    108108                                )
    109109                        );
    110                         $this->assertInternalType( 'integer', $blog_id );
     110                        $this->assertIsInt( $blog_id );
    111111
    112112                        $key    = __FUNCTION__ . '_key1';
    113113                        $key2   = __FUNCTION__ . '_key2';
  • tests/phpunit/tests/post.php

     
    9797
    9898                        update_object_term_cache( $id, $post_type );
    9999                        $tcache = wp_cache_get( $id, 'post_tag_relationships' );
    100                         $this->assertInternalType( 'array', $tcache );
     100                        $this->assertIsArray( $tcache );
    101101                        $this->assertSame( 2, count( $tcache ) );
    102102
    103103                        $tcache = wp_cache_get( $id, 'ctax_relationships' );
    104104                        if ( 'cpt' === $post_type ) {
    105                                 $this->assertInternalType( 'array', $tcache );
     105                                $this->assertIsArray( $tcache );
    106106                                $this->assertSame( 2, count( $tcache ) );
    107107                        } else {
    108108                                $this->assertFalse( $tcache );
  • tests/phpunit/tests/post/formats.php

     
    1212
    1313                $result = set_post_format( $post_id, 'aside' );
    1414                $this->assertNotWPError( $result );
    15                 $this->assertInternalType( 'array', $result );
     15                $this->assertIsArray( $result );
    1616                $this->assertSame( 1, count( $result ) );
    1717
    1818                $format = get_post_format( $post_id );
     
    2020
    2121                $result = set_post_format( $post_id, 'standard' );
    2222                $this->assertNotWPError( $result );
    23                 $this->assertInternalType( 'array', $result );
     23                $this->assertIsArray( $result );
    2424                $this->assertSame( 0, count( $result ) );
    2525
    2626                $result = set_post_format( $post_id, '' );
    2727                $this->assertNotWPError( $result );
    28                 $this->assertInternalType( 'array', $result );
     28                $this->assertIsArray( $result );
    2929                $this->assertSame( 0, count( $result ) );
    3030        }
    3131
     
    4040
    4141                $result = set_post_format( $post_id, 'aside' );
    4242                $this->assertNotWPError( $result );
    43                 $this->assertInternalType( 'array', $result );
     43                $this->assertIsArray( $result );
    4444                $this->assertSame( 1, count( $result ) );
    4545                // The format can be set but not retrieved until it is registered.
    4646                $format = get_post_format( $post_id );
     
    5353
    5454                $result = set_post_format( $post_id, 'standard' );
    5555                $this->assertNotWPError( $result );
    56                 $this->assertInternalType( 'array', $result );
     56                $this->assertIsArray( $result );
    5757                $this->assertSame( 0, count( $result ) );
    5858
    5959                $result = set_post_format( $post_id, '' );
    6060                $this->assertNotWPError( $result );
    61                 $this->assertInternalType( 'array', $result );
     61                $this->assertIsArray( $result );
    6262                $this->assertSame( 0, count( $result ) );
    6363
    6464                remove_post_type_support( 'page', 'post-formats' );
     
    7272
    7373                $result = set_post_format( $post_id, 'aside' );
    7474                $this->assertNotWPError( $result );
    75                 $this->assertInternalType( 'array', $result );
     75                $this->assertIsArray( $result );
    7676                $this->assertSame( 1, count( $result ) );
    7777                $this->assertTrue( has_post_format( 'aside', $post_id ) );
    7878
    7979                $result = set_post_format( $post_id, 'standard' );
    8080                $this->assertNotWPError( $result );
    81                 $this->assertInternalType( 'array', $result );
     81                $this->assertIsArray( $result );
    8282                $this->assertSame( 0, count( $result ) );
    8383                // Standard is a special case. It shows as false when set.
    8484                $this->assertFalse( has_post_format( 'standard', $post_id ) );
  • tests/phpunit/tests/post/getPageByPath.php

     
    306306                $this->assertSame( $page, $found->ID );
    307307
    308308                $object = get_page_by_path( 'foo', OBJECT );
    309                 $this->assertInternalType( 'object', $object );
     309                $this->assertIsObject( $object );
    310310                $this->assertSame( $page, $object->ID );
    311311
    312312                $array_n = get_page_by_path( 'foo', ARRAY_N );
    313                 $this->assertInternalType( 'array', $array_n );
     313                $this->assertIsArray( $array_n );
    314314                $this->assertSame( $page, $array_n[0] );
    315315
    316316                $array_a = get_page_by_path( 'foo', ARRAY_A );
    317                 $this->assertInternalType( 'array', $array_a );
     317                $this->assertIsArray( $array_a );
    318318                $this->assertSame( $page, $array_a['ID'] );
    319319        }
    320320}
  • tests/phpunit/tests/post/getPostTypeLabels.php

     
    55 */
    66class Tests_Post_GetPostTypeLabels extends WP_UnitTestCase {
    77        public function test_returns_an_object() {
    8                 $this->assertInternalType(
    9                         'object',
     8                $this->assertIsObject(
    109                        get_post_type_labels(
    1110                                (object) array(
    1211                                        'name'         => 'foo',
  • tests/phpunit/tests/post/meta.php

     
    4646
    4747        function test_unique_postmeta() {
    4848                // Add a unique post meta item.
    49                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'unique', 'value', true ) );
     49                $this->assertIsInt( add_post_meta( self::$post_id, 'unique', 'value', true ) );
    5050
    5151                // Check unique is enforced.
    5252                $this->assertFalse( add_post_meta( self::$post_id, 'unique', 'another value', true ) );
     
    6969
    7070        function test_nonunique_postmeta() {
    7171                // Add two non-unique post meta items.
    72                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'nonunique', 'value' ) );
    73                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'nonunique', 'another value' ) );
     72                $this->assertIsInt( add_post_meta( self::$post_id, 'nonunique', 'value' ) );
     73                $this->assertIsInt( add_post_meta( self::$post_id, 'nonunique', 'another value' ) );
    7474
    7575                // Check they exist.
    7676                $this->assertSame( 'value', get_post_meta( self::$post_id, 'nonunique', true ) );
     
    8787                $this->assertSame( array( 'another value' ), get_post_meta( self::$post_id, 'nonunique', false ) );
    8888
    8989                // Add a third one.
    90                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'nonunique', 'someother value' ) );
     90                $this->assertIsInt( add_post_meta( self::$post_id, 'nonunique', 'someother value' ) );
    9191
    9292                // Check they exist.
    9393                $expected = array(
     
    106106
    107107        function test_update_post_meta() {
    108108                // Add a unique post meta item.
    109                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'unique_update', 'value', true ) );
     109                $this->assertIsInt( add_post_meta( self::$post_id, 'unique_update', 'value', true ) );
    110110
    111111                // Add two non-unique post meta items.
    112                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'nonunique_update', 'value' ) );
    113                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'nonunique_update', 'another value' ) );
     112                $this->assertIsInt( add_post_meta( self::$post_id, 'nonunique_update', 'value' ) );
     113                $this->assertIsInt( add_post_meta( self::$post_id, 'nonunique_update', 'another value' ) );
    114114
    115115                // Check they exist.
    116116                $this->assertSame( 'value', get_post_meta( self::$post_id, 'unique_update', true ) );
     
    133133
    134134        function test_delete_post_meta() {
    135135                // Add two unique post meta items.
    136                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'unique_delete', 'value', true ) );
    137                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id_2, 'unique_delete', 'value', true ) );
     136                $this->assertIsInt( add_post_meta( self::$post_id, 'unique_delete', 'value', true ) );
     137                $this->assertIsInt( add_post_meta( self::$post_id_2, 'unique_delete', 'value', true ) );
    138138
    139139                // Check they exist.
    140140                $this->assertSame( 'value', get_post_meta( self::$post_id, 'unique_delete', true ) );
     
    150150
    151151        function test_delete_post_meta_by_key() {
    152152                // Add two unique post meta items.
    153                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'unique_delete_by_key', 'value', true ) );
    154                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id_2, 'unique_delete_by_key', 'value', true ) );
     153                $this->assertIsInt( add_post_meta( self::$post_id, 'unique_delete_by_key', 'value', true ) );
     154                $this->assertIsInt( add_post_meta( self::$post_id_2, 'unique_delete_by_key', 'value', true ) );
    155155
    156156                // Check they exist.
    157157                $this->assertSame( 'value', get_post_meta( self::$post_id, 'unique_delete_by_key', true ) );
     
    167167
    168168        function test_get_post_meta_by_id() {
    169169                $mid = add_post_meta( self::$post_id, 'get_post_meta_by_key', 'get_post_meta_by_key_value', true );
    170                 $this->assertInternalType( 'integer', $mid );
     170                $this->assertIsInt( $mid );
    171171
    172172                $mobj             = new stdClass;
    173173                $mobj->meta_id    = $mid;
     
    178178                delete_metadata_by_mid( 'post', $mid );
    179179
    180180                $mid = add_post_meta( self::$post_id, 'get_post_meta_by_key', array( 'foo', 'bar' ), true );
    181                 $this->assertInternalType( 'integer', $mid );
     181                $this->assertIsInt( $mid );
    182182                $mobj->meta_id    = $mid;
    183183                $mobj->meta_value = array( 'foo', 'bar' );
    184184                $this->assertEquals( $mobj, get_post_meta_by_id( $mid ) );
     
    187187
    188188        function test_delete_meta() {
    189189                $mid = add_post_meta( self::$post_id, 'delete_meta', 'delete_meta_value', true );
    190                 $this->assertInternalType( 'integer', $mid );
     190                $this->assertIsInt( $mid );
    191191
    192192                $this->assertTrue( delete_meta( $mid ) );
    193193                $this->assertFalse( get_metadata_by_mid( 'post', $mid ) );
     
    197197
    198198        function test_update_meta() {
    199199                // Add a unique post meta item.
    200                 $this->assertInternalType( 'integer', $mid1 = add_post_meta( self::$post_id, 'unique_update', 'value', true ) );
     200                $mid1 = add_post_meta( self::$post_id, 'unique_update', 'value', true );
     201                $this->assertIsInt( $mid1 );
    201202
    202203                // Add two non-unique post meta items.
    203                 $this->assertInternalType( 'integer', $mid2 = add_post_meta( self::$post_id, 'nonunique_update', 'value' ) );
    204                 $this->assertInternalType( 'integer', $mid3 = add_post_meta( self::$post_id, 'nonunique_update', 'another value' ) );
     204                $mid2 = add_post_meta( self::$post_id, 'nonunique_update', 'value' );
     205                $this->assertIsInt( $mid2 );
     206                $mid3 = add_post_meta( self::$post_id, 'nonunique_update', 'another value' );
     207                $this->assertIsInt( $mid3 );
    205208
    206209                // Check they exist.
    207210                $this->assertSame( 'value', get_post_meta( self::$post_id, 'unique_update', true ) );
     
    242245                $funky_meta[]    = $classy;
    243246
    244247                // Add a post meta item.
    245                 $this->assertInternalType( 'integer', add_post_meta( self::$post_id, 'test_funky_post_meta', $funky_meta, true ) );
     248                $this->assertIsInt( add_post_meta( self::$post_id, 'test_funky_post_meta', $funky_meta, true ) );
    246249
    247250                // Check it exists.
    248251                $this->assertEquals( $funky_meta, get_post_meta( self::$post_id, 'test_funky_post_meta', true ) );
     
    318321
    319322                wp_cache_delete( 'last_changed', 'posts' );
    320323
    321                 $this->assertInternalType( 'integer', add_metadata( 'post', $post_id, 'foo', 'bar' ) );
     324                $this->assertIsInt( add_metadata( 'post', $post_id, 'foo', 'bar' ) );
    322325                $this->assertNotFalse( wp_cache_get_last_changed( 'posts' ) );
    323326        }
    324327
     
    330333
    331334                wp_cache_delete( 'last_changed', 'posts' );
    332335
    333                 $this->assertInternalType( 'integer', update_metadata( 'post', $post_id, 'foo', 'bar' ) );
     336                $this->assertIsInt( update_metadata( 'post', $post_id, 'foo', 'bar' ) );
    334337                $this->assertNotFalse( wp_cache_get_last_changed( 'posts' ) );
    335338        }
    336339
  • tests/phpunit/tests/post/objects.php

     
    3030
    3131                // Excercise the output argument.
    3232                $post = get_post( $id, ARRAY_A );
    33                 $this->assertInternalType( 'array', $post );
     33                $this->assertIsArray( $post );
    3434                $this->assertSame( 'post', $post['post_type'] );
    3535
    3636                $post = get_post( $id, ARRAY_N );
    37                 $this->assertInternalType( 'array', $post );
     37                $this->assertIsArray( $post );
    3838                $this->assertFalse( isset( $post['post_type'] ) );
    3939                $this->assertTrue( in_array( 'post', $post, true ) );
    4040
    4141                $post = get_post( $id );
    4242                $post = get_post( $post, ARRAY_A );
    43                 $this->assertInternalType( 'array', $post );
     43                $this->assertIsArray( $post );
    4444                $this->assertSame( 'post', $post['post_type'] );
    4545                $this->assertSame( $id, $post['ID'] );
    4646
     
    5151
    5252                // Make sure stdClass in $GLOBALS['post'] is handled.
    5353                $post_std = $post->to_array();
    54                 $this->assertInternalType( 'array', $post_std );
     54                $this->assertIsArray( $post_std );
    5555                $post_std        = (object) $post_std;
    5656                $GLOBALS['post'] = $post_std;
    5757                $post            = get_post( null );
     
    103103         */
    104104        function test_get_post_ancestors_with_falsey_values() {
    105105                foreach ( array( null, 0, false, '0', '' ) as $post_id ) {
    106                         $this->assertInternalType( 'array', get_post_ancestors( $post_id ) );
     106                        $this->assertIsArray( get_post_ancestors( $post_id ) );
    107107                        $this->assertSame( array(), get_post_ancestors( $post_id ) );
    108108                }
    109109        }
     
    112112                $post_id = self::factory()->post->create();
    113113                $post    = get_post( $post_id );
    114114
    115                 $this->assertInternalType( 'array', $post->post_category );
     115                $this->assertIsArray( $post->post_category );
    116116                $this->assertSame( 1, count( $post->post_category ) );
    117117                $this->assertEquals( get_option( 'default_category' ), $post->post_category[0] );
    118118                $term1 = wp_insert_term( 'Foo', 'category' );
     
    131131                $post_id = self::factory()->post->create();
    132132                $post    = get_post( $post_id );
    133133
    134                 $this->assertInternalType( 'array', $post->tags_input );
     134                $this->assertIsArray( $post->tags_input );
    135135                $this->assertEmpty( $post->tags_input );
    136136                wp_set_post_tags( $post_id, 'Foo, Bar, Baz' );
    137                 $this->assertInternalType( 'array', $post->tags_input );
     137                $this->assertIsArray( $post->tags_input );
    138138                $this->assertSame( 3, count( $post->tags_input ) );
    139139                $this->assertSame( array( 'Bar', 'Baz', 'Foo' ), $post->tags_input );
    140140
    141141                $post = get_post( $post_id, ARRAY_A );
    142                 $this->assertInternalType( 'array', $post['tags_input'] );
     142                $this->assertIsArray( $post['tags_input'] );
    143143                $this->assertSame( 3, count( $post['tags_input'] ) );
    144144                $this->assertSame( array( 'Bar', 'Baz', 'Foo' ), $post['tags_input'] );
    145145        }
     
    148148                $post_id = self::factory()->post->create();
    149149                $post    = get_post( $post_id );
    150150
    151                 $this->assertInternalType( 'string', $post->page_template );
     151                $this->assertIsString( $post->page_template );
    152152                $template = get_post_meta( $post->ID, '_wp_page_template', true );
    153153                $this->assertSame( $template, $post->page_template );
    154154                update_post_meta( $post_id, '_wp_page_template', 'foo.php' );
     
    167167                );
    168168
    169169                $this->assertSame( 'raw', $post->filter );
    170                 $this->assertInternalType( 'int', $post->post_parent );
     170                $this->assertIsInt( $post->post_parent );
    171171
    172172                $display_post = get_post( $post, OBJECT, 'js' );
    173173                $this->assertSame( 'js', $display_post->filter );
     
    194194                foreach ( $contexts as $context ) {
    195195                        $post = get_post( $post_id, OBJECT, $context );
    196196
    197                         $this->assertInternalType( 'int', $post->ID );
    198                         $this->assertInternalType( 'int', $post->post_parent );
    199                         $this->assertInternalType( 'int', $post->menu_order );
     197                        $this->assertIsInt( $post->ID );
     198                        $this->assertIsInt( $post->post_parent );
     199                        $this->assertIsInt( $post->menu_order );
    200200                }
    201201        }
    202202
     
    215215                $post = get_post( $id, ARRAY_A );
    216216
    217217                $this->assertSame( $id, $post['ID'] );
    218                 $this->assertInternalType( 'array', $post['ancestors'] );
     218                $this->assertIsArray( $post['ancestors'] );
    219219                $this->assertSame( 'raw', $post['filter'] );
    220220        }
    221221
  • tests/phpunit/tests/post/query.php

     
    737737                        )
    738738                );
    739739
    740                 $this->assertInternalType( 'int', $q->found_posts );
     740                $this->assertIsInt( $q->found_posts );
    741741        }
    742742
    743743        /**
     
    756756
    757757                remove_filter( 'found_posts', '__return_empty_string' );
    758758
    759                 $this->assertInternalType( 'int', $q->found_posts );
     759                $this->assertIsInt( $q->found_posts );
    760760        }
    761761}
  • tests/phpunit/tests/post/types.php

     
    321321                        )
    322322                );
    323323
    324                 $this->assertInternalType( 'int', array_search( 'bar', $wp->public_query_vars, true ) );
     324                $this->assertIsInt( array_search( 'bar', $wp->public_query_vars, true ) );
    325325                $this->assertTrue( unregister_post_type( 'foo' ) );
    326326                $this->assertFalse( array_search( 'bar', $wp->public_query_vars, true ) );
    327327        }
     
    439439                        )
    440440                );
    441441
    442                 $this->assertInternalType( 'int', array_search( 'foo', $wp_taxonomies['category']->object_type, true ) );
    443                 $this->assertInternalType( 'int', array_search( 'foo', $wp_taxonomies['post_tag']->object_type, true ) );
     442                $this->assertIsInt( array_search( 'foo', $wp_taxonomies['category']->object_type, true ) );
     443                $this->assertIsInt( array_search( 'foo', $wp_taxonomies['post_tag']->object_type, true ) );
    444444                $this->assertTrue( unregister_post_type( 'foo' ) );
    445445                $this->assertFalse( array_search( 'foo', $wp_taxonomies['category']->object_type, true ) );
    446446                $this->assertFalse( array_search( 'foo', $wp_taxonomies['post_tag']->object_type, true ) );
     
    499499                        )
    500500                );
    501501
    502                 $this->assertInternalType( 'object', $wp_post_types['foo'] );
    503                 $this->assertInternalType( 'object', get_post_type_object( 'foo' ) );
     502                $this->assertIsObject( $wp_post_types['foo'] );
     503                $this->assertIsObject( get_post_type_object( 'foo' ) );
    504504
    505505                $this->assertTrue( unregister_post_type( 'foo' ) );
    506506
  • tests/phpunit/tests/query/results.php

     
    765765                $this->assertSame( $children, $posts2 );
    766766
    767767                foreach ( $this->q->posts as $post ) {
    768                         $this->assertInternalType( 'int', $post->ID );
    769                         $this->assertInternalType( 'int', $post->post_parent );
     768                        $this->assertIsInt( $post->ID );
     769                        $this->assertIsInt( $post->post_parent );
    770770                }
    771771
    772772        }
  • tests/phpunit/tests/rest-api/rest-attachments-controller.php

     
    658658                $original_image_src = wp_get_attachment_image_src( $attachment_id, 'full' );
    659659                remove_image_size( 'rest-api-test' );
    660660
    661                 $this->assertInternalType( 'array', $data['media_details']['sizes'], 'Could not retrieve the sizes data.' );
     661                $this->assertIsArray( $data['media_details']['sizes'], 'Could not retrieve the sizes data.' );
    662662                $this->assertSame( $image_src[0], $data['media_details']['sizes']['rest-api-test']['source_url'] );
    663663                $this->assertSame( 'image/jpeg', $data['media_details']['sizes']['rest-api-test']['mime_type'] );
    664664                $this->assertSame( $original_image_src[0], $data['media_details']['sizes']['full']['source_url'] );
     
    690690                remove_filter( 'wp_get_attachment_image_src', '__return_false' );
    691691                remove_image_size( 'rest-api-test' );
    692692
    693                 $this->assertInternalType( 'array', $data['media_details']['sizes'], 'Could not retrieve the sizes data.' );
     693                $this->assertIsArray( $data['media_details']['sizes'], 'Could not retrieve the sizes data.' );
    694694                $this->assertFalse( isset( $data['media_details']['sizes']['rest-api-test']['source_url'] ) );
    695695        }
    696696
  • tests/phpunit/tests/rest-api/rest-comments-controller.php

     
    29032903                $actual_output = $response->get_data();
    29042904
    29052905                // Compare expected API output to actual API output.
    2906                 $this->assertInternalType( 'array', $actual_output['content'] );
     2906                $this->assertIsArray( $actual_output['content'] );
    29072907                $this->assertArrayHasKey( 'raw', $actual_output['content'] );
    29082908                $this->assertSame( $expected_output['content']['raw'], $actual_output['content']['raw'] );
    29092909                $this->assertSame( $expected_output['content']['rendered'], trim( $actual_output['content']['rendered'] ) );
  • tests/phpunit/tests/rest-api/rest-post-meta-fields.php

     
    290290                $data = $response->get_data();
    291291                $meta = (array) $data['meta'];
    292292                $this->assertArrayHasKey( 'test_multi', $meta );
    293                 $this->assertInternalType( 'array', $meta['test_multi'] );
     293                $this->assertIsArray( $meta['test_multi'] );
    294294                $this->assertContains( 'value1', $meta['test_multi'] );
    295295
    296296                // Check after an update.
     
    395395                $meta = (array) $data['meta'];
    396396
    397397                $this->assertArrayHasKey( 'test_string', $meta );
    398                 $this->assertInternalType( 'string', $meta['test_string'] );
     398                $this->assertIsString( $meta['test_string'] );
    399399                $this->assertSame( '42', $meta['test_string'] );
    400400
    401401                $this->assertArrayHasKey( 'test_number', $meta );
    402                 $this->assertInternalType( 'float', $meta['test_number'] );
     402                $this->assertIsFloat( $meta['test_number'] );
    403403                $this->assertSame( 42.0, $meta['test_number'] );
    404404
    405405                $this->assertArrayHasKey( 'test_bool', $meta );
    406                 $this->assertInternalType( 'boolean', $meta['test_bool'] );
     406                $this->assertIsBool( $meta['test_bool'] );
    407407                $this->assertTrue( $meta['test_bool'] );
    408408        }
    409409
     
    12721272                $data = $response->get_data();
    12731273
    12741274                $this->assertArrayHasKey( 'meta', $data );
    1275                 $this->assertInternalType( 'array', $data['meta'] );
     1275                $this->assertIsArray( $data['meta'] );
    12761276
    12771277                if ( $in_post_type ) {
    12781278                        $expected_value = $meta_value;
     
    13381338
    13391339                $data = $response->get_data();
    13401340                $this->assertArrayHasKey( 'meta', $data );
    1341                 $this->assertInternalType( 'array', $data['meta'] );
     1341                $this->assertIsArray( $data['meta'] );
    13421342
    13431343                if ( $in_post_type ) {
    13441344                        $expected_value = $meta_value;
  • tests/phpunit/tests/rest-api/rest-request.php

     
    491491                $this->assertWPError( $valid );
    492492                $data = $valid->get_error_data();
    493493
    494                 $this->assertInternalType( 'array', $data );
     494                $this->assertIsArray( $data );
    495495                $this->assertArrayHasKey( 'params', $data );
    496496                $this->assertArrayHasKey( 'failparam', $data['params'] );
    497497                $this->assertSame( 'Invalid. Super Invalid. Broken.', $data['params']['failparam'] );
     
    754754                $this->assertWPError( $valid );
    755755                $data = $valid->get_error_data();
    756756
    757                 $this->assertInternalType( 'array', $data );
     757                $this->assertIsArray( $data );
    758758                $this->assertArrayHasKey( 'params', $data );
    759759                $this->assertArrayHasKey( 'failparam', $data['params'] );
    760760                $this->assertSame( 'Invalid. Super Invalid. Broken.', $data['params']['failparam'] );
  • tests/phpunit/tests/rest-api/rest-server.php

     
    545545                $this->assertCount( 2, $alternate );
    546546                $this->assertEmpty( $alternate[0] );
    547547
    548                 $this->assertInternalType( 'array', $alternate[1] );
     548                $this->assertIsArray( $alternate[1] );
    549549                $this->assertArrayNotHasKey( 'code', $alternate[1] );
    550550                $this->assertTrue( $alternate[1]['hello'] );
    551551
  • tests/phpunit/tests/rest-api/rest-term-meta-fields.php

     
    237237                $data = $response->get_data();
    238238                $meta = (array) $data['meta'];
    239239                $this->assertArrayHasKey( 'test_multi', $meta );
    240                 $this->assertInternalType( 'array', $meta['test_multi'] );
     240                $this->assertIsArray( $meta['test_multi'] );
    241241                $this->assertContains( 'value1', $meta['test_multi'] );
    242242
    243243                // Check after an update.
     
    342342                $meta = (array) $data['meta'];
    343343
    344344                $this->assertArrayHasKey( 'test_string', $meta );
    345                 $this->assertInternalType( 'string', $meta['test_string'] );
     345                $this->assertIsString( $meta['test_string'] );
    346346                $this->assertSame( '42', $meta['test_string'] );
    347347
    348348                $this->assertArrayHasKey( 'test_number', $meta );
    349                 $this->assertInternalType( 'float', $meta['test_number'] );
     349                $this->assertIsFloat( $meta['test_number'] );
    350350                $this->assertSame( 42.0, $meta['test_number'] );
    351351
    352352                $this->assertArrayHasKey( 'test_bool', $meta );
    353                 $this->assertInternalType( 'boolean', $meta['test_bool'] );
     353                $this->assertIsBool( $meta['test_bool'] );
    354354                $this->assertTrue( $meta['test_bool'] );
    355355        }
    356356
     
    11571157                $data = $response->get_data();
    11581158
    11591159                $this->assertArrayHasKey( 'meta', $data );
    1160                 $this->assertInternalType( 'array', $data['meta'] );
     1160                $this->assertIsArray( $data['meta'] );
    11611161
    11621162                if ( $in_taxonomy ) {
    11631163                        $expected_value = $meta_value;
     
    12211221
    12221222                $data = $response->get_data();
    12231223                $this->assertArrayHasKey( 'meta', $data );
    1224                 $this->assertInternalType( 'array', $data['meta'] );
     1224                $this->assertIsArray( $data['meta'] );
    12251225
    12261226                if ( $in_taxonomy ) {
    12271227                        $expected_value = $meta_value;
  • tests/phpunit/tests/rest-api/rest-users-controller.php

     
    12111211                $data = $response->get_data();
    12121212
    12131213                if ( is_multisite() ) {
    1214                         $this->assertInternalType( 'array', $data['additional_errors'] );
     1214                        $this->assertIsArray( $data['additional_errors'] );
    12151215                        $this->assertCount( 1, $data['additional_errors'] );
    12161216                        $error = $data['additional_errors'][0];
    12171217                        $this->assertSame( 'user_name', $error['code'] );
    12181218                        $this->assertSame( 'Usernames can only contain lowercase letters (a-z) and numbers.', $error['message'] );
    12191219                } else {
    1220                         $this->assertInternalType( 'array', $data['data']['params'] );
     1220                        $this->assertIsArray( $data['data']['params'] );
    12211221                        $errors = $data['data']['params'];
    1222                         $this->assertInternalType( 'string', $errors['username'] );
     1222                        $this->assertIsString( $errors['username'] );
    12231223                        $this->assertSame( 'This username is invalid because it uses illegal characters. Please enter a valid username.', $errors['username'] );
    12241224                }
    12251225        }
     
    12571257                $this->assertErrorResponse( 'rest_invalid_param', $response, 400 );
    12581258
    12591259                $data = $response->get_data();
    1260                 $this->assertInternalType( 'array', $data['data']['params'] );
     1260                $this->assertIsArray( $data['data']['params'] );
    12611261                $errors = $data['data']['params'];
    1262                 $this->assertInternalType( 'string', $errors['username'] );
     1262                $this->assertIsString( $errors['username'] );
    12631263                $this->assertSame( 'Sorry, that username is not allowed.', $errors['username'] );
    12641264        }
    12651265
     
    13811381
    13821382                $this->assertErrorResponse( 'rest_invalid_param', $switched_response, 400 );
    13831383                $data = $switched_response->get_data();
    1384                 $this->assertInternalType( 'array', $data['additional_errors'] );
     1384                $this->assertIsArray( $data['additional_errors'] );
    13851385                $this->assertCount( 2, $data['additional_errors'] );
    13861386                $errors = $data['additional_errors'];
    13871387                foreach ( $errors as $error ) {
  • tests/phpunit/tests/rewrite.php

     
    482482                $this->set_permalink_structure( '/%year%/%monthnum%/%day%/%postname%/' );
    483483
    484484                $rewrite_rules = get_option( 'rewrite_rules' );
    485                 $this->assertInternalType( 'array', $rewrite_rules );
     485                $this->assertIsArray( $rewrite_rules );
    486486                $this->assertNotEmpty( $rewrite_rules );
    487487        }
    488488}
  • tests/phpunit/tests/rewrite/permastructs.php

     
    3434                global $wp_rewrite;
    3535
    3636                add_permastruct( 'foo', 'bar/%foo%' );
    37                 $this->assertInternalType( 'array', $wp_rewrite->extra_permastructs['foo'] );
     37                $this->assertIsArray( $wp_rewrite->extra_permastructs['foo'] );
    3838                $this->assertSame( '/bar/%foo%', $wp_rewrite->extra_permastructs['foo']['struct'] );
    3939
    4040                remove_permastruct( 'foo' );
  • tests/phpunit/tests/taxonomy.php

     
    818818
    819819                register_taxonomy( 'foo', 'post', array( 'query_var' => 'bar' ) );
    820820
    821                 $this->assertInternalType( 'int', array_search( 'bar', $wp->public_query_vars, true ) );
     821                $this->assertIsInt( array_search( 'bar', $wp->public_query_vars, true ) );
    822822                $this->assertTrue( unregister_taxonomy( 'foo' ) );
    823823                $this->assertFalse( array_search( 'bar', $wp->public_query_vars, true ) );
    824824        }
     
    840840                        )
    841841                );
    842842
    843                 $this->assertInternalType( 'array', $wp_rewrite->extra_permastructs['foo'] );
     843                $this->assertIsArray( $wp_rewrite->extra_permastructs['foo'] );
    844844                $this->assertTrue( unregister_taxonomy( 'foo' ) );
    845845                $this->assertFalse( isset( $wp_rewrite->extra_permastructs['foo'] ) );
    846846        }
     
    873873
    874874                register_taxonomy( 'foo', 'post' );
    875875
    876                 $this->assertInternalType( 'object', $wp_taxonomies['foo'] );
    877                 $this->assertInternalType( 'object', get_taxonomy( 'foo' ) );
     876                $this->assertIsObject( $wp_taxonomies['foo'] );
     877                $this->assertIsObject( get_taxonomy( 'foo' ) );
    878878
    879879                $this->assertTrue( unregister_taxonomy( 'foo' ) );
    880880
  • tests/phpunit/tests/taxonomy/getObjectTaxonomies.php

     
    3636                $found = get_object_taxonomies( 'wptests_pt', 'objects' );
    3737
    3838                $this->assertSame( array( 'wptests_tax' ), array_keys( $found ) );
    39                 $this->assertInternalType( 'object', $found['wptests_tax'] );
     39                $this->assertIsObject( $found['wptests_tax'] );
    4040                $this->assertSame( 'wptests_tax', $found['wptests_tax']->name );
    4141        }
    4242
     
    8787                $found = get_object_taxonomies( $attachment, 'objects' );
    8888
    8989                $this->assertSame( array( 'wptests_tax2' ), array_keys( $found ) );
    90                 $this->assertInternalType( 'object', $found['wptests_tax2'] );
     90                $this->assertIsObject( $found['wptests_tax2'] );
    9191                $this->assertSame( 'wptests_tax2', $found['wptests_tax2']->name );
    9292        }
    9393}
  • tests/phpunit/tests/term.php

     
    5353                // Insert a term.
    5454                $term = rand_str();
    5555                $t    = wp_insert_term( $term, $this->taxonomy );
    56                 $this->assertInternalType( 'array', $t );
     56                $this->assertIsArray( $t );
    5757                $term_obj = get_term_by( 'name', $term, $this->taxonomy );
    5858                $this->assertEquals( $t['term_id'], term_exists( $term_obj->slug ) );
    5959
     
    132132                $term2 = rand_str();
    133133
    134134                $t = wp_insert_term( $term, 'category' );
    135                 $this->assertInternalType( 'array', $t );
     135                $this->assertIsArray( $t );
    136136                $t2 = wp_insert_term( $term, 'category', array( 'parent' => $t['term_id'] ) );
    137                 $this->assertInternalType( 'array', $t2 );
     137                $this->assertIsArray( $t2 );
    138138                if ( function_exists( 'term_is_ancestor_of' ) ) {
    139139                        $this->assertTrue( term_is_ancestor_of( $t['term_id'], $t2['term_id'], 'category' ) );
    140140                        $this->assertFalse( term_is_ancestor_of( $t2['term_id'], $t['term_id'], 'category' ) );
     
    176176                $post_id = self::$post_ids[0];
    177177                $post    = get_post( $post_id );
    178178
    179                 $this->assertInternalType( 'array', $post->post_category );
     179                $this->assertIsArray( $post->post_category );
    180180                $this->assertSame( 1, count( $post->post_category ) );
    181181                $this->assertEquals( get_option( 'default_category' ), $post->post_category[0] );
    182182
  • tests/phpunit/tests/term/getTerm.php

     
    9797
    9898        public function test_output_object() {
    9999                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    100                 $this->assertInternalType( 'object', get_term( $t, 'wptests_tax', OBJECT ) );
     100                $this->assertIsObject( get_term( $t, 'wptests_tax', OBJECT ) );
    101101        }
    102102
    103103        public function test_output_array_a() {
    104104                $t    = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    105105                $term = get_term( $t, 'wptests_tax', ARRAY_A );
    106                 $this->assertInternalType( 'array', $term );
     106                $this->assertIsArray( $term );
    107107                $this->assertTrue( isset( $term['term_id'] ) );
    108108        }
    109109
     
    110110        public function test_output_array_n() {
    111111                $t    = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    112112                $term = get_term( $t, 'wptests_tax', ARRAY_N );
    113                 $this->assertInternalType( 'array', $term );
     113                $this->assertIsArray( $term );
    114114                $this->assertFalse( isset( $term['term_id'] ) );
    115115                foreach ( $term as $k => $v ) {
    116                         $this->assertInternalType( 'integer', $k );
     116                        $this->assertIsInt( $k );
    117117                }
    118118        }
    119119
    120120        public function test_output_should_fall_back_to_object_for_invalid_input() {
    121121                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    122                 $this->assertInternalType( 'object', get_term( $t, 'wptests_tax', 'foo' ) );
     122                $this->assertIsObject( get_term( $t, 'wptests_tax', 'foo' ) );
    123123        }
    124124
    125125        /**
     
    140140                        $found = get_term( $term_data, '', OBJECT, $context );
    141141
    142142                        $this->assertInstanceOf( 'WP_Term', $found );
    143                         $this->assertInternalType( 'int', $found->term_id );
    144                         $this->assertInternalType( 'int', $found->term_taxonomy_id );
    145                         $this->assertInternalType( 'int', $found->parent );
    146                         $this->assertInternalType( 'int', $found->count );
    147                         $this->assertInternalType( 'int', $found->term_group );
     143                        $this->assertIsInt( $found->term_id );
     144                        $this->assertIsInt( $found->term_taxonomy_id );
     145                        $this->assertIsInt( $found->parent );
     146                        $this->assertIsInt( $found->count );
     147                        $this->assertIsInt( $found->term_group );
    148148                }
    149149        }
    150150
  • tests/phpunit/tests/term/getTerms.php

     
    861861                $term = get_term( $term['term_id'], 'category' );
    862862
    863863                $this->assertSame( $term->term_id, $term->parent );
    864                 $this->assertInternalType( 'array', get_term_children( $term->term_id, 'category' ) );
     864                $this->assertIsArray( get_term_children( $term->term_id, 'category' ) );
    865865
    866866                add_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10, 3 );
    867867        }
  • tests/phpunit/tests/term/getTheTerms.php

     
    3939                // get_the_terms() does prime the cache.
    4040                $terms = get_the_terms( $post_id, $this->taxonomy );
    4141                $cache = wp_cache_get( $post_id, $this->taxonomy . '_relationships' );
    42                 $this->assertInternalType( 'array', $cache );
     42                $this->assertIsArray( $cache );
    4343
    4444                // Cache should be empty after a set.
    4545                $tt_2 = wp_set_object_terms( $post_id, $terms_2, $this->taxonomy );
  • tests/phpunit/tests/term/meta.php

     
    9494                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    9595
    9696                $actual = update_term_meta( $t, 'foo', 'bar' );
    97                 $this->assertInternalType( 'int', $actual );
     97                $this->assertIsInt( $actual );
    9898                $this->assertNotEmpty( $actual );
    9999
    100100                $meta = get_term_meta( $t, 'foo', true );
     
    549549
    550550                wp_cache_delete( 'last_changed', 'terms' );
    551551
    552                 $this->assertInternalType( 'integer', add_metadata( 'term', $term_id, 'foo', 'bar' ) );
     552                $this->assertIsInt( add_metadata( 'term', $term_id, 'foo', 'bar' ) );
    553553                $this->assertNotFalse( wp_cache_get_last_changed( 'terms' ) );
    554554        }
    555555
     
    561561
    562562                wp_cache_delete( 'last_changed', 'terms' );
    563563
    564                 $this->assertInternalType( 'integer', update_metadata( 'term', $term_id, 'foo', 'bar' ) );
     564                $this->assertIsInt( update_metadata( 'term', $term_id, 'foo', 'bar' ) );
    565565                $this->assertNotFalse( wp_cache_get_last_changed( 'terms' ) );
    566566        }
    567567
  • tests/phpunit/tests/term/termExists.php

     
    116116
    117117                _unregister_taxonomy( 'foo' );
    118118
    119                 $this->assertInternalType( 'array', $found );
     119                $this->assertIsArray( $found );
    120120                $this->assertEquals( $t, $found['term_id'] );
    121121        }
    122122
     
    180180
    181181                _unregister_taxonomy( 'foo' );
    182182
    183                 $this->assertInternalType( 'array', $found );
     183                $this->assertIsArray( $found );
    184184                $this->assertEquals( $t, $found['term_id'] );
    185185        }
    186186
     
    198198
    199199                _unregister_taxonomy( 'foo' );
    200200
    201                 $this->assertInternalType( 'array', $found );
     201                $this->assertIsArray( $found );
    202202                $this->assertEquals( $t, $found['term_id'] );
    203203        }
    204204
     
    216216
    217217                _unregister_taxonomy( 'foo' );
    218218
    219                 $this->assertInternalType( 'array', $found );
     219                $this->assertIsArray( $found );
    220220                $this->assertEquals( $t, $found['term_id'] );
    221221        }
    222222
     
    234234
    235235                _unregister_taxonomy( 'foo' );
    236236
    237                 $this->assertInternalType( 'string', $found );
     237                $this->assertIsString( $found );
    238238                $this->assertEquals( $t, $found );
    239239        }
    240240
     
    252252
    253253                _unregister_taxonomy( 'foo' );
    254254
    255                 $this->assertInternalType( 'string', $found );
     255                $this->assertIsString( $found );
    256256                $this->assertEquals( $t, $found );
    257257        }
    258258
     
    262262                // Insert a term.
    263263                $term = rand_str();
    264264                $t    = wp_insert_term( $term, 'wptests_tax' );
    265                 $this->assertInternalType( 'array', $t );
     265                $this->assertIsArray( $t );
    266266                $this->assertEquals( $t['term_id'], term_exists( $t['term_id'] ) );
    267267                $this->assertEquals( $t['term_id'], term_exists( $term ) );
    268268
  • tests/phpunit/tests/term/wpGenerateTagCloud.php

     
    106106                        )
    107107                );
    108108
    109                 $this->assertInternalType( 'array', $found );
     109                $this->assertIsArray( $found );
    110110                $this->assertContains( '>' . $tags[0]->name . '<', $found[0] );
    111111        }
    112112
  • tests/phpunit/tests/term/wpGetObjectTerms.php

     
    7373                $term       = array_shift( $terms );
    7474                $int_fields = array( 'parent', 'term_id', 'count', 'term_group', 'term_taxonomy_id', 'object_id' );
    7575                foreach ( $int_fields as $field ) {
    76                         $this->assertInternalType( 'int', $term->$field, $field );
     76                        $this->assertIsInt( $term->$field, $field );
    7777                }
    7878
    7979                $terms = wp_get_object_terms( $post_id, $this->taxonomy, array( 'fields' => 'ids' ) );
    8080                $term  = array_shift( $terms );
    81                 $this->assertInternalType( 'int', $term, 'term' );
     81                $this->assertIsInt( $term, 'term' );
    8282        }
    8383
    8484        /**
     
    9393                $terms = wp_get_object_terms( $post_id, $this->taxonomy );
    9494                remove_filter( 'wp_get_object_terms', array( $this, 'filter_get_object_terms' ) );
    9595                foreach ( $terms as $term ) {
    96                         $this->assertInternalType( 'object', $term );
     96                        $this->assertIsObject( $term );
    9797                }
    9898        }
    9999
  • tests/phpunit/tests/term/wpInsertTerm.php

     
    2727                $initial_count = wp_count_terms( array( 'taxonomy' => $taxonomy ) );
    2828
    2929                $t = wp_insert_term( $term, $taxonomy );
    30                 $this->assertInternalType( 'array', $t );
     30                $this->assertIsArray( $t );
    3131                $this->assertNotWPError( $t );
    3232                $this->assertTrue( $t['term_id'] > 0 );
    3333                $this->assertTrue( $t['term_taxonomy_id'] > 0 );
     
    776776
    777777                _unregister_taxonomy( 'wptests_tax' );
    778778
    779                 $this->assertInternalType( 'array', $found );
     779                $this->assertIsArray( $found );
    780780                $this->assertNotEmpty( $found['term_id'] );
    781781                $this->assertNotEmpty( $found['term_taxonomy_id'] );
    782782                $this->assertNotEmpty( $term_by_id );
     
    844844                        )
    845845                );
    846846
    847                 $this->assertInternalType( 'int', $t1 );
    848                 $this->assertInternalType( 'int', $t2 );
     847                $this->assertIsInt( $t1 );
     848                $this->assertIsInt( $t2 );
    849849                $this->assertNotEquals( $t1, $t2 );
    850850
    851851                $term_2 = get_term( $t2, 'wptests_tax' );
     
    900900        /** Helpers */
    901901
    902902        public function deleted_term_cb( $term, $tt_id, $taxonomy, $deleted_term, $object_ids ) {
    903                 $this->assertInternalType( 'object', $deleted_term );
    904                 $this->assertInternalType( 'int', $term );
    905                 $this->assertInternalType( 'array', $object_ids );
    906                 // Pesky string $this->assertInternalType( 'int', $tt_id );
     903                $this->assertIsObject( $deleted_term );
     904                $this->assertIsInt( $term );
     905                $this->assertIsArray( $object_ids );
     906                // Pesky string $this->assertIsInt( $tt_id );
    907907                $this->assertSame( $term, $deleted_term->term_id );
    908908                $this->assertSame( $taxonomy, $deleted_term->taxonomy );
    909909                $this->assertEquals( $tt_id, $deleted_term->term_taxonomy_id );
  • tests/phpunit/tests/term/wpSetObjectTerms.php

     
    106106                for ( $i = 0; $i < 3; $i++ ) {
    107107                        $term   = "term_{$i}";
    108108                        $result = wp_insert_term( $term, $this->taxonomy );
    109                         $this->assertInternalType( 'array', $result );
     109                        $this->assertIsArray( $result );
    110110                        $term_id[ $term ] = $result['term_id'];
    111111                }
    112112
     
    254254                for ( $i = 0; $i < 3; $i++ ) {
    255255                        $term   = "term_{$i}";
    256256                        $result = wp_insert_term( $term, $this->taxonomy );
    257                         $this->assertInternalType( 'array', $result );
     257                        $this->assertIsArray( $result );
    258258                        $terms_1[ $i ] = $result['term_id'];
    259259                }
    260260
  • tests/phpunit/tests/term/wpUpdateTerm.php

     
    612612
    613613                _unregister_taxonomy( 'wptests_tax' );
    614614
    615                 $this->assertInternalType( 'array', $found );
     615                $this->assertIsArray( $found );
    616616                $this->assertNotEmpty( $found['term_id'] );
    617617                $this->assertNotEmpty( $found['term_taxonomy_id'] );
    618618                $this->assertNotEmpty( $term_by_id );
     
    638638                        )
    639639                );
    640640
    641                 $this->assertInternalType( 'int', $found['term_id'] );
    642                 $this->assertInternalType( 'int', $found['term_taxonomy_id'] );
     641                $this->assertIsInt( $found['term_id'] );
     642                $this->assertIsInt( $found['term_taxonomy_id'] );
    643643        }
    644644
    645645        public function test_wp_update_term_should_clean_term_cache() {
  • tests/phpunit/tests/theme/getThemeStarterContent.php

     
    142142                $this->assertSame( $dehydrated_starter_content['attachments']['featured-image-logo'], $hydrated_starter_content['attachments']['featured-image-logo'] );
    143143
    144144                foreach ( $hydrated_starter_content['widgets']['sidebar-1'] as $widget ) {
    145                         $this->assertInternalType( 'array', $widget );
     145                        $this->assertIsArray( $widget );
    146146                        $this->assertCount( 2, $widget );
    147                         $this->assertInternalType( 'string', $widget[0] );
    148                         $this->assertInternalType( 'array', $widget[1] );
     147                        $this->assertIsString( $widget[0] );
     148                        $this->assertIsArray( $widget[1] );
    149149                        $this->assertArrayHasKey( 'title', $widget[1] );
    150150                }
    151151                $this->assertSame( 'text', $hydrated_starter_content['widgets']['sidebar-1'][1][0], 'Core content extended' );
     
    152152                $this->assertSame( 'Our Story', $hydrated_starter_content['widgets']['sidebar-1'][1][1]['title'], 'Core content extended' );
    153153
    154154                foreach ( $hydrated_starter_content['nav_menus']['top']['items'] as $nav_menu_item ) {
    155                         $this->assertInternalType( 'array', $nav_menu_item );
     155                        $this->assertIsArray( $nav_menu_item );
    156156                        $this->assertTrue( ! empty( $nav_menu_item['object_id'] ) || ! empty( $nav_menu_item['url'] ) );
    157157                }
    158158                $this->assertSame( 'Email Us', $hydrated_starter_content['nav_menus']['top']['items'][4]['title'], 'Core content extended' );
    159159
    160160                foreach ( $hydrated_starter_content['posts'] as $key => $post ) {
    161                         $this->assertInternalType( 'string', $key );
     161                        $this->assertIsString( $key );
    162162                        $this->assertFalse( is_numeric( $key ) );
    163                         $this->assertInternalType( 'array', $post );
     163                        $this->assertIsArray( $post );
    164164                        $this->assertArrayHasKey( 'post_type', $post );
    165165                        $this->assertArrayHasKey( 'post_title', $post );
    166166                }
     
    200200         * @return array Filtered starter content.
    201201         */
    202202        public function filter_theme_starter_content( $content, $config ) {
    203                 $this->assertInternalType( 'array', $config );
     203                $this->assertIsArray( $config );
    204204                $this->assertCount( 1, $config['widgets']['sidebar-1'] );
    205205                $content['widgets']['sidebar-1'][] = array(
    206206                        'text',
  • tests/phpunit/tests/user.php

     
    216216                        $user->filter = $context;
    217217                        $user->init( $user->data );
    218218
    219                         $this->assertInternalType( 'int', $user->ID );
     219                        $this->assertIsInt( $user->ID );
    220220                }
    221221        }
    222222
     
    870870                        )
    871871                );
    872872
    873                 $this->assertInternalType( 'int', $u );
     873                $this->assertIsInt( $u );
    874874                $this->assertGreaterThan( 0, $u );
    875875
    876876                $user = new WP_User( $u );
     
    14931493                $user_id = edit_user();
    14941494                $user    = get_user_by( 'ID', $user_id );
    14951495
    1496                 $this->assertInternalType( 'int', $user_id );
     1496                $this->assertIsInt( $user_id );
    14971497                $this->assertInstanceOf( 'WP_User', $user );
    14981498                $this->assertSame( 'nickname1', $user->nickname );
    14991499
     
    15041504
    15051505                $user_id = edit_user( $user_id );
    15061506
    1507                 $this->assertInternalType( 'int', $user_id );
     1507                $this->assertIsInt( $user_id );
    15081508                $this->assertSame( 'nickname_updated', $user->nickname );
    15091509
    15101510                // Check not to change an old password if a new password contains only spaces. Ticket #42766.
     
    15161516                $user_id = edit_user( $user_id );
    15171517                $user    = get_user_by( 'ID', $user_id );
    15181518
    1519                 $this->assertInternalType( 'int', $user_id );
     1519                $this->assertIsInt( $user_id );
    15201520                $this->assertSame( $old_pass, $user->user_pass );
    15211521
    15221522                // Check updating user with missing second password.
     
    15351535                $user_id = edit_user( $user_id );
    15361536                remove_action( 'check_passwords', array( $this, 'action_check_passwords_blank_password' ) );
    15371537
    1538                 $this->assertInternalType( 'int', $user_id );
     1538                $this->assertIsInt( $user_id );
    15391539                $this->assertSame( 'nickname_updated2', $user->nickname );
    15401540        }
    15411541
  • tests/phpunit/tests/user/multisite.php

     
    124124
    125125                        $blog_id = self::factory()->blog->create( array( 'user_id' => get_current_user_id() ) );
    126126
    127                         $this->assertInternalType( 'int', $blog_id );
     127                        $this->assertIsInt( $blog_id );
    128128                        $this->assertTrue( is_blog_user( $blog_id ) );
    129129                        $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
    130130                        $this->assertFalse( is_blog_user( $blog_id ) );
     
    156156
    157157                        $blog_id = self::factory()->blog->create( array( 'user_id' => get_current_user_id() ) );
    158158
    159                         $this->assertInternalType( 'int', $blog_id );
     159                        $this->assertIsInt( $blog_id );
    160160
    161161                        // Current user gets added to new blogs.
    162162                        $this->assertTrue( is_user_member_of_blog( $user1_id, $blog_id ) );
  • tests/phpunit/tests/widgets.php

     
    624624                $this->assertSame( 1, $option_value['_multiwidget'] );
    625625                $this->assertArrayHasKey( 2, $option_value );
    626626                $instance = $option_value[2];
    627                 $this->assertInternalType( 'array', $instance );
     627                $this->assertIsArray( $instance );
    628628                $this->assertArrayHasKey( 'content', $instance );
    629629                unset( $option_value['_multiwidget'] );
    630630
     
    875875
    876876                $result = retrieve_widgets( true );
    877877
    878                 $this->assertInternalType( 'array', $result );
     878                $this->assertIsArray( $result );
    879879                $this->assertSame( $result, $sidebars_widgets );
    880880
    881881                foreach ( $sidebars_widgets as $widgets ) {
    882                         $this->assertInternalType( 'array', $widgets );
     882                        $this->assertIsArray( $widgets );
    883883                }
    884884
    885885                $this->assertContains( 'tag_cloud-1', $sidebars_widgets['sidebar-1'] );
     
    924924                $result = retrieve_widgets( true );
    925925
    926926                // $sidebars_widgets matches registered sidebars.
    927                 $this->assertInternalType( 'array', $result );
     927                $this->assertIsArray( $result );
    928928                $this->assertSame( $result, $sidebars_widgets );
    929929
    930930                foreach ( $sidebars_widgets as $widgets ) {
    931                         $this->assertInternalType( 'array', $widgets );
     931                        $this->assertIsArray( $widgets );
    932932                }
    933933
    934934                $this->assertContains( 'tag_cloud-1', $sidebars_widgets['sidebar-1'] );
     
    963963                $result = retrieve_widgets( true );
    964964
    965965                $_wp_sidebars_widgets = array();
    966                 $this->assertInternalType( 'array', $result );
     966                $this->assertIsArray( $result );
    967967                $this->assertSame( $result, $sidebars_widgets );
    968968
    969969                foreach ( $sidebars_widgets as $widgets ) {
    970                         $this->assertInternalType( 'array', $widgets );
     970                        $this->assertIsArray( $widgets );
    971971                }
    972972
    973973                // Current theme doesn't have a fantasy-sidebar.
     
    10051005                $result = retrieve_widgets();
    10061006
    10071007                $_wp_sidebars_widgets = array();
    1008                 $this->assertInternalType( 'array', $result );
     1008                $this->assertIsArray( $result );
    10091009                $this->assertSame( $result, $sidebars_widgets );
    10101010
    10111011                foreach ( $sidebars_widgets as $widgets ) {
    1012                         $this->assertInternalType( 'array', $widgets );
     1012                        $this->assertIsArray( $widgets );
    10131013                }
    10141014
    10151015                // This sidebar is not registered anymore.
     
    10561056                $result = retrieve_widgets( 'customize' );
    10571057
    10581058                $_wp_sidebars_widgets = array();
    1059                 $this->assertInternalType( 'array', $result );
     1059                $this->assertIsArray( $result );
    10601060                $this->assertSame( $result, $sidebars_widgets );
    10611061
    10621062                foreach ( $sidebars_widgets as $widgets ) {
    1063                         $this->assertInternalType( 'array', $widgets );
     1063                        $this->assertIsArray( $widgets );
    10641064                }
    10651065
    10661066                $this->assertContains( 'tag_cloud-1', $sidebars_widgets['sidebar-1'] );
     
    11241124
    11251125                retrieve_widgets();
    11261126
    1127                 $this->assertInternalType( 'array', $sidebars_widgets );
     1127                $this->assertIsArray( $sidebars_widgets );
    11281128
    11291129                foreach ( $sidebars_widgets as $widgets ) {
    1130                         $this->assertInternalType( 'array', $widgets );
     1130                        $this->assertIsArray( $widgets );
    11311131                }
    11321132
    11331133                // 5 default widgets + 1 orphaned calendar widget = 6.
     
    11571157
    11581158                $filtered_widgets = _wp_remove_unregistered_widgets( $widgets, $allowed_widgets );
    11591159
    1160                 $this->assertInternalType( 'array', $filtered_widgets );
     1160                $this->assertIsArray( $filtered_widgets );
    11611161                $this->assertArrayHasKey( 'fantasy', $filtered_widgets );
    11621162                $this->assertEmpty( $filtered_widgets['fantasy'] );
    11631163                $this->assertArrayHasKey( 'array_version', $filtered_widgets );
    11641164                $this->assertSame( 3, $filtered_widgets['array_version'] );
    1165                 $this->assertInternalType( 'integer', $filtered_widgets['array_version'] );
     1165                $this->assertIsInt( $filtered_widgets['array_version'] );
    11661166        }
    11671167
    11681168        /**
  • tests/phpunit/tests/widgets/media-widget.php

     
    219219                $this->filter_instance_schema_args = null;
    220220                add_filter( 'widget_mocked_instance_schema', array( $this, 'filter_instance_schema' ), 10, 2 );
    221221                $schema = $widget->get_instance_schema();
    222                 $this->assertInternalType( 'array', $this->filter_instance_schema_args );
     222                $this->assertIsArray( $this->filter_instance_schema_args );
    223223                $this->assertSame( $widget, $this->filter_instance_schema_args['widget'] );
    224224                $this->assertSameSets( array( 'attachment_id', 'title', 'url' ), array_keys( $this->filter_instance_schema_args['schema'] ) );
    225225                $this->assertArrayHasKey( 'injected', $schema );
  • tests/phpunit/tests/xmlrpc/mw/getPost.php

     
    5252                $this->assertNotIXRError( $result );
    5353
    5454                // Check data types.
    55                 $this->assertInternalType( 'string', $result['userid'] );
    56                 $this->assertInternalType( 'int', $result['postid'] );
    57                 $this->assertInternalType( 'string', $result['description'] );
    58                 $this->assertInternalType( 'string', $result['title'] );
    59                 $this->assertInternalType( 'string', $result['link'] );
    60                 $this->assertInternalType( 'string', $result['permaLink'] );
    61                 $this->assertInternalType( 'array', $result['categories'] );
    62                 $this->assertInternalType( 'string', $result['mt_excerpt'] );
    63                 $this->assertInternalType( 'string', $result['mt_text_more'] );
    64                 $this->assertInternalType( 'string', $result['wp_more_text'] );
    65                 $this->assertInternalType( 'int', $result['mt_allow_comments'] );
    66                 $this->assertInternalType( 'int', $result['mt_allow_pings'] );
    67                 $this->assertInternalType( 'string', $result['mt_keywords'] );
    68                 $this->assertInternalType( 'string', $result['wp_slug'] );
    69                 $this->assertInternalType( 'string', $result['wp_password'] );
    70                 $this->assertInternalType( 'string', $result['wp_author_id'] );
    71                 $this->assertInternalType( 'string', $result['wp_author_display_name'] );
    72                 $this->assertInternalType( 'string', $result['post_status'] );
    73                 $this->assertInternalType( 'array', $result['custom_fields'] );
    74                 $this->assertInternalType( 'string', $result['wp_post_format'] );
    75                 $this->assertInternalType( 'bool', $result['sticky'] );
     55                $this->assertIsString( $result['userid'] );
     56                $this->assertIsInt( $result['postid'] );
     57                $this->assertIsString( $result['description'] );
     58                $this->assertIsString( $result['title'] );
     59                $this->assertIsString( $result['link'] );
     60                $this->assertIsString( $result['permaLink'] );
     61                $this->assertIsArray( $result['categories'] );
     62                $this->assertIsString( $result['mt_excerpt'] );
     63                $this->assertIsString( $result['mt_text_more'] );
     64                $this->assertIsString( $result['wp_more_text'] );
     65                $this->assertIsInt( $result['mt_allow_comments'] );
     66                $this->assertIsInt( $result['mt_allow_pings'] );
     67                $this->assertIsString( $result['mt_keywords'] );
     68                $this->assertIsString( $result['wp_slug'] );
     69                $this->assertIsString( $result['wp_password'] );
     70                $this->assertIsString( $result['wp_author_id'] );
     71                $this->assertIsString( $result['wp_author_display_name'] );
     72                $this->assertIsString( $result['post_status'] );
     73                $this->assertIsArray( $result['custom_fields'] );
     74                $this->assertIsString( $result['wp_post_format'] );
     75                $this->assertIsBool( $result['sticky'] );
    7676
    7777                $post_data = get_post( self::$post_id );
    7878
     
    102102                $result = $this->myxmlrpcserver->mw_getPost( array( self::$post_id, 'author', 'author' ) );
    103103                $this->assertNotIXRError( $result );
    104104
    105                 $this->assertInternalType( 'int', $result['wp_post_thumbnail'] );
     105                $this->assertIsInt( $result['wp_post_thumbnail'] );
    106106                $this->assertSame( $attachment_id, $result['wp_post_thumbnail'] );
    107107
    108108                remove_theme_support( 'post-thumbnails' );
  • tests/phpunit/tests/xmlrpc/mw/getRecentPosts.php

     
    5858                        $post = get_post( $result['postid'] );
    5959
    6060                        // Check data types.
    61                         $this->assertInternalType( 'string', $result['userid'] );
    62                         $this->assertInternalType( 'string', $result['postid'] );
    63                         $this->assertInternalType( 'string', $result['description'] );
    64                         $this->assertInternalType( 'string', $result['title'] );
    65                         $this->assertInternalType( 'string', $result['link'] );
    66                         $this->assertInternalType( 'string', $result['permaLink'] );
    67                         $this->assertInternalType( 'array', $result['categories'] );
    68                         $this->assertInternalType( 'string', $result['mt_excerpt'] );
    69                         $this->assertInternalType( 'string', $result['mt_text_more'] );
    70                         $this->assertInternalType( 'string', $result['wp_more_text'] );
    71                         $this->assertInternalType( 'int', $result['mt_allow_comments'] );
    72                         $this->assertInternalType( 'int', $result['mt_allow_pings'] );
    73                         $this->assertInternalType( 'string', $result['mt_keywords'] );
    74                         $this->assertInternalType( 'string', $result['wp_slug'] );
    75                         $this->assertInternalType( 'string', $result['wp_password'] );
    76                         $this->assertInternalType( 'string', $result['wp_author_id'] );
    77                         $this->assertInternalType( 'string', $result['wp_author_display_name'] );
    78                         $this->assertInternalType( 'string', $result['post_status'] );
    79                         $this->assertInternalType( 'array', $result['custom_fields'] );
    80                         $this->assertInternalType( 'string', $result['wp_post_format'] );
     61                        $this->assertIsString( $result['userid'] );
     62                        $this->assertIsString( $result['postid'] );
     63                        $this->assertIsString( $result['description'] );
     64                        $this->assertIsString( $result['title'] );
     65                        $this->assertIsString( $result['link'] );
     66                        $this->assertIsString( $result['permaLink'] );
     67                        $this->assertIsArray( $result['categories'] );
     68                        $this->assertIsString( $result['mt_excerpt'] );
     69                        $this->assertIsString( $result['mt_text_more'] );
     70                        $this->assertIsString( $result['wp_more_text'] );
     71                        $this->assertIsInt( $result['mt_allow_comments'] );
     72                        $this->assertIsInt( $result['mt_allow_pings'] );
     73                        $this->assertIsString( $result['mt_keywords'] );
     74                        $this->assertIsString( $result['wp_slug'] );
     75                        $this->assertIsString( $result['wp_password'] );
     76                        $this->assertIsString( $result['wp_author_id'] );
     77                        $this->assertIsString( $result['wp_author_display_name'] );
     78                        $this->assertIsString( $result['post_status'] );
     79                        $this->assertIsArray( $result['custom_fields'] );
     80                        $this->assertIsString( $result['wp_post_format'] );
    8181
    8282                        // Check expected values.
    8383                        $this->assertStringMatchesFormat( '%d', $result['userid'] );
     
    106106                $this->assertNotIXRError( $results );
    107107
    108108                foreach ( $results as $result ) {
    109                         $this->assertInternalType( 'string', $result['wp_post_thumbnail'] );
     109                        $this->assertIsString( $result['wp_post_thumbnail'] );
    110110                        $this->assertStringMatchesFormat( '%d', $result['wp_post_thumbnail'] );
    111111
    112112                        if ( ! empty( $result['wp_post_thumbnail'] ) || $result['postid'] === self::$post_id ) {
  • tests/phpunit/tests/xmlrpc/wp/deleteTerm.php

     
    7070
    7171                $result = $this->myxmlrpcserver->wp_deleteTerm( array( 1, 'editor', 'editor', 'category', self::$term_id ) );
    7272                $this->assertNotIXRError( $result );
    73                 $this->assertInternalType( 'boolean', $result );
     73                $this->assertIsBool( $result );
    7474        }
    7575}
  • tests/phpunit/tests/xmlrpc/wp/editPost.php

     
    159159                $result = $this->myxmlrpcserver->wp_getPost( array( 1, 'author', 'author', $post_id ) );
    160160                $this->assertNotIXRError( $result );
    161161                $this->assertArrayHasKey( 'post_thumbnail', $result );
    162                 $this->assertInternalType( 'array', $result['post_thumbnail'] );
     162                $this->assertIsArray( $result['post_thumbnail'] );
    163163                $this->assertEquals( $attachment_id, $result['post_thumbnail']['attachment_id'] );
    164164
    165165                // Edit the post without supplying a post_thumbnail and check that it didn't change.
  • tests/phpunit/tests/xmlrpc/wp/editTerm.php

     
    155155                );
    156156
    157157                $this->assertNotIXRError( $result );
    158                 $this->assertInternalType( 'boolean', $result );
     158                $this->assertIsBool( $result );
    159159
    160160                $term = get_term( self::$child_term, 'category' );
    161161                $this->assertEquals( '0', $term->parent );
     
    236236                $result = $this->myxmlrpcserver->wp_editTerm( array( 1, 'editor', 'editor', self::$child_term, $fields ) );
    237237
    238238                $this->assertNotIXRError( $result );
    239                 $this->assertInternalType( 'boolean', $result );
     239                $this->assertIsBool( $result );
    240240        }
    241241
    242242        /**
  • tests/phpunit/tests/xmlrpc/wp/getComment.php

     
    5454                $this->assertNotIXRError( $result );
    5555
    5656                // Check data types.
    57                 $this->assertInternalType( 'string', $result['user_id'] );
    58                 $this->assertInternalType( 'string', $result['comment_id'] );
     57                $this->assertIsString( $result['user_id'] );
     58                $this->assertIsString( $result['comment_id'] );
    5959                $this->assertInstanceOf( 'IXR_Date', $result['date_created_gmt'] );
    60                 $this->assertInternalType( 'string', $result['parent'] );
    61                 $this->assertInternalType( 'string', $result['status'] );
    62                 $this->assertInternalType( 'string', $result['content'] );
    63                 $this->assertInternalType( 'string', $result['link'] );
    64                 $this->assertInternalType( 'string', $result['post_id'] );
    65                 $this->assertInternalType( 'string', $result['post_title'] );
    66                 $this->assertInternalType( 'string', $result['author'] );
    67                 $this->assertInternalType( 'string', $result['author_url'] );
    68                 $this->assertInternalType( 'string', $result['author_email'] );
    69                 $this->assertInternalType( 'string', $result['author_ip'] );
    70                 $this->assertInternalType( 'string', $result['type'] );
     60                $this->assertIsString( $result['parent'] );
     61                $this->assertIsString( $result['status'] );
     62                $this->assertIsString( $result['content'] );
     63                $this->assertIsString( $result['link'] );
     64                $this->assertIsString( $result['post_id'] );
     65                $this->assertIsString( $result['post_title'] );
     66                $this->assertIsString( $result['author'] );
     67                $this->assertIsString( $result['author_url'] );
     68                $this->assertIsString( $result['author_email'] );
     69                $this->assertIsString( $result['author_ip'] );
     70                $this->assertIsString( $result['type'] );
    7171
    7272                // Check expected values.
    7373                $this->assertStringMatchesFormat( '%d', $result['user_id'] );
  • tests/phpunit/tests/xmlrpc/wp/getComments.php

     
    198198                        )
    199199                );
    200200
    201                 $this->assertInternalType( 'array', $result2 );
     201                $this->assertIsArray( $result2 );
    202202                $this->assertCount( 1, $result2 );
    203203
    204204                $result3 = $this->myxmlrpcserver->wp_getComments(
     
    225225                        )
    226226                );
    227227
    228                 $this->assertInternalType( 'array', $result4 );
     228                $this->assertIsArray( $result4 );
    229229                $this->assertCount( 1, $result4 );
    230230        }
    231231
     
    276276                                ),
    277277                        )
    278278                );
    279                 $this->assertInternalType( 'array', $result );
     279                $this->assertIsArray( $result );
    280280                $this->assertCount( 1, $result );
    281281
    282282                $result2 = $this->myxmlrpcserver->wp_getComments(
     
    291291                        )
    292292                );
    293293
    294                 $this->assertInternalType( 'array', $result2 );
     294                $this->assertIsArray( $result2 );
    295295                $this->assertCount( 1, $result2 );
    296296        }
    297297}
  • tests/phpunit/tests/xmlrpc/wp/getMediaItem.php

     
    5050                $this->assertNotIXRError( $result );
    5151
    5252                // Check data types.
    53                 $this->assertInternalType( 'string', $result['attachment_id'] );
    54                 $this->assertInternalType( 'int', $result['parent'] );
    55                 $this->assertInternalType( 'string', $result['title'] );
     53                $this->assertIsString( $result['attachment_id'] );
     54                $this->assertIsInt( $result['parent'] );
     55                $this->assertIsString( $result['title'] );
    5656                $this->assertInstanceOf( 'IXR_Date', $result['date_created_gmt'] );
    57                 $this->assertInternalType( 'string', $result['caption'] );
    58                 $this->assertInternalType( 'string', $result['description'] );
    59                 $this->assertInternalType( 'string', $result['link'] );
    60                 $this->assertInternalType( 'string', $result['thumbnail'] );
    61                 $this->assertInternalType( 'array', $result['metadata'] );
     57                $this->assertIsString( $result['caption'] );
     58                $this->assertIsString( $result['description'] );
     59                $this->assertIsString( $result['link'] );
     60                $this->assertIsString( $result['thumbnail'] );
     61                $this->assertIsArray( $result['metadata'] );
    6262
    6363                // Check expected values.
    6464                $this->assertStringMatchesFormat( '%d', $result['attachment_id'] );
  • tests/phpunit/tests/xmlrpc/wp/getOptions.php

     
    1515                $this->make_user_by_role( 'subscriber' );
    1616
    1717                $result = $this->myxmlrpcserver->wp_getOptions( array( 1, 'subscriber', 'subscriber' ) );
    18                 $this->assertInternalType( 'array', $result );
     18                $this->assertIsArray( $result );
    1919                $this->assertSame( 'WordPress', $result['software_name']['value'] );
    2020        }
    2121
     
    2323                $this->make_user_by_role( 'administrator' );
    2424
    2525                $result = $this->myxmlrpcserver->wp_getOptions( array( 1, 'administrator', 'administrator', 'default_comment_status' ) );
    26                 $this->assertInternalType( 'array', $result );
     26                $this->assertIsArray( $result );
    2727
    2828                $this->assertSame( get_option( 'default_comment_status' ), $result['default_comment_status']['value'] );
    2929                $this->assertFalse( $result['default_comment_status']['readonly'] );
     
    3737                $this->make_user_by_role( 'subscriber' );
    3838
    3939                $result = $this->myxmlrpcserver->wp_getOptions( array( 1, 'subscriber', 'subscriber' ) );
    40                 $this->assertInternalType( 'array', $result );
     40                $this->assertIsArray( $result );
    4141
    4242                // Read-only options.
    4343                $this->assertSame( 'WordPress', $result['software_name']['value'] );
     
    126126                $this->make_user_by_role( 'administrator' );
    127127
    128128                $result = $this->myxmlrpcserver->wp_getOptions( array( 1, 'administrator', 'administrator' ) );
    129                 $this->assertInternalType( 'array', $result );
     129                $this->assertIsArray( $result );
    130130
    131131                // Read-only options.
    132132                $this->assertSame( 'WordPress', $result['software_name']['value'] );
  • tests/phpunit/tests/xmlrpc/wp/getPage.php

     
    4646                $this->assertNotIXRError( $result );
    4747
    4848                // Check data types.
    49                 $this->assertInternalType( 'string', $result['userid'] );
    50                 $this->assertInternalType( 'int', $result['page_id'] );
    51                 $this->assertInternalType( 'string', $result['page_status'] );
    52                 $this->assertInternalType( 'string', $result['description'] );
    53                 $this->assertInternalType( 'string', $result['title'] );
    54                 $this->assertInternalType( 'string', $result['link'] );
    55                 $this->assertInternalType( 'string', $result['permaLink'] );
    56                 $this->assertInternalType( 'array', $result['categories'] );
    57                 $this->assertInternalType( 'string', $result['excerpt'] );
    58                 $this->assertInternalType( 'string', $result['text_more'] );
    59                 $this->assertInternalType( 'int', $result['mt_allow_comments'] );
    60                 $this->assertInternalType( 'int', $result['mt_allow_pings'] );
    61                 $this->assertInternalType( 'string', $result['wp_slug'] );
    62                 $this->assertInternalType( 'string', $result['wp_password'] );
    63                 $this->assertInternalType( 'string', $result['wp_author'] );
    64                 $this->assertInternalType( 'int', $result['wp_page_parent_id'] );
    65                 $this->assertInternalType( 'string', $result['wp_page_parent_title'] );
    66                 $this->assertInternalType( 'int', $result['wp_page_order'] );
    67                 $this->assertInternalType( 'string', $result['wp_author_id'] );
    68                 $this->assertInternalType( 'string', $result['wp_author_display_name'] );
    69                 $this->assertInternalType( 'array', $result['custom_fields'] );
    70                 $this->assertInternalType( 'string', $result['wp_page_template'] );
     49                $this->assertIsString( $result['userid'] );
     50                $this->assertIsInt( $result['page_id'] );
     51                $this->assertIsString( $result['page_status'] );
     52                $this->assertIsString( $result['description'] );
     53                $this->assertIsString( $result['title'] );
     54                $this->assertIsString( $result['link'] );
     55                $this->assertIsString( $result['permaLink'] );
     56                $this->assertIsArray( $result['categories'] );
     57                $this->assertIsString( $result['excerpt'] );
     58                $this->assertIsString( $result['text_more'] );
     59                $this->assertIsInt( $result['mt_allow_comments'] );
     60                $this->assertIsInt( $result['mt_allow_pings'] );
     61                $this->assertIsString( $result['wp_slug'] );
     62                $this->assertIsString( $result['wp_password'] );
     63                $this->assertIsString( $result['wp_author'] );
     64                $this->assertIsInt( $result['wp_page_parent_id'] );
     65                $this->assertIsString( $result['wp_page_parent_title'] );
     66                $this->assertIsInt( $result['wp_page_order'] );
     67                $this->assertIsString( $result['wp_author_id'] );
     68                $this->assertIsString( $result['wp_author_display_name'] );
     69                $this->assertIsArray( $result['custom_fields'] );
     70                $this->assertIsString( $result['wp_page_template'] );
    7171
    7272                $post_data = get_post( self::$post_id );
    7373
  • tests/phpunit/tests/xmlrpc/wp/getPost.php

     
    4242                $this->assertNotIXRError( $result );
    4343
    4444                // Check data types.
    45                 $this->assertInternalType( 'string', $result['post_id'] );
    46                 $this->assertInternalType( 'string', $result['post_title'] );
     45                $this->assertIsString( $result['post_id'] );
     46                $this->assertIsString( $result['post_title'] );
    4747                $this->assertInstanceOf( 'IXR_Date', $result['post_date'] );
    4848                $this->assertInstanceOf( 'IXR_Date', $result['post_date_gmt'] );
    4949                $this->assertInstanceOf( 'IXR_Date', $result['post_modified'] );
    5050                $this->assertInstanceOf( 'IXR_Date', $result['post_modified_gmt'] );
    51                 $this->assertInternalType( 'string', $result['post_status'] );
    52                 $this->assertInternalType( 'string', $result['post_type'] );
    53                 $this->assertInternalType( 'string', $result['post_name'] );
    54                 $this->assertInternalType( 'string', $result['post_author'] );
    55                 $this->assertInternalType( 'string', $result['post_password'] );
    56                 $this->assertInternalType( 'string', $result['post_excerpt'] );
    57                 $this->assertInternalType( 'string', $result['post_content'] );
    58                 $this->assertInternalType( 'string', $result['link'] );
    59                 $this->assertInternalType( 'string', $result['comment_status'] );
    60                 $this->assertInternalType( 'string', $result['ping_status'] );
    61                 $this->assertInternalType( 'bool', $result['sticky'] );
    62                 $this->assertInternalType( 'string', $result['post_format'] );
    63                 $this->assertInternalType( 'array', $result['post_thumbnail'] );
    64                 $this->assertInternalType( 'array', $result['custom_fields'] );
     51                $this->assertIsString( $result['post_status'] );
     52                $this->assertIsString( $result['post_type'] );
     53                $this->assertIsString( $result['post_name'] );
     54                $this->assertIsString( $result['post_author'] );
     55                $this->assertIsString( $result['post_password'] );
     56                $this->assertIsString( $result['post_excerpt'] );
     57                $this->assertIsString( $result['post_content'] );
     58                $this->assertIsString( $result['link'] );
     59                $this->assertIsString( $result['comment_status'] );
     60                $this->assertIsString( $result['ping_status'] );
     61                $this->assertIsBool( $result['sticky'] );
     62                $this->assertIsString( $result['post_format'] );
     63                $this->assertIsArray( $result['post_thumbnail'] );
     64                $this->assertIsArray( $result['custom_fields'] );
    6565
    6666                // Check expected values.
    6767                $this->assertStringMatchesFormat( '%d', $result['post_id'] );
     
    137137                $result = $this->myxmlrpcserver->wp_getPost( array( 1, 'editor', 'editor', $child_page_id ) );
    138138                $this->assertNotIXRError( $result );
    139139
    140                 $this->assertInternalType( 'string', $result['post_id'] );
    141                 $this->assertInternalType( 'string', $result['post_parent'] );
    142                 $this->assertInternalType( 'int', $result['menu_order'] );
    143                 $this->assertInternalType( 'string', $result['guid'] );
    144                 $this->assertInternalType( 'string', $result['post_mime_type'] );
     140                $this->assertIsString( $result['post_id'] );
     141                $this->assertIsString( $result['post_parent'] );
     142                $this->assertIsInt( $result['menu_order'] );
     143                $this->assertIsString( $result['guid'] );
     144                $this->assertIsString( $result['post_mime_type'] );
    145145
    146146                $this->assertSame( 'page', $result['post_type'] );
    147147                $this->assertEquals( $parent_page_id, $result['post_parent'] );
  • tests/phpunit/tests/xmlrpc/wp/getPostType.php

     
    5959                $this->assertNotIXRError( $result );
    6060
    6161                // Check data types.
    62                 $this->assertInternalType( 'string', $result['name'] );
    63                 $this->assertInternalType( 'string', $result['label'] );
    64                 $this->assertInternalType( 'bool', $result['hierarchical'] );
    65                 $this->assertInternalType( 'bool', $result['public'] );
    66                 $this->assertInternalType( 'bool', $result['_builtin'] );
    67                 $this->assertInternalType( 'bool', $result['map_meta_cap'] );
    68                 $this->assertInternalType( 'bool', $result['has_archive'] );
    69                 $this->assertInternalType( 'bool', $result['show_ui'] );
    70                 $this->assertInternalType( 'int', $result['menu_position'] );
    71                 $this->assertInternalType( 'string', $result['menu_icon'] );
    72                 $this->assertInternalType( 'array', $result['labels'] );
    73                 $this->assertInternalType( 'array', $result['cap'] );
    74                 $this->assertInternalType( 'array', $result['taxonomies'] );
    75                 $this->assertInternalType( 'array', $result['supports'] );
     62                $this->assertIsString( $result['name'] );
     63                $this->assertIsString( $result['label'] );
     64                $this->assertIsBool( $result['hierarchical'] );
     65                $this->assertIsBool( $result['public'] );
     66                $this->assertIsBool( $result['_builtin'] );
     67                $this->assertIsBool( $result['map_meta_cap'] );
     68                $this->assertIsBool( $result['has_archive'] );
     69                $this->assertIsBool( $result['show_ui'] );
     70                $this->assertIsInt( $result['menu_position'] );
     71                $this->assertIsString( $result['menu_icon'] );
     72                $this->assertIsArray( $result['labels'] );
     73                $this->assertIsArray( $result['cap'] );
     74                $this->assertIsArray( $result['taxonomies'] );
     75                $this->assertIsArray( $result['supports'] );
    7676
    7777                // Check label data types.
    78                 $this->assertInternalType( 'string', $result['labels']['name'] );
    79                 $this->assertInternalType( 'string', $result['labels']['singular_name'] );
    80                 $this->assertInternalType( 'string', $result['labels']['add_new'] );
    81                 $this->assertInternalType( 'string', $result['labels']['add_new_item'] );
    82                 $this->assertInternalType( 'string', $result['labels']['edit_item'] );
    83                 $this->assertInternalType( 'string', $result['labels']['new_item'] );
    84                 $this->assertInternalType( 'string', $result['labels']['view_item'] );
    85                 $this->assertInternalType( 'string', $result['labels']['search_items'] );
    86                 $this->assertInternalType( 'string', $result['labels']['not_found'] );
    87                 $this->assertInternalType( 'string', $result['labels']['not_found_in_trash'] );
    88                 $this->assertInternalType( 'string', $result['labels']['parent_item_colon'] );
    89                 $this->assertInternalType( 'string', $result['labels']['all_items'] );
    90                 $this->assertInternalType( 'string', $result['labels']['menu_name'] );
    91                 $this->assertInternalType( 'string', $result['labels']['name_admin_bar'] );
     78                $this->assertIsString( $result['labels']['name'] );
     79                $this->assertIsString( $result['labels']['singular_name'] );
     80                $this->assertIsString( $result['labels']['add_new'] );
     81                $this->assertIsString( $result['labels']['add_new_item'] );
     82                $this->assertIsString( $result['labels']['edit_item'] );
     83                $this->assertIsString( $result['labels']['new_item'] );
     84                $this->assertIsString( $result['labels']['view_item'] );
     85                $this->assertIsString( $result['labels']['search_items'] );
     86                $this->assertIsString( $result['labels']['not_found'] );
     87                $this->assertIsString( $result['labels']['not_found_in_trash'] );
     88                $this->assertIsString( $result['labels']['parent_item_colon'] );
     89                $this->assertIsString( $result['labels']['all_items'] );
     90                $this->assertIsString( $result['labels']['menu_name'] );
     91                $this->assertIsString( $result['labels']['name_admin_bar'] );
    9292
    9393                // Check cap data types.
    94                 $this->assertInternalType( 'string', $result['cap']['edit_post'] );
    95                 $this->assertInternalType( 'string', $result['cap']['read_post'] );
    96                 $this->assertInternalType( 'string', $result['cap']['delete_post'] );
    97                 $this->assertInternalType( 'string', $result['cap']['edit_posts'] );
    98                 $this->assertInternalType( 'string', $result['cap']['edit_others_posts'] );
    99                 $this->assertInternalType( 'string', $result['cap']['publish_posts'] );
    100                 $this->assertInternalType( 'string', $result['cap']['read_private_posts'] );
    101                 $this->assertInternalType( 'string', $result['cap']['read'] );
    102                 $this->assertInternalType( 'string', $result['cap']['delete_posts'] );
    103                 $this->assertInternalType( 'string', $result['cap']['delete_private_posts'] );
    104                 $this->assertInternalType( 'string', $result['cap']['delete_published_posts'] );
    105                 $this->assertInternalType( 'string', $result['cap']['delete_others_posts'] );
    106                 $this->assertInternalType( 'string', $result['cap']['edit_private_posts'] );
    107                 $this->assertInternalType( 'string', $result['cap']['edit_published_posts'] );
     94                $this->assertIsString( $result['cap']['edit_post'] );
     95                $this->assertIsString( $result['cap']['read_post'] );
     96                $this->assertIsString( $result['cap']['delete_post'] );
     97                $this->assertIsString( $result['cap']['edit_posts'] );
     98                $this->assertIsString( $result['cap']['edit_others_posts'] );
     99                $this->assertIsString( $result['cap']['publish_posts'] );
     100                $this->assertIsString( $result['cap']['read_private_posts'] );
     101                $this->assertIsString( $result['cap']['read'] );
     102                $this->assertIsString( $result['cap']['delete_posts'] );
     103                $this->assertIsString( $result['cap']['delete_private_posts'] );
     104                $this->assertIsString( $result['cap']['delete_published_posts'] );
     105                $this->assertIsString( $result['cap']['delete_others_posts'] );
     106                $this->assertIsString( $result['cap']['edit_private_posts'] );
     107                $this->assertIsString( $result['cap']['edit_published_posts'] );
    108108
    109109                // Check taxonomy data types.
    110110                foreach ( $result['taxonomies'] as $taxonomy ) {
    111                         $this->assertInternalType( 'string', $taxonomy );
     111                        $this->assertIsString( $taxonomy );
    112112                }
    113113
    114114                // Check support data types.
    115115                foreach ( $result['supports'] as $key => $value ) {
    116                         $this->assertInternalType( 'string', $key );
    117                         $this->assertInternalType( 'bool', $value );
     116                        $this->assertIsString( $key );
     117                        $this->assertIsBool( $value );
    118118                }
    119119
    120120                // Check expected values.
  • tests/phpunit/tests/xmlrpc/wp/getPostTypes.php

     
    1515
    1616                $result = $this->myxmlrpcserver->wp_getPostTypes( array( 1, 'subscriber', 'subscriber' ) );
    1717                $this->assertNotIXRError( $result );
    18                 $this->assertInternalType( 'array', $result );
     18                $this->assertIsArray( $result );
    1919                $this->assertSame( 0, count( $result ) );
    2020        }
    2121
     
    2424
    2525                $result = $this->myxmlrpcserver->wp_getPostTypes( array( 1, 'editor', 'editor' ) );
    2626                $this->assertNotIXRError( $result );
    27                 $this->assertInternalType( 'array', $result );
     27                $this->assertIsArray( $result );
    2828                $this->assertGreaterThan( 0, count( $result ) );
    2929        }
    3030
     
    3333
    3434                $result = $this->myxmlrpcserver->wp_getPostTypes( array( 1, 'editor', 'editor', array( 'hierarchical' => true ) ) );
    3535                $this->assertNotIXRError( $result );
    36                 $this->assertInternalType( 'array', $result );
     36                $this->assertIsArray( $result );
    3737
    3838                // Verify that page is in the result, and post is not.
    3939                $result_names = wp_list_pluck( $result, 'name' );
  • tests/phpunit/tests/xmlrpc/wp/getRevisions.php

     
    4141                ); // Create the initial revision.
    4242
    4343                $result = $this->myxmlrpcserver->wp_getRevisions( array( 1, 'editor', 'editor', $post_id ) );
    44                 $this->assertInternalType( 'array', $result );
     44                $this->assertIsArray( $result );
    4545                $this->assertCount( 1, $result );
    4646
    4747                wp_insert_post(
     
    5252                );
    5353
    5454                $result = $this->myxmlrpcserver->wp_getRevisions( array( 1, 'editor', 'editor', $post_id ) );
    55                 $this->assertInternalType( 'array', $result );
     55                $this->assertIsArray( $result );
    5656                $this->assertCount( 2, $result );
    5757        }
    5858
  • tests/phpunit/tests/xmlrpc/wp/getTerm.php

     
    7979                $this->assertEquals( $result, $term );
    8080
    8181                // Check data types.
    82                 $this->assertInternalType( 'string', $result['name'] );
    83                 $this->assertInternalType( 'string', $result['slug'] );
    84                 $this->assertInternalType( 'string', $result['taxonomy'] );
    85                 $this->assertInternalType( 'string', $result['description'] );
    86                 $this->assertInternalType( 'int', $result['count'] );
     82                $this->assertIsString( $result['name'] );
     83                $this->assertIsString( $result['slug'] );
     84                $this->assertIsString( $result['taxonomy'] );
     85                $this->assertIsString( $result['description'] );
     86                $this->assertIsInt( $result['count'] );
    8787
    8888                // We expect all ID's to be strings not integers so we don't return something larger than an XMLRPC integer can describe.
    8989                $this->assertStringMatchesFormat( '%d', $result['term_id'] );
     
    121121                );
    122122                $this->assertNotIXRError( $result );
    123123
    124                 $this->assertInternalType( 'array', $result['custom_fields'] );
     124                $this->assertIsArray( $result['custom_fields'] );
    125125                $term_meta = get_term_meta( self::$term_id, '', true );
    126126                $this->assertSame( $term_meta['foo'][0], $result['custom_fields'][0]['value'] );
    127127        }
  • tests/phpunit/tests/xmlrpc/wp/getTerms.php

     
    4848                $this->assertNotIXRError( $results );
    4949
    5050                foreach ( $results as $term ) {
    51                         $this->assertInternalType( 'int', $term['count'] );
     51                        $this->assertIsInt( $term['count'] );
    5252
    5353                        // Check custom term meta.
    54                         $this->assertInternalType( 'array', $term['custom_fields'] );
     54                        $this->assertIsArray( $term['custom_fields'] );
    5555
    5656                        // We expect all other IDs to be strings, not integers,
    5757                        // so we don't return something larger than an XMLRPC integer can describe.
  • tests/phpunit/tests/xmlrpc/wp/getUser.php

     
    6969                $this->assertNotIXRError( $result );
    7070
    7171                // Check data types.
    72                 $this->assertInternalType( 'string', $result['user_id'] );
     72                $this->assertIsString( $result['user_id'] );
    7373                $this->assertStringMatchesFormat( '%d', $result['user_id'] );
    74                 $this->assertInternalType( 'string', $result['username'] );
    75                 $this->assertInternalType( 'string', $result['first_name'] );
    76                 $this->assertInternalType( 'string', $result['last_name'] );
     74                $this->assertIsString( $result['username'] );
     75                $this->assertIsString( $result['first_name'] );
     76                $this->assertIsString( $result['last_name'] );
    7777                $this->assertInstanceOf( 'IXR_Date', $result['registered'] );
    78                 $this->assertInternalType( 'string', $result['bio'] );
    79                 $this->assertInternalType( 'string', $result['email'] );
    80                 $this->assertInternalType( 'string', $result['nickname'] );
    81                 $this->assertInternalType( 'string', $result['nicename'] );
    82                 $this->assertInternalType( 'string', $result['url'] );
    83                 $this->assertInternalType( 'string', $result['display_name'] );
    84                 $this->assertInternalType( 'array', $result['roles'] );
     78                $this->assertIsString( $result['bio'] );
     79                $this->assertIsString( $result['email'] );
     80                $this->assertIsString( $result['nickname'] );
     81                $this->assertIsString( $result['nicename'] );
     82                $this->assertIsString( $result['url'] );
     83                $this->assertIsString( $result['display_name'] );
     84                $this->assertIsArray( $result['roles'] );
    8585
    8686                // Check expected values.
    8787                $this->assertEquals( $user_id, $result['user_id'] );
  • tests/phpunit/tests/xmlrpc/wp/getUsers.php

     
    2727                $this->assertNotIXRError( $result );
    2828
    2929                // Check data types.
    30                 $this->assertInternalType( 'string', $result[0]['user_id'] );
     30                $this->assertIsString( $result[0]['user_id'] );
    3131                $this->assertStringMatchesFormat( '%d', $result[0]['user_id'] );
    32                 $this->assertInternalType( 'string', $result[0]['username'] );
    33                 $this->assertInternalType( 'string', $result[0]['first_name'] );
    34                 $this->assertInternalType( 'string', $result[0]['last_name'] );
     32                $this->assertIsString( $result[0]['username'] );
     33                $this->assertIsString( $result[0]['first_name'] );
     34                $this->assertIsString( $result[0]['last_name'] );
    3535                $this->assertInstanceOf( 'IXR_Date', $result[0]['registered'] );
    36                 $this->assertInternalType( 'string', $result[0]['bio'] );
    37                 $this->assertInternalType( 'string', $result[0]['email'] );
    38                 $this->assertInternalType( 'string', $result[0]['nickname'] );
    39                 $this->assertInternalType( 'string', $result[0]['nicename'] );
    40                 $this->assertInternalType( 'string', $result[0]['url'] );
    41                 $this->assertInternalType( 'string', $result[0]['display_name'] );
    42                 $this->assertInternalType( 'array', $result[0]['roles'] );
     36                $this->assertIsString( $result[0]['bio'] );
     37                $this->assertIsString( $result[0]['email'] );
     38                $this->assertIsString( $result[0]['nickname'] );
     39                $this->assertIsString( $result[0]['nicename'] );
     40                $this->assertIsString( $result[0]['url'] );
     41                $this->assertIsString( $result[0]['display_name'] );
     42                $this->assertIsArray( $result[0]['roles'] );
    4343        }
    4444
    4545        function test_invalid_role() {
  • tests/phpunit/tests/xmlrpc/wp/newComment.php

     
    208208
    209209                $result = $this->myxmlrpcserver->wp_newComment( $comment_args );
    210210                $this->assertNotIXRError( $result );
    211                 $this->assertInternalType( 'int', $result );
     211                $this->assertIsInt( $result );
    212212        }
    213213
    214214        /**
     
    290290
    291291                $result = $this->myxmlrpcserver->wp_newComment( $comment_args );
    292292                if ( $expected ) {
    293                         $this->assertInternalType( 'int', $result );
     293                        $this->assertIsInt( $result );
    294294                        return;
    295295                }
    296296
  • tests/phpunit/tests/xmlrpc/wp/newPost.php

     
    280280                $this->make_user_by_role( 'editor' );
    281281
    282282                $tag1 = wp_create_tag( 'tag1' );
    283                 $this->assertInternalType( 'array', $tag1 );
     283                $this->assertIsArray( $tag1 );
    284284                $tag2 = wp_create_tag( 'tag2' );
    285                 $this->assertInternalType( 'array', $tag2 );
     285                $this->assertIsArray( $tag2 );
    286286                $tag3 = wp_create_tag( 'tag3' );
    287                 $this->assertInternalType( 'array', $tag3 );
     287                $this->assertIsArray( $tag3 );
    288288
    289289                $post   = array(
    290290                        'post_title' => 'Test',
  • tests/phpunit/tests/xmlrpc/wp/setOptions.php

     
    2626                        )
    2727                );
    2828
    29                 $this->assertInternalType( 'array', $result );
     29                $this->assertIsArray( $result );
    3030                $this->assertSame( $escaped_string_with_quote, $result['blog_title']['value'] );
    3131                $this->assertSame( 'open', $result['default_comment_status']['value'] );
    3232        }
  • tests/phpunit/tests/xmlrpc/wp/uploadFile.php

     
    2727                $this->assertNotIXRError( $result );
    2828
    2929                // Check data types.
    30                 $this->assertInternalType( 'string', $result['id'] );
     30                $this->assertIsString( $result['id'] );
    3131                $this->assertStringMatchesFormat( '%d', $result['id'] );
    32                 $this->assertInternalType( 'string', $result['file'] );
    33                 $this->assertInternalType( 'string', $result['url'] );
    34                 $this->assertInternalType( 'string', $result['type'] );
     32                $this->assertIsString( $result['file'] );
     33                $this->assertIsString( $result['url'] );
     34                $this->assertIsString( $result['type'] );
    3535        }
    3636}