WordPress.org
Get WordPress

Make WordPress Core

Changeset 60729

Timestamp:
09/11/2025 02:45:56 PM (4 weeks ago)
Author:
swissspidy
Message:

Code Modernization: Address reflection no-op function deprecations in PHP 8.5.

Reflection*::setAccessible() methods are no-ops since PHP 8.1. This commit adds conditional checks to only call these functions on older PHP versions.

Reference: ​PHP RFC: Deprecations for PHP 8.5: Deprecate `Reflection*::setAccessible()`.

Props rishabhwp, swissspidy.
Fixes #63956.
See #63061.

Location:
trunk/tests/phpunit/tests
Files:
46 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/admin/plugin-dependencies/base.php

    r57658 r60729  
    8383        }
    8484
    85         self::$reflected_members[ $property ]->setAccessible( true );
     85        if ( PHP_VERSION_ID < 80100 ) {
     86            self::$reflected_members[ $property ]->setAccessible( true );
     87        }
    8688        self::$reflected_members[ $property ]->setValue( self::$instance, $value );
    87         self::$reflected_members[ $property ]->setAccessible( false );
     89        if ( PHP_VERSION_ID < 80100 ) {
     90            self::$reflected_members[ $property ]->setAccessible( false );
     91        }
    8892    }
    8993
    … …  
    99103        }
    100104
    101         self::$reflected_members[ $property ]->setAccessible( true );
     105        if ( PHP_VERSION_ID < 80100 ) {
     106            self::$reflected_members[ $property ]->setAccessible( true );
     107        }
    102108        $value = self::$reflected_members[ $property ]->getValue( self::$instance );
    103         self::$reflected_members[ $property ]->setAccessible( false );
     109        if ( PHP_VERSION_ID < 80100 ) {
     110            self::$reflected_members[ $property ]->setAccessible( false );
     111        }
    104112
    105113        return $value;
    … …  
    119127        }
    120128
    121         self::$reflected_members[ $method ]->setAccessible( true );
     129        if ( PHP_VERSION_ID < 80100 ) {
     130            self::$reflected_members[ $method ]->setAccessible( true );
     131        }
    122132        $value = self::$reflected_members[ $method ]->invokeArgs( self::$instance, $args );
    123         self::$reflected_members[ $method ]->setAccessible( false );
     133        if ( PHP_VERSION_ID < 80100 ) {
     134            self::$reflected_members[ $method ]->setAccessible( false );
     135        }
    124136
    125137        return $value;

  • trunk/tests/phpunit/tests/admin/wpAutomaticUpdater.php

    r56971 r60729  
    3131
    3232        self::$send_plugin_theme_email = new ReflectionMethod( self::$updater, 'send_plugin_theme_email' );
    33         self::$send_plugin_theme_email->setAccessible( true );
     33        if ( PHP_VERSION_ID < 80100 ) {
     34            self::$send_plugin_theme_email->setAccessible( true );
     35        }
    3436    }
    3537

  • trunk/tests/phpunit/tests/admin/wpCommunityEvents.php

    r55337 r60729  
    300300    public function test_trim_expired_events() {
    301301        $trim_events = new ReflectionMethod( $this->instance, 'trim_events' );
    302         $trim_events->setAccessible( true );
     302        if ( PHP_VERSION_ID < 80100 ) {
     303            $trim_events->setAccessible( true );
     304        }
    303305
    304306        $events = $this->get_valid_events();
    … …  
    329331    public function test_trim_events_pin_wordcamp() {
    330332        $trim_events = new ReflectionMethod( $this->instance, 'trim_events' );
    331         $trim_events->setAccessible( true );
     333        if ( PHP_VERSION_ID < 80100 ) {
     334            $trim_events->setAccessible( true );
     335        }
    332336
    333337        $actual = $trim_events->invoke( $this->instance, $this->_events_with_unpinned_wordcamp() );
    … …  
    434438    public function test_trim_events_dont_pin_multiple_wordcamps() {
    435439        $trim_events = new ReflectionMethod( $this->instance, 'trim_events' );
    436         $trim_events->setAccessible( true );
     440        if ( PHP_VERSION_ID < 80100 ) {
     441            $trim_events->setAccessible( true );
     442        }
    437443
    438444        $actual = $trim_events->invoke( $this->instance, $this->_events_with_multiple_wordcamps() );

  • trunk/tests/phpunit/tests/admin/wpListTable.php

    r58389 r60729  
    7171
    7272        $column_headers = new ReflectionProperty( $list_table, '_column_headers' );
    73         $column_headers->setAccessible( true );
     73        if ( PHP_VERSION_ID < 80100 ) {
     74            $column_headers->setAccessible( true );
     75        }
    7476        $column_headers->setValue( $list_table, $headers );
    7577
    7678        $column_info = new ReflectionMethod( $list_table, 'get_column_info' );
    77         $column_info->setAccessible( true );
     79        if ( PHP_VERSION_ID < 80100 ) {
     80            $column_info->setAccessible( true );
     81        }
    7882
    7983        $this->assertSame( $expected, $column_info->invoke( $list_table ), 'The actual columns did not match the expected columns' );
    … …  
    161165    public function test_get_views_links( $link_data, $expected ) {
    162166        $get_views_links = new ReflectionMethod( $this->list_table, 'get_views_links' );
    163         $get_views_links->setAccessible( true );
     167        if ( PHP_VERSION_ID < 80100 ) {
     168            $get_views_links->setAccessible( true );
     169        }
    164170
    165171        $actual = $get_views_links->invokeArgs( $this->list_table, array( $link_data ) );
    … …  
    276282    public function test_get_views_links_doing_it_wrong( $link_data ) {
    277283        $get_views_links = new ReflectionMethod( $this->list_table, 'get_views_links' );
    278         $get_views_links->setAccessible( true );
     284        if ( PHP_VERSION_ID < 80100 ) {
     285            $get_views_links->setAccessible( true );
     286        }
    279287        $get_views_links->invokeArgs( $this->list_table, array( $link_data ) );
    280288    }

  • trunk/tests/phpunit/tests/admin/wpMediaListTable.php

    r56141 r60729  
    7777        self::$detached   = new ReflectionProperty( self::$list_table, 'detached' );
    7878
    79         self::$is_trash->setAccessible( true );
     79        if ( PHP_VERSION_ID < 80100 ) {
     80            self::$is_trash->setAccessible( true );
     81        }
    8082        self::$is_trash_original = self::$is_trash->getValue( self::$list_table );
    81         self::$is_trash->setAccessible( false );
    82 
    83         self::$detached->setAccessible( true );
     83        if ( PHP_VERSION_ID < 80100 ) {
     84            self::$is_trash->setAccessible( false );
     85        }
     86
     87        if ( PHP_VERSION_ID < 80100 ) {
     88            self::$detached->setAccessible( true );
     89        }
    8490        self::$detached_original = self::$detached->getValue( self::$list_table );
    85         self::$detached->setAccessible( false );
     91        if ( PHP_VERSION_ID < 80100 ) {
     92            self::$detached->setAccessible( false );
     93        }
    8694
    8795        // Create users.
    … …  
    182190
    183191        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    184         $_get_row_actions->setAccessible( true );
     192        if ( PHP_VERSION_ID < 80100 ) {
     193            $_get_row_actions->setAccessible( true );
     194        }
    185195        $actions = $_get_row_actions->invoke( self::$list_table, self::$post, 'att_title' );
    186         $_get_row_actions->setAccessible( false );
     196        if ( PHP_VERSION_ID < 80100 ) {
     197            $_get_row_actions->setAccessible( false );
     198        }
    187199
    188200        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    263275
    264276        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    265         $_get_row_actions->setAccessible( true );
     277        if ( PHP_VERSION_ID < 80100 ) {
     278            $_get_row_actions->setAccessible( true );
     279        }
    266280        $actions = $_get_row_actions->invoke( self::$list_table, self::$post, 'att_title' );
    267         $_get_row_actions->setAccessible( false );
     281        if ( PHP_VERSION_ID < 80100 ) {
     282            $_get_row_actions->setAccessible( false );
     283        }
    268284
    269285        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    356372
    357373        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    358         $_get_row_actions->setAccessible( true );
     374        if ( PHP_VERSION_ID < 80100 ) {
     375            $_get_row_actions->setAccessible( true );
     376        }
    359377        $actions = $_get_row_actions->invoke( self::$list_table, self::$post, 'att_title' );
    360         $_get_row_actions->setAccessible( false );
     378        if ( PHP_VERSION_ID < 80100 ) {
     379            $_get_row_actions->setAccessible( false );
     380        }
    361381
    362382        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    375395
    376396        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    377         $_get_row_actions->setAccessible( true );
     397        if ( PHP_VERSION_ID < 80100 ) {
     398            $_get_row_actions->setAccessible( true );
     399        }
    378400        $actions = $_get_row_actions->invoke( self::$list_table, self::$attachment, 'att_title' );
    379         $_get_row_actions->setAccessible( false );
     401        if ( PHP_VERSION_ID < 80100 ) {
     402            $_get_row_actions->setAccessible( false );
     403        }
    380404
    381405        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    398422
    399423        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    400         $_get_row_actions->setAccessible( true );
     424        if ( PHP_VERSION_ID < 80100 ) {
     425            $_get_row_actions->setAccessible( true );
     426        }
    401427        $actions = $_get_row_actions->invoke( self::$list_table, self::$attachment, 'att_title' );
    402         $_get_row_actions->setAccessible( false );
     428        if ( PHP_VERSION_ID < 80100 ) {
     429            $_get_row_actions->setAccessible( false );
     430        }
    403431
    404432        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    415443    public function test_get_row_actions_should_include_download() {
    416444        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    417         $_get_row_actions->setAccessible( true );
     445        if ( PHP_VERSION_ID < 80100 ) {
     446            $_get_row_actions->setAccessible( true );
     447        }
    418448        $actions = $_get_row_actions->invoke( self::$list_table, self::$attachment, 'att_title' );
    419         $_get_row_actions->setAccessible( false );
     449        if ( PHP_VERSION_ID < 80100 ) {
     450            $_get_row_actions->setAccessible( false );
     451        }
    420452
    421453        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    436468
    437469        $_get_row_actions = new ReflectionMethod( self::$list_table, '_get_row_actions' );
    438         $_get_row_actions->setAccessible( true );
     470        if ( PHP_VERSION_ID < 80100 ) {
     471            $_get_row_actions->setAccessible( true );
     472        }
    439473        $actions = $_get_row_actions->invoke( self::$list_table, self::$attachment, 'att_title' );
    440         $_get_row_actions->setAccessible( false );
     474        if ( PHP_VERSION_ID < 80100 ) {
     475            $_get_row_actions->setAccessible( false );
     476        }
    441477
    442478        $this->assertIsArray( $actions, 'An array was not returned.' );
    … …  
    452488     */
    453489    private static function set_is_trash( $is_trash ) {
    454         self::$is_trash->setAccessible( true );
     490        if ( PHP_VERSION_ID < 80100 ) {
     491            self::$is_trash->setAccessible( true );
     492        }
    455493        self::$is_trash->setValue( self::$list_table, $is_trash );
    456         self::$is_trash->setAccessible( false );
     494        if ( PHP_VERSION_ID < 80100 ) {
     495            self::$is_trash->setAccessible( false );
     496        }
    457497    }
    458498
    … …  
    465505     */
    466506    private static function set_detached( $detached ) {
    467         self::$detached->setAccessible( true );
     507        if ( PHP_VERSION_ID < 80100 ) {
     508            self::$detached->setAccessible( true );
     509        }
    468510        self::$detached->setValue( self::$list_table, $detached );
    469         self::$detached->setAccessible( false );
     511        if ( PHP_VERSION_ID < 80100 ) {
     512            self::$detached->setAccessible( false );
     513        }
    470514    }
    471515}

  • trunk/tests/phpunit/tests/admin/wpPluginsListTable.php

    r60250 r60729  
    150150        $show_autoupdates = new ReflectionProperty( $list_table, 'show_autoupdates' );
    151151
    152         $show_autoupdates->setAccessible( true );
     152        if ( PHP_VERSION_ID < 80100 ) {
     153            $show_autoupdates->setAccessible( true );
     154        }
    153155        $actual = $show_autoupdates->getValue( $list_table );
    154         $show_autoupdates->setAccessible( false );
     156        if ( PHP_VERSION_ID < 80100 ) {
     157            $show_autoupdates->setAccessible( false );
     158        }
    155159
    156160        $_REQUEST['plugin_status'] = $original_status;

  • trunk/tests/phpunit/tests/admin/wpPrivacyRequestsTable.php

    r58176 r60729  
    5353        // Set the request type as 'export_personal_data'.
    5454        $reflection_property = $reflection->getProperty( 'request_type' );
    55         $reflection_property->setAccessible( true );
     55        if ( PHP_VERSION_ID < 80100 ) {
     56            $reflection_property->setAccessible( true );
     57        }
    5658        $reflection_property->setValue( $instance, 'export_personal_data' );
    5759
    5860        // Set the post type as 'user_request'.
    5961        $reflection_property = $reflection->getProperty( 'post_type' );
    60         $reflection_property->setAccessible( true );
     62        if ( PHP_VERSION_ID < 80100 ) {
     63            $reflection_property->setAccessible( true );
     64        }
    6165        $reflection_property->setValue( $instance, 'user_request' );
    6266

  • trunk/tests/phpunit/tests/admin/wpSiteHealth.php

    r58432 r60729  
    4141        $reflection          = new ReflectionClass( $this->instance );
    4242        $reflection_property = $reflection->getProperty( 'mysql_recommended_version' );
    43         $reflection_property->setAccessible( true );
    44 
     43        if ( PHP_VERSION_ID < 80100 ) {
     44            $reflection_property->setAccessible( true );
     45        }
    4546        $readme = file_get_contents( ABSPATH . 'readme.html' );
    4647
    … …  
    5758        $reflection          = new ReflectionClass( $this->instance );
    5859        $reflection_property = $reflection->getProperty( 'mariadb_recommended_version' );
    59         $reflection_property->setAccessible( true );
     60        if ( PHP_VERSION_ID < 80100 ) {
     61            $reflection_property->setAccessible( true );
     62        }
    6063
    6164        $readme = file_get_contents( ABSPATH . 'readme.html' );

  • trunk/tests/phpunit/tests/admin/wpTermsListTable.php

    r56680 r60729  
    5050    private function call_inaccessible_method( $instance, $method_name, $args = array() ) {
    5151        $method = ( new ReflectionClass( $instance ) )->getMethod( $method_name );
    52         $method->setAccessible( true );
     52        if ( PHP_VERSION_ID < 80100 ) {
     53            $method->setAccessible( true );
     54        }
    5355        return $method->invokeArgs( $instance, $args );
    5456    }

  • trunk/tests/phpunit/tests/admin/wpUpgrader.php

    r59257 r60729  
    171171    public function test_flatten_dirlist_should_flatten_the_provided_directory_list( $expected, $nested_files, $path = '' ) {
    172172        $flatten_dirlist = new ReflectionMethod( self::$instance, 'flatten_dirlist' );
    173         $flatten_dirlist->setAccessible( true );
     173        if ( PHP_VERSION_ID < 80100 ) {
     174            $flatten_dirlist->setAccessible( true );
     175        }
    174176        $actual = $flatten_dirlist->invoke( self::$instance, $nested_files, $path );
    175         $flatten_dirlist->setAccessible( false );
     177        if ( PHP_VERSION_ID < 80100 ) {
     178            $flatten_dirlist->setAccessible( false );
     179        }
    176180
    177181        $this->assertSameSetsWithIndex( $expected, $actual );

  • trunk/tests/phpunit/tests/block-bindings/wp-block-get-block-bindings-processor.php

    r60684 r60729  
    1616    public static function wpSetupBeforeClass() {
    1717        self::$get_block_bindings_processor_method = new ReflectionMethod( 'WP_Block', 'get_block_bindings_processor' );
    18         self::$get_block_bindings_processor_method->setAccessible( true );
     18        if ( PHP_VERSION_ID < 80100 ) {
     19            self::$get_block_bindings_processor_method->setAccessible( true );
     20        }
    1921    }
    2022

  • trunk/tests/phpunit/tests/block-supports/duotone.php

    r57652 r60729  
    7979
    8080        $reflection = new ReflectionMethod( 'WP_Duotone', 'get_slug_from_attribute' );
    81         $reflection->setAccessible( true );
     81        if ( PHP_VERSION_ID < 80100 ) {
     82            $reflection->setAccessible( true );
     83        }
    8284
    8385        $this->assertSame( $expected, $reflection->invoke( null, $data_attr ) );
    … …  
    129131        $wp_duotone                      = new WP_Duotone();
    130132        $block_css_declarations_property = new ReflectionProperty( 'WP_Duotone', 'block_css_declarations' );
    131         $block_css_declarations_property->setAccessible( true );
     133        if ( PHP_VERSION_ID < 80100 ) {
     134            $block_css_declarations_property->setAccessible( true );
     135        }
    132136        $previous_value = $block_css_declarations_property->getValue();
    133137        $block_css_declarations_property->setValue( $wp_duotone, array() );
    … …  
    138142        // Reset the property.
    139143        $block_css_declarations_property->setValue( $wp_duotone, $previous_value );
    140         $block_css_declarations_property->setAccessible( false );
     144        if ( PHP_VERSION_ID < 80100 ) {
     145            $block_css_declarations_property->setAccessible( false );
     146        }
    141147
    142148        $this->assertNotEmpty( $actual );
    … …  
    148154    public function test_is_preset( $data_attr, $expected ) {
    149155        $reflection = new ReflectionMethod( 'WP_Duotone', 'is_preset' );
    150         $reflection->setAccessible( true );
     156        if ( PHP_VERSION_ID < 80100 ) {
     157            $reflection->setAccessible( true );
     158        }
    151159
    152160        $this->assertSame( $expected, $reflection->invoke( null, $data_attr ) );
    … …  
    174182    public function test_colord_parse_hue( $value, $unit, $expected ) {
    175183        $reflection = new ReflectionMethod( 'WP_Duotone', 'colord_parse_hue' );
    176         $reflection->setAccessible( true );
     184        if ( PHP_VERSION_ID < 80100 ) {
     185            $reflection->setAccessible( true );
     186        }
    177187
    178188        $this->assertSame( $expected, $reflection->invoke( null, $value, $unit ) );

  • trunk/tests/phpunit/tests/block-template.php

    r59201 r60729  
    328328        $this->assertSame( $expected, get_block_theme_folders( $theme ), 'Incorrect block theme folders were retrieved.' );
    329329        $reflection = new ReflectionMethod( $wp_theme, 'cache_get' );
    330         $reflection->setAccessible( true );
     330        if ( PHP_VERSION_ID < 80100 ) {
     331            $reflection->setAccessible( true );
     332        }
    331333        $theme_cache  = $reflection->invoke( $wp_theme, 'theme' );
    332334        $cached_value = $theme_cache['block_template_folders'];
    333         $reflection->setAccessible( false );
     335        if ( PHP_VERSION_ID < 80100 ) {
     336            $reflection->setAccessible( false );
     337        }
    334338
    335339        $this->assertSame( $expected, $cached_value, 'The cached value is incorrect.' );

  • trunk/tests/phpunit/tests/blocks/wpBlockPatternsRegistry.php

    r58176 r60729  
    663663        $reflection = new ReflectionClass( $registry );
    664664        $property   = $reflection->getProperty( 'registered_patterns' );
    665         $property->setAccessible( true );
     665        if ( PHP_VERSION_ID < 80100 ) {
     666            $property->setAccessible( true );
     667        }
    666668
    667669        // Get the value of the private property.
    668670        $registered_patterns = $property->getValue( $registry );
    669         $property->setAccessible( false );
     671        if ( PHP_VERSION_ID < 80100 ) {
     672            $property->setAccessible( false );
     673        }
    670674
    671675        return $registered_patterns;
    … …  
    682686        $reflection = new ReflectionClass( $registry );
    683687        $property   = $reflection->getProperty( 'registered_patterns' );
    684         $property->setAccessible( true );
     688        if ( PHP_VERSION_ID < 80100 ) {
     689            $property->setAccessible( true );
     690        }
    685691
    686692        // Set the value of the private property.
    687693        $property->setValue( $registry, $value );
    688         $property->setAccessible( false );
     694        if ( PHP_VERSION_ID < 80100 ) {
     695            $property->setAccessible( false );
     696        }
    689697    }
    690698}

  • trunk/tests/phpunit/tests/db.php

    r60622 r60729  
    19881988
    19891989        $property = new ReflectionProperty( $wpdb, 'allow_unsafe_unquoted_parameters' );
    1990         $property->setAccessible( true );
     1990        if ( PHP_VERSION_ID < 80100 ) {
     1991            $property->setAccessible( true );
     1992        }
    19911993        $property->setValue( $wpdb, $allow );
    19921994
    … …  
    19961998        // Reset.
    19971999        $property->setValue( $wpdb, $default );
    1998         $property->setAccessible( false );
     2000        if ( PHP_VERSION_ID < 80100 ) {
     2001            $property->setAccessible( false );
     2002        }
    19992003
    20002004        $this->assertSame( $expected, $actual );

  • trunk/tests/phpunit/tests/dependencies/scripts.php

    r60728 r60729  
    446446        $wp_scripts_reflection      = new ReflectionClass( WP_Scripts::class );
    447447        $filter_eligible_strategies = $wp_scripts_reflection->getMethod( 'filter_eligible_strategies' );
    448         $filter_eligible_strategies->setAccessible( true );
     448        if ( PHP_VERSION_ID < 80100 ) {
     449            $filter_eligible_strategies->setAccessible( true );
     450        }
    449451        $this->assertSame( $expected, $filter_eligible_strategies->invokeArgs( wp_scripts(), array( $handle ) ), 'Expected return value of WP_Scripts::filter_eligible_strategies to match.' );
    450452    }

  • trunk/tests/phpunit/tests/error-protection/wpRecoveryModeCookieService.php

    r51650 r60729  
    3636        $service    = new WP_Recovery_Mode_Cookie_Service();
    3737        $reflection = new ReflectionMethod( $service, 'recovery_mode_hash' );
    38         $reflection->setAccessible( true );
     38        if ( PHP_VERSION_ID < 80100 ) {
     39            $reflection->setAccessible( true );
     40        }
    3941
    4042        $to_sign = sprintf( 'recovery_mode|%s|%s', time() - WEEK_IN_SECONDS - 30, wp_generate_password( 20, false ) );
    … …  
    5557        $service    = new WP_Recovery_Mode_Cookie_Service();
    5658        $reflection = new ReflectionMethod( $service, 'generate_cookie' );
    57         $reflection->setAccessible( true );
     59        if ( PHP_VERSION_ID < 80100 ) {
     60            $reflection->setAccessible( true );
     61        }
    5862
    5963        $cookie  = $reflection->invoke( $service );
    … …  
    7377        $service    = new WP_Recovery_Mode_Cookie_Service();
    7478        $reflection = new ReflectionMethod( $service, 'recovery_mode_hash' );
    75         $reflection->setAccessible( true );
     79        if ( PHP_VERSION_ID < 80100 ) {
     80            $reflection->setAccessible( true );
     81        }
    7682
    7783        $to_sign = sprintf( 'recovery_mode|%s|%s', 'month', wp_generate_password( 20, false ) );
    … …  
    9399        $service    = new WP_Recovery_Mode_Cookie_Service();
    94100        $reflection = new ReflectionMethod( $service, 'generate_cookie' );
    95         $reflection->setAccessible( true );
     101        if ( PHP_VERSION_ID < 80100 ) {
     102            $reflection->setAccessible( true );
     103        }
    96104
    97105        $this->assertTrue( $service->validate_cookie( $reflection->invoke( $service ) ) );

  • trunk/tests/phpunit/tests/functions/maybeSerialize.php

    r57735 r60729  
    218218            $new_value = unserialize( $serialized );
    219219            $property  = ( new ReflectionClass( 'WpOrg\Requests\Utility\FilteredIterator' ) )->getProperty( 'callback' );
    220             $property->setAccessible( true );
     220            if ( PHP_VERSION_ID < 80100 ) {
     221                $property->setAccessible( true );
     222            }
    221223            $callback_value = $property->getValue( $new_value );
    222224

  • trunk/tests/phpunit/tests/hooks/addFilter.php

    r56609 r60729  
    317317        $reflection          = new ReflectionClass( $hook );
    318318        $reflection_property = $reflection->getProperty( 'priorities' );
    319         $reflection_property->setAccessible( true );
     319        if ( PHP_VERSION_ID < 80100 ) {
     320            $reflection_property->setAccessible( true );
     321        }
    320322
    321323        return $reflection_property->getValue( $hook );

  • trunk/tests/phpunit/tests/hooks/removeAllFilters.php

    r56609 r60729  
    5858        $reflection          = new ReflectionClass( $hook );
    5959        $reflection_property = $reflection->getProperty( 'priorities' );
    60         $reflection_property->setAccessible( true );
     60        if ( PHP_VERSION_ID < 80100 ) {
     61            $reflection_property->setAccessible( true );
     62        }
    6163
    6264        return $reflection_property->getValue( $hook );

  • trunk/tests/phpunit/tests/hooks/removeFilter.php

    r56609 r60729  
    102102        $reflection          = new ReflectionClass( $hook );
    103103        $reflection_property = $reflection->getProperty( 'priorities' );
    104         $reflection_property->setAccessible( true );
     104        if ( PHP_VERSION_ID < 80100 ) {
     105            $reflection_property->setAccessible( true );
     106        }
    105107
    106108        return $reflection_property->getValue( $hook );

  • trunk/tests/phpunit/tests/image/editor.php

    r58049 r60729  
    210210
    211211        $property = new ReflectionProperty( $editor, 'size' );
    212         $property->setAccessible( true );
     212        if ( PHP_VERSION_ID < 80100 ) {
     213            $property->setAccessible( true );
     214        }
    213215        $property->setValue(
    214216            $editor,
    … …  
    256258        );
    257259        $property = new ReflectionProperty( $editor, 'size' );
    258         $property->setAccessible( true );
     260        if ( PHP_VERSION_ID < 80100 ) {
     261            $property->setAccessible( true );
     262        }
    259263        $property->setValue( $editor, $size );
    260264
    … …  
    279283        );
    280284        $property = new ReflectionProperty( $editor, 'size' );
    281         $property->setAccessible( true );
     285        if ( PHP_VERSION_ID < 80100 ) {
     286            $property->setAccessible( true );
     287        }
    282288        $property->setValue( $editor, $size );
    283289

  • trunk/tests/phpunit/tests/image/editorGd.php

    r54401 r60729  
    555555
    556556        $property = new ReflectionProperty( $gd_image_editor, 'image' );
    557         $property->setAccessible( true );
     557        if ( PHP_VERSION_ID < 80100 ) {
     558            $property->setAccessible( true );
     559        }
    558560
    559561        $color_top_left = imagecolorat( $property->getValue( $gd_image_editor ), 0, 0 );
    … …  
    574576
    575577        $property = new ReflectionProperty( $gd_image_editor, 'image' );
    576         $property->setAccessible( true );
     578        if ( PHP_VERSION_ID < 80100 ) {
     579            $property->setAccessible( true );
     580        }
    577581
    578582        $color_top_left = imagecolorat( $property->getValue( $gd_image_editor ), 0, 0 );

  • trunk/tests/phpunit/tests/image/editorImagick.php

    r60667 r60729  
    441441
    442442        $property = new ReflectionProperty( $imagick_image_editor, 'image' );
    443         $property->setAccessible( true );
     443        if ( PHP_VERSION_ID < 80100 ) {
     444            $property->setAccessible( true );
     445        }
    444446
    445447        $color_top_left = $property->getValue( $imagick_image_editor )->getImagePixelColor( 0, 0 )->getColor();
    … …  
    460462
    461463        $property = new ReflectionProperty( $imagick_image_editor, 'image' );
    462         $property->setAccessible( true );
     464        if ( PHP_VERSION_ID < 80100 ) {
     465            $property->setAccessible( true );
     466        }
    463467
    464468        $color_top_left = $property->getValue( $imagick_image_editor )->getImagePixelColor( 0, 0 )->getColor();

  • trunk/tests/phpunit/tests/interactivity-api/wpInteractivityAPI-wp-style.php

    r58594 r60729  
    4848    private function merge_style_property( $style_attribute_value, $style_property_name, $style_property_value ) {
    4949        $evaluate = new ReflectionMethod( $this->interactivity, 'merge_style_property' );
    50         $evaluate->setAccessible( true );
     50        if ( PHP_VERSION_ID < 80100 ) {
     51            $evaluate->setAccessible( true );
     52        }
    5153        return $evaluate->invokeArgs( $this->interactivity, array( $style_attribute_value, $style_property_name, $style_property_value ) );
    5254    }

  • trunk/tests/phpunit/tests/interactivity-api/wpInteractivityAPI.php

    r60070 r60729  
    4242        $interactivity   = new ReflectionClass( $this->interactivity );
    4343        $namespace_stack = $interactivity->getProperty( 'namespace_stack' );
    44         $namespace_stack->setAccessible( true );
     44        if ( PHP_VERSION_ID < 80100 ) {
     45            $namespace_stack->setAccessible( true );
     46        }
    4547        $namespace_stack->setValue( $this->interactivity, $stack );
    4648    }
    … …  
    5658        $interactivity = new ReflectionClass( $this->interactivity );
    5759        $context_stack = $interactivity->getProperty( 'context_stack' );
    58         $context_stack->setAccessible( true );
     60        if ( PHP_VERSION_ID < 80100 ) {
     61            $context_stack->setAccessible( true );
     62        }
    5963        $context_stack->setValue( $this->interactivity, $stack );
    6064    }
    … …  
    587591    public function test_extract_directive_value() {
    588592        $extract_directive_value = new ReflectionMethod( $this->interactivity, 'extract_directive_value' );
    589         $extract_directive_value->setAccessible( true );
     593        if ( PHP_VERSION_ID < 80100 ) {
     594            $extract_directive_value->setAccessible( true );
     595        }
    590596
    591597        $result = $extract_directive_value->invoke( $this->interactivity, 'state.foo', 'myPlugin' );
    … …  
    650656    public function test_extract_directive_value_empty_values() {
    651657        $extract_directive_value = new ReflectionMethod( $this->interactivity, 'extract_directive_value' );
    652         $extract_directive_value->setAccessible( true );
     658        if ( PHP_VERSION_ID < 80100 ) {
     659            $extract_directive_value->setAccessible( true );
     660        }
    653661
    654662        $result = $extract_directive_value->invoke( $this->interactivity, '', 'myPlugin' );
    … …  
    684692    public function test_extract_directive_value_invalid_json() {
    685693        $extract_directive_value = new ReflectionMethod( $this->interactivity, 'extract_directive_value' );
    686         $extract_directive_value->setAccessible( true );
     694        if ( PHP_VERSION_ID < 80100 ) {
     695            $extract_directive_value->setAccessible( true );
     696        }
    687697
    688698        // Invalid JSON due to missing quotes. Returns the original value.
    … …  
    705715    public function test_extract_prefix_and_suffix() {
    706716        $extract_prefix_and_suffix = new ReflectionMethod( $this->interactivity, 'extract_prefix_and_suffix' );
    707         $extract_prefix_and_suffix->setAccessible( true );
     717        if ( PHP_VERSION_ID < 80100 ) {
     718            $extract_prefix_and_suffix->setAccessible( true );
     719        }
    708720
    709721        $result = $extract_prefix_and_suffix->invoke( $this->interactivity, 'data-wp-interactive' );
    … …  
    979991
    980992        $evaluate = new ReflectionMethod( $this->interactivity, 'evaluate' );
    981         $evaluate->setAccessible( true );
     993        if ( PHP_VERSION_ID < 80100 ) {
     994            $evaluate->setAccessible( true );
     995        }
    982996
    983997        $result = $evaluate->invokeArgs( $this->interactivity, array( $directive_value ) );
    … …  
    13941408    public function test_kebab_to_camel_case() {
    13951409        $method = new ReflectionMethod( $this->interactivity, 'kebab_to_camel_case' );
    1396         $method->setAccessible( true );
     1410        if ( PHP_VERSION_ID < 80100 ) {
     1411            $method->setAccessible( true );
     1412        }
    13971413
    13981414        $this->assertSame( '', $method->invoke( $this->interactivity, '' ) );

  • trunk/tests/phpunit/tests/interactivity-api/wpInteractivityAPIFunctions.php

    r58739 r60729  
    283283        $class                = new ReflectionClass( 'WP_Interactivity_API' );
    284284        $directive_processors = $class->getProperty( 'directive_processors' );
    285         $directive_processors->setAccessible( true );
     285        if ( PHP_VERSION_ID < 80100 ) {
     286            $directive_processors->setAccessible( true );
     287        }
    286288        $old_directive_processors = $directive_processors->getValue();
    287289        $directive_processors->setValue( null, array( 'data-wp-test' => array( $this, 'data_wp_test_processor' ) ) );

  • trunk/tests/phpunit/tests/menu/walker-nav-menu.php

    r59674 r60729  
    396396        $build_atts_reflection = new ReflectionMethod( $this->walker, 'build_atts' );
    397397
    398         $build_atts_reflection->setAccessible( true );
     398        if ( PHP_VERSION_ID < 80100 ) {
     399            $build_atts_reflection->setAccessible( true );
     400        }
    399401        $actual = $build_atts_reflection->invoke( $this->walker, $atts );
    400         $build_atts_reflection->setAccessible( false );
     402        if ( PHP_VERSION_ID < 80100 ) {
     403            $build_atts_reflection->setAccessible( false );
     404        }
    401405
    402406        $this->assertSame( $expected, $actual );

  • trunk/tests/phpunit/tests/multisite/network.php

    r60666 r60729  
    158158        $reflection = new ReflectionObject( $network );
    159159        $property   = $reflection->getProperty( 'id' );
    160         $property->setAccessible( true );
     160        if ( PHP_VERSION_ID < 80100 ) {
     161            $property->setAccessible( true );
     162        }
    161163
    162164        $this->assertSame( (int) $id, $property->getValue( $network ) );
    … …  
    195197        $reflection = new ReflectionObject( $network );
    196198        $property   = $reflection->getProperty( 'blog_id' );
    197         $property->setAccessible( true );
     199        if ( PHP_VERSION_ID < 80100 ) {
     200            $property->setAccessible( true );
     201        }
    198202
    199203        $this->assertIsString( $property->getValue( $network ) );

  • trunk/tests/phpunit/tests/post/query.php

    r57987 r60729  
    727727
    728728        $method = new ReflectionMethod( 'WP_Query', 'set_found_posts' );
    729         $method->setAccessible( true );
     729        if ( PHP_VERSION_ID < 80100 ) {
     730            $method->setAccessible( true );
     731        }
    730732        $method->invoke( $q, array( 'no_found_rows' => false ), array() );
    731733

  • trunk/tests/phpunit/tests/query/cacheResults.php

    r59979 r60729  
    103103
    104104        $reflection = new ReflectionMethod( $query1, 'generate_cache_key' );
    105         $reflection->setAccessible( true );
     105        if ( PHP_VERSION_ID < 80100 ) {
     106            $reflection->setAccessible( true );
     107        }
    106108
    107109        $cache_key_1 = $reflection->invoke( $query1, $query_vars, $request );
    … …  
    159161
    160162        $reflection = new ReflectionMethod( $query1, 'generate_cache_key' );
    161         $reflection->setAccessible( true );
     163        if ( PHP_VERSION_ID < 80100 ) {
     164            $reflection->setAccessible( true );
     165        }
    162166
    163167        $cache_key_1 = $reflection->invoke( $query1, $query_vars, $request );
    … …  
    192196
    193197        $reflection = new ReflectionMethod( $query1, 'generate_cache_key' );
    194         $reflection->setAccessible( true );
     198        if ( PHP_VERSION_ID < 80100 ) {
     199            $reflection->setAccessible( true );
     200        }
    195201
    196202        $cache_key_1 = $reflection->invoke( $query1, $query_vars, $request1 );
    … …  
    228234
    229235        $reflection_q1 = new ReflectionProperty( $query1, 'query_cache_key' );
    230         $reflection_q1->setAccessible( true );
     236        if ( PHP_VERSION_ID < 80100 ) {
     237            $reflection_q1->setAccessible( true );
     238        }
    231239
    232240        $reflection_q2 = new ReflectionProperty( $query2, 'query_cache_key' );
    233         $reflection_q2->setAccessible( true );
     241        if ( PHP_VERSION_ID < 80100 ) {
     242            $reflection_q2->setAccessible( true );
     243        }
    234244
    235245        $this->assertNotSame( $request1, $request2, 'Queries should not match' );
    … …  
    289299
    290300        $reflection_q1 = new ReflectionProperty( $query1, 'query_cache_key' );
    291         $reflection_q1->setAccessible( true );
     301        if ( PHP_VERSION_ID < 80100 ) {
     302            $reflection_q1->setAccessible( true );
     303        }
    292304
    293305        $reflection_q2 = new ReflectionProperty( $query2, 'query_cache_key' );
    294         $reflection_q2->setAccessible( true );
     306        if ( PHP_VERSION_ID < 80100 ) {
     307            $reflection_q2->setAccessible( true );
     308        }
    295309
    296310        $this->assertNotSame( $request1, $request2, 'Queries should not match' );
    … …  
    346360
    347361        $reflection_q1 = new ReflectionProperty( $query1, 'query_cache_key' );
    348         $reflection_q1->setAccessible( true );
     362        if ( PHP_VERSION_ID < 80100 ) {
     363            $reflection_q1->setAccessible( true );
     364        }
    349365
    350366        $reflection_q2 = new ReflectionProperty( $query2, 'query_cache_key' );
    351         $reflection_q2->setAccessible( true );
     367        if ( PHP_VERSION_ID < 80100 ) {
     368            $reflection_q2->setAccessible( true );
     369        }
    352370
    353371        $this->assertNotSame( $request1, $request2, 'Queries should not match' );
    … …  
    386404
    387405        $reflection_q1 = new ReflectionProperty( $query1, 'query_cache_key' );
    388         $reflection_q1->setAccessible( true );
     406        if ( PHP_VERSION_ID < 80100 ) {
     407            $reflection_q1->setAccessible( true );
     408        }
    389409
    390410        $reflection_q2 = new ReflectionProperty( $query2, 'query_cache_key' );
    391         $reflection_q2->setAccessible( true );
     411        if ( PHP_VERSION_ID < 80100 ) {
     412            $reflection_q2->setAccessible( true );
     413        }
    392414
    393415        $this->assertSame( $request1, $request2, 'Queries should match' );

  • trunk/tests/phpunit/tests/rest-api/rest-pattern-directory-controller.php

    r59970 r60729  
    708708    public function test_transient_keys_get_generated_correctly( $parameters_1, $parameters_2, $message, $assert_same = true ) {
    709709        $reflection_method = new ReflectionMethod( static::$controller, 'get_transient_key' );
    710         $reflection_method->setAccessible( true );
     710        if ( PHP_VERSION_ID < 80100 ) {
     711            $reflection_method->setAccessible( true );
     712        }
    711713
    712714        $result_1 = $reflection_method->invoke( self::$controller, $parameters_1 );

  • trunk/tests/phpunit/tests/rest-api/wpRestBlockPatternCategoriesController.php

    r59970 r60729  
    6464        self::$orig_registry              = WP_Block_Pattern_Categories_Registry::get_instance();
    6565        self::$registry_instance_property = new ReflectionProperty( 'WP_Block_Pattern_Categories_Registry', 'instance' );
    66         self::$registry_instance_property->setAccessible( true );
     66        if ( PHP_VERSION_ID < 80100 ) {
     67            self::$registry_instance_property->setAccessible( true );
     68        }
    6769        $test_registry = new WP_Block_Pattern_Categories_Registry();
    6870        self::$registry_instance_property->setValue( null, $test_registry );
    … …  
    9092        // Restore the original registry instance.
    9193        self::$registry_instance_property->setValue( null, self::$orig_registry );
    92         self::$registry_instance_property->setAccessible( false );
     94
     95        if ( PHP_VERSION_ID < 80100 ) {
     96            self::$registry_instance_property->setAccessible( false );
     97        }
    9398        self::$registry_instance_property = null;
    9499        self::$orig_registry              = null;

  • trunk/tests/phpunit/tests/rest-api/wpRestBlockPatternsController.php

    r59964 r60729  
    6464        self::$orig_registry              = WP_Block_Patterns_Registry::get_instance();
    6565        self::$registry_instance_property = new ReflectionProperty( 'WP_Block_Patterns_Registry', 'instance' );
    66         self::$registry_instance_property->setAccessible( true );
     66        if ( PHP_VERSION_ID < 80100 ) {
     67            self::$registry_instance_property->setAccessible( true );
     68        }
    6769        $test_registry = new WP_Block_Pattern_Categories_Registry();
    6870        self::$registry_instance_property->setValue( null, $test_registry );
    … …  
    108110        // Restore the original registry instance.
    109111        self::$registry_instance_property->setValue( null, self::$orig_registry );
    110         self::$registry_instance_property->setAccessible( false );
     112        if ( PHP_VERSION_ID < 80100 ) {
     113            self::$registry_instance_property->setAccessible( false );
     114        }
    111115        self::$registry_instance_property = null;
    112116        self::$orig_registry              = null;

  • trunk/tests/phpunit/tests/rest-api/wpRestTemplatesController.php

    r59970 r60729  
    11421142
    11431143        $prepare_item_for_database = new ReflectionMethod( $endpoint, 'prepare_item_for_database' );
    1144         $prepare_item_for_database->setAccessible( true );
     1144        if ( PHP_VERSION_ID < 80100 ) {
     1145            $prepare_item_for_database->setAccessible( true );
     1146        }
    11451147
    11461148        $body_params = array(
    … …  
    11941196
    11951197        $prepare_item_for_database = new ReflectionMethod( $endpoint, 'prepare_item_for_database' );
    1196         $prepare_item_for_database->setAccessible( true );
     1198        if ( PHP_VERSION_ID < 80100 ) {
     1199            $prepare_item_for_database->setAccessible( true );
     1200        }
    11971201
    11981202        $id          = get_stylesheet() . '//' . 'my_template_part';

  • trunk/tests/phpunit/tests/rest-api/wpRestUrlDetailsController.php

    r56559 r60729  
    11971197        $class  = new ReflectionClass( WP_REST_URL_Details_Controller::class );
    11981198        $method = $class->getMethod( $method_name );
    1199         $method->setAccessible( true );
     1199        if ( PHP_VERSION_ID < 80100 ) {
     1200            $method->setAccessible( true );
     1201        }
    12001202        return $method;
    12011203    }

  • trunk/tests/phpunit/tests/script-modules/wpScriptModules.php

    r60704 r60729  
    876876    public function test_get_src() {
    877877        $get_src = new ReflectionMethod( $this->script_modules, 'get_src' );
    878         $get_src->setAccessible( true );
     878        if ( PHP_VERSION_ID < 80100 ) {
     879            $get_src->setAccessible( true );
     880        }
    879881
    880882        $this->script_modules->register(
    … …  
    13511353        $reflection_class    = new ReflectionClass( $script_modules );
    13521354        $registered_property = $reflection_class->getProperty( 'registered' );
    1353         $registered_property->setAccessible( true );
     1355        if ( PHP_VERSION_ID < 80100 ) {
     1356            $registered_property->setAccessible( true );
     1357        }
    13541358        return $registered_property->getValue( $script_modules );
    13551359    }

  • trunk/tests/phpunit/tests/term/query.php

    r60661 r60729  
    10691069
    10701070        $reflection = new ReflectionMethod( $query1, 'generate_cache_key' );
    1071         $reflection->setAccessible( true );
     1071        if ( PHP_VERSION_ID < 80100 ) {
     1072            $reflection->setAccessible( true );
     1073        }
    10721074
    10731075        $cache_key_1 = $reflection->invoke( $query1, $query_vars, $request );

  • trunk/tests/phpunit/tests/theme.php

    r60251 r60729  
    233233        $reflection = new ReflectionClass( 'WP_Theme' );
    234234        $property   = $reflection->getProperty( 'default_themes' );
    235         $property->setAccessible( true );
     235        if ( PHP_VERSION_ID < 80100 ) {
     236            $property->setAccessible( true );
     237        }
    236238
    237239        /*

  • trunk/tests/phpunit/tests/theme/customHeader.php

    r56559 r60729  
    505505        $class    = new ReflectionClass( 'WP_Customize_Manager' );
    506506        $property = $class->getProperty( 'previewing' );
    507         $property->setAccessible( true );
     507        if ( PHP_VERSION_ID < 80100 ) {
     508            $property->setAccessible( true );
     509        }
    508510        $property->setValue( $this->customize_manager, $value );
    509511    }

  • trunk/tests/phpunit/tests/theme/wpTheme.php

    r60500 r60729  
    302302        $reflection          = new ReflectionClass( $theme );
    303303        $reflection_property = $reflection->getProperty( 'block_theme' );
    304         $reflection_property->setAccessible( true );
     304        if ( PHP_VERSION_ID < 80100 ) {
     305            $reflection_property->setAccessible( true );
     306        }
    305307
    306308        $this->assertSame( $expected, $reflection_property->getValue( $theme ) );
    … …  
    612614        $theme           = new WP_Theme( 'twentytwentytwo', $this->theme_root );
    613615        $sanitize_header = new ReflectionMethod( $theme, 'sanitize_header' );
    614         $sanitize_header->setAccessible( true );
     616        if ( PHP_VERSION_ID < 80100 ) {
     617            $sanitize_header->setAccessible( true );
     618        }
    615619
    616620        $actual = $sanitize_header->invoke( $theme, 'UpdateURI', '<?php?><a href="http://example.org">http://example.org</a>' );

  • trunk/tests/phpunit/tests/theme/wpThemeGetBlockPatterns.php

    r58025 r60729  
    4949    private function get_pattern_cache( $wp_theme ) {
    5050        $reflection = new ReflectionMethod( $wp_theme, 'get_pattern_cache' );
    51         $reflection->setAccessible( true );
     51        if ( PHP_VERSION_ID < 80100 ) {
     52            $reflection->setAccessible( true );
     53        }
    5254
    5355        $pattern_cache = $reflection->invoke( $wp_theme, 'get_pattern_cache' );
    54         $reflection->setAccessible( false );
     56        if ( PHP_VERSION_ID < 80100 ) {
     57            $reflection->setAccessible( false );
     58        }
    5559
    5660        return $pattern_cache;
    … …  
    6569    private function get_cache_hash( $wp_theme ) {
    6670        $reflection = new ReflectionProperty( get_class( $wp_theme ), 'cache_hash' );
    67         $reflection->setAccessible( true );
     71        if ( PHP_VERSION_ID < 80100 ) {
     72            $reflection->setAccessible( true );
     73        }
    6874        $cache_hash = $reflection->getValue( $wp_theme );
    69         $reflection->setAccessible( false );
     75        if ( PHP_VERSION_ID < 80100 ) {
     76            $reflection->setAccessible( false );
     77        }
    7078        return $cache_hash;
    7179    }

  • trunk/tests/phpunit/tests/theme/wpThemeJson.php

    r59814 r60729  
    24592459
    24602460        $func = $theme_json->getMethod( 'get_block_nodes' );
    2461         $func->setAccessible( true );
     2461        if ( PHP_VERSION_ID < 81000 ) {
     2462            $func->setAccessible( true );
     2463        }
    24622464
    24632465        $theme_json = array(
    … …  
    25132515
    25142516        $func = $theme_json->getMethod( 'get_block_nodes' );
    2515         $func->setAccessible( true );
     2517        if ( PHP_VERSION_ID < 81000 ) {
     2518            $func->setAccessible( true );
     2519        }
    25162520
    25172521        $theme_json = array(
    … …  
    38523856
    38533857        $get_property_value_method = $reflection_class->getMethod( 'get_property_value' );
    3854         $get_property_value_method->setAccessible( true );
     3858        if ( PHP_VERSION_ID < 80100 ) {
     3859            $get_property_value_method->setAccessible( true );
     3860        }
    38553861        $result = $get_property_value_method->invoke( null, $styles, $path );
    38563862
    … …  
    58435849        );
    58445850        $reflection = new ReflectionMethod( $theme_json, 'process_blocks_custom_css' );
    5845         $reflection->setAccessible( true );
     5851        if ( PHP_VERSION_ID < 80100 ) {
     5852            $reflection->setAccessible( true );
     5853        }
    58465854
    58475855        $this->assertSame( $expected, $reflection->invoke( $theme_json, $input['css'], $input['selector'] ) );
    … …  
    61786186
    61796187        $func = $theme_json->getMethod( 'get_block_style_variation_selector' );
    6180         $func->setAccessible( true );
     6188        if ( PHP_VERSION_ID < 80100 ) {
     6189            $func->setAccessible( true );
     6190        }
    61816191
    61826192        $actual = $func->invoke( null, 'custom', $selector );
    … …  
    62606270
    62616271        $func = $theme_json->getMethod( 'scope_style_node_selectors' );
    6262         $func->setAccessible( true );
     6272        if ( PHP_VERSION_ID < 80100 ) {
     6273            $func->setAccessible( true );
     6274        }
    62636275
    62646276        $node = array(
    … …  
    63096321
    63106322        $func = $theme_json->getMethod( 'get_block_nodes' );
    6311         $func->setAccessible( true );
     6323        if ( PHP_VERSION_ID < 80100 ) {
     6324            $func->setAccessible( true );
     6325        }
    63126326
    63136327        $theme_json = array(
    … …  
    63456359
    63466360        $func = $theme_json->getMethod( 'get_block_nodes' );
    6347         $func->setAccessible( true );
     6361        if ( PHP_VERSION_ID < 80100 ) {
     6362            $func->setAccessible( true );
     6363        }
    63486364
    63496365        $theme_json = array(

  • trunk/tests/phpunit/tests/theme/wpThemeJsonResolver.php

    r60234 r60729  
    7878
    7979        static::$property_blocks_cache = new ReflectionProperty( WP_Theme_JSON_Resolver::class, 'blocks_cache' );
    80         static::$property_blocks_cache->setAccessible( true );
     80        if ( PHP_VERSION_ID < 80100 ) {
     81            static::$property_blocks_cache->setAccessible( true );
     82        }
    8183        static::$property_blocks_cache_orig_value = static::$property_blocks_cache->getValue();
    8284
    8385        static::$property_core = new ReflectionProperty( WP_Theme_JSON_Resolver::class, 'core' );
    84         static::$property_core->setAccessible( true );
     86        if ( PHP_VERSION_ID < 80100 ) {
     87            static::$property_core->setAccessible( true );
     88        }
    8589        static::$property_core_orig_value = static::$property_core->getValue();
    8690    }
    … …  
    307311    public function test_has_same_registered_blocks_when_all_blocks_not_cached( $origin, array $cache = array() ) {
    308312        $has_same_registered_blocks = new ReflectionMethod( WP_Theme_JSON_Resolver::class, 'has_same_registered_blocks' );
    309         $has_same_registered_blocks->setAccessible( true );
     313        if ( PHP_VERSION_ID < 80100 ) {
     314            $has_same_registered_blocks->setAccessible( true );
     315        }
    310316        $expected_cache = $this->get_registered_block_names();
    311317
    … …  
    381387    public function test_has_same_registered_blocks_when_all_blocks_are_cached( $origin ) {
    382388        $has_same_registered_blocks = new ReflectionMethod( WP_Theme_JSON_Resolver::class, 'has_same_registered_blocks' );
    383         $has_same_registered_blocks->setAccessible( true );
     389        if ( PHP_VERSION_ID < 80100 ) {
     390            $has_same_registered_blocks->setAccessible( true );
     391        }
    384392        $expected_cache = $this->get_registered_block_names();
    385393
    … …  
    837845        // Force-unset $i18n_schema property to "unload" translation schema.
    838846        $property = new ReflectionProperty( $theme_json_resolver, 'i18n_schema' );
    839         $property->setAccessible( true );
     847        if ( PHP_VERSION_ID < 80100 ) {
     848            $property->setAccessible( true );
     849        }
    840850        $property->setValue( null, null );
    841851

  • trunk/tests/phpunit/tests/user/queryCache.php

    r58876 r60729  
    772772
    773773        $reflection = new ReflectionMethod( $query1, 'generate_cache_key' );
    774         $reflection->setAccessible( true );
     774        if ( PHP_VERSION_ID < 80100 ) {
     775            $reflection->setAccessible( true );
     776        }
    775777
    776778        $cache_key_1 = $reflection->invoke( $query1, $query_vars, $request_with_placeholder );

  • trunk/tests/phpunit/tests/widgets/wpWidgetMedia.php

    r56746 r60729  
    495495        $wp_widget_media = new ReflectionClass( 'WP_Widget_Media' );
    496496        $has_content     = $wp_widget_media->getMethod( 'has_content' );
    497         $has_content->setAccessible( true );
     497        if ( PHP_VERSION_ID < 80100 ) {
     498            $has_content->setAccessible( true );
     499        }
    498500
    499501        $result = $has_content->invokeArgs(
Note: See TracChangeset for help on using the changeset viewer.