WordPress.org

Make WordPress Core

Ticket #17817: 17817.22.diff

File 17817.22.diff, 65.2 KB (added by pento, 3 years ago)
  • src/wp-includes/class-wp-hook.php

     
     1<?php
     2/**
     3 * Plugin API: WP_Hook class
     4 *
     5 * @package WordPress
     6 * @subpackage Plugin
     7 * @since 4.7.0
     8 */
     9
     10/**
     11 * Core class used to implement action and filter hook functionality.
     12 *
     13 * @since 4.7.0
     14 *
     15 * @see Iterator
     16 * @see ArrayAccess
     17 */
     18final class WP_Hook implements Iterator, ArrayAccess {
     19
     20        /**
     21         * Hook callbacks.
     22         *
     23         * @since 4.7.0
     24         * @access public
     25         * @var array
     26         */
     27        public $callbacks = array();
     28
     29        /**
     30         * The priority keys of actively running iterations of a hook.
     31         *
     32         * @since 4.7.0
     33         * @access private
     34         * @var array
     35         */
     36        private $iterations = array();
     37
     38        /**
     39         * The current priority of actively running iterations of a hook.
     40         *
     41         * @since 4.7.0
     42         * @access private
     43         * @var array
     44         */
     45        private $current_priority = array();
     46
     47        /**
     48         * Number of levels this hook can be recursively called.
     49         *
     50         * @since 4.7.0
     51         * @access private
     52         * @var int
     53         */
     54        private $nesting_level = 0;
     55
     56        /**
     57         * Flag for if we're current doing an action, rather than a filter.
     58         *
     59         * @since 4.7.0
     60         * @access private
     61         * @var boolean
     62         */
     63        private $doing_action = false;
     64
     65        /**
     66         * Hooks a function or method to a specific filter action.
     67         *
     68         * @since 4.7.0
     69         * @access public
     70         *
     71         * @param string   $tag             The name of the filter to hook the $function_to_add callback to.
     72         * @param callable $function_to_add The callback to be run when the filter is applied.
     73         * @param int      $priority        The order in which the functions associated with a
     74         *                                  particular action are executed. Lower numbers correspond with
     75         *                                  earlier execution, and functions with the same priority are executed
     76         *                                  in the order in which they were added to the action.
     77         * @param int      $accepted_args   The number of arguments the function accepts.
     78         */
     79        public function add_filter( $tag, $function_to_add, $priority, $accepted_args ) {
     80                $idx = _wp_filter_build_unique_id( $tag, $function_to_add, $priority );
     81                $priority_existed = isset( $this->callbacks[ $priority ] );
     82
     83                $this->callbacks[ $priority ][ $idx ] = array(
     84                        'function' => $function_to_add,
     85                        'accepted_args' => $accepted_args
     86                );
     87
     88                // if we're adding a new priority to the list, put them back in sorted order
     89                if ( ! $priority_existed && count( $this->callbacks ) > 1 ) {
     90                        ksort( $this->callbacks, SORT_NUMERIC );
     91                }
     92
     93                if ( $this->nesting_level > 0 ) {
     94                        $this->resort_active_iterations( $priority, $priority_existed );
     95                }
     96        }
     97
     98        /**
     99         * Handles reseting callback priority keys mid-iteration.
     100         *
     101         * @since 4.7.0
     102         * @access private
     103         *
     104         * @param bool|int $new_priority      The priority of the new filter being added. Default false, for no priority being added.
     105         * @param bool     $priority_existed  Flag for whether the priority already existed before the new filter was added.
     106         */
     107        private function resort_active_iterations( $new_priority = false, $priority_existed = false ) {
     108                $new_priorities = array_keys( $this->callbacks );
     109
     110                // If there are no remaining hooks, clear out all running iterations.
     111                if ( ! $new_priorities ) {
     112                        foreach ( $this->iterations as $index => $iteration ) {
     113                                $this->iterations[ $index ] = $new_priorities;
     114                        }
     115                        return;
     116                }
     117
     118                $min = min( $new_priorities );
     119                foreach ( $this->iterations as $index => &$iteration ) {
     120                        $current = current( $iteration );
     121                        // If we're already at the end of this iteration, just leave the array pointer where it is.
     122                        if ( false === $current ) {
     123                                continue;
     124                        }
     125
     126                        $iteration = $new_priorities;
     127
     128                        if ( $current < $min ) {
     129                                array_unshift( $iteration, $current );
     130                                continue;
     131                        }
     132
     133                        while ( current( $iteration ) < $current ) {
     134                                if ( false === next( $iteration ) ) {
     135                                        break;
     136                                }
     137                        }
     138
     139                        // If we have a new priority that didn't exist, but ::apply_filters() or ::do_action() thinks it's the current priority...
     140                        if ( $new_priority === $this->current_priority[ $index ] && ! $priority_existed ) {
     141                                // ... and the new priority is the same as what $this->iterations thinks is the previous priority,
     142                                // We need to move back to it.
     143
     144                                if ( false === current( $iteration ) ) {
     145                                        // If we've already moved off the end of the array, go back to the last element.
     146                                        $prev = end( $iteration );
     147                                } else {
     148                                        // Otherwise, just go back to the previous element.
     149                                        $prev = prev( $iteration );
     150                                }
     151                                if ( false === $prev ) {
     152                                        // Start of the array. Reset, and go about our day.
     153                                        reset( $iteration );
     154                                } elseif ( $new_priority !== $prev ) {
     155                                        // Previous wasn't the same. Move forward again.
     156                                        next( $iteration );
     157                                }
     158                        }
     159                }
     160                unset( $iteration );
     161        }
     162
     163        /**
     164         * Unhooks a function or method from a specific filter action.
     165         *
     166         * @since 4.7.0
     167         * @access public
     168         *
     169         * @param string   $tag                The filter hook to which the function to be removed is hooked. Used
     170         *                                     for building the callback ID when SPL is not available.
     171         * @param callable $function_to_remove The callback to be removed from running when the filter is applied.
     172         * @param int      $priority           The exact priority used when adding the original filter callback.
     173         * @return bool Whether the callback existed before it was removed.
     174         */
     175        public function remove_filter( $tag, $function_to_remove, $priority ) {
     176                $function_key = _wp_filter_build_unique_id( $tag, $function_to_remove, $priority );
     177
     178                $exists = isset( $this->callbacks[ $priority ][ $function_key ] );
     179                if ( $exists ) {
     180                        unset( $this->callbacks[ $priority ][ $function_key ] );
     181                        if ( ! $this->callbacks[ $priority ] ) {
     182                                unset( $this->callbacks[ $priority ] );
     183                                if ( $this->nesting_level > 0 ) {
     184                                        $this->resort_active_iterations();
     185                                }
     186                        }
     187                }
     188                return $exists;
     189        }
     190
     191        /**
     192         * Checks if a specific action has been registered for this hook.
     193         *
     194         * @since 4.7.0
     195         * @access public
     196         *
     197         * @param callable|bool $function_to_check Optional. The callback to check for. Default false.
     198         * @param string        $tag               Optional. The name of the filter hook. Default empty.
     199         *                                         Used for building the callback ID when SPL is not available.
     200         * @return bool|int The priority of that hook is returned, or false if the function is not attached.
     201         */
     202        public function has_filter( $tag = '', $function_to_check = false ) {
     203                if ( false === $function_to_check ) {
     204                        return $this->has_filters();
     205                }
     206
     207                $function_key = _wp_filter_build_unique_id( $tag, $function_to_check, false );
     208                if ( ! $function_key ) {
     209                        return false;
     210                }
     211
     212                foreach ( $this->callbacks as $priority => $callbacks ) {
     213                        if ( isset( $callbacks[ $function_key ] ) ) {
     214                                return $priority;
     215                        }
     216                }
     217
     218                return false;
     219        }
     220
     221        /**
     222         * Checks if any callbacks have been registered for this hook.
     223         *
     224         * @since 4.7.0
     225         * @access public
     226         *
     227         * @return bool True if callbacks have been registered for the current hook, false otherwise.
     228         */
     229        public function has_filters() {
     230                foreach ( $this->callbacks as $callbacks ) {
     231                        if ( $callbacks ) {
     232                                return true;
     233                        }
     234                }
     235                return false;
     236        }
     237
     238        /**
     239         * Removes all callbacks from the current filter.
     240         *
     241         * @since 4.7.0
     242         * @access public
     243         *
     244         * @param int|bool $priority Optional. The priority number to remove. Default false.
     245         */
     246        public function remove_all_filters( $priority = false ) {
     247                if ( ! $this->callbacks ) {
     248                        return;
     249                }
     250
     251                if ( false === $priority ) {
     252                        $this->callbacks = array();
     253                } else if ( isset( $this->callbacks[ $priority ] ) ) {
     254                        unset( $this->callbacks[ $priority ] );
     255                }
     256
     257                if ( $this->nesting_level > 0 ) {
     258                        $this->resort_active_iterations();
     259                }
     260        }
     261
     262        /**
     263         * Calls the callback functions added to a filter hook.
     264         *
     265         * @since 4.7.0
     266         * @access public
     267         *
     268         * @param mixed $value The value to filter.
     269         * @param array $args  Arguments to pass to callbacks.
     270         * @return mixed The filtered value after all hooked functions are applied to it.
     271         */
     272        public function apply_filters( $value, $args ) {
     273                if ( ! $this->callbacks ) {
     274                        return $value;
     275                }
     276
     277                $nesting_level = $this->nesting_level++;
     278
     279                $this->iterations[ $nesting_level ] = array_keys( $this->callbacks );
     280                $num_args = count( $args );
     281
     282                do {
     283                        $this->current_priority[ $nesting_level ] = $priority = current( $this->iterations[ $nesting_level ] );
     284
     285                        foreach ( $this->callbacks[ $priority ] as $the_ ) {
     286                                if( ! $this->doing_action ) {
     287                                        $args[ 0 ] = $value;
     288                                }
     289
     290                                // Avoid the array_slice if possible.
     291                                if ( $the_['accepted_args'] == 0 ) {
     292                                        $value = call_user_func_array( $the_['function'], array() );
     293                                } elseif ( $the_['accepted_args'] >= $num_args ) {
     294                                        $value = call_user_func_array( $the_['function'], $args );
     295                                } else {
     296                                        $value = call_user_func_array( $the_['function'], array_slice( $args, 0, (int)$the_['accepted_args'] ) );
     297                                }
     298                        }
     299                } while ( false !== next( $this->iterations[ $nesting_level ] ) );
     300
     301                unset( $this->iterations[ $nesting_level ] );
     302                unset( $this->current_priority[ $nesting_level ] );
     303
     304                $this->nesting_level--;
     305
     306                return $value;
     307        }
     308
     309        /**
     310         * Executes the callback functions hooked on a specific action hook.
     311         *
     312         * @since 4.7.0
     313         * @access public
     314         *
     315         * @param mixed $args Arguments to pass to the hook callbacks.
     316         */
     317        public function do_action( $args ) {
     318                $this->doing_action = true;
     319                $this->apply_filters( '', $args );
     320                $this->doing_action = false;
     321        }
     322
     323        /**
     324         * Processes the functions hooked into the 'all' hook.
     325         *
     326         * @since 4.7.0
     327         * @access public
     328         *
     329         * @param array $args Arguments to pass to the hook callbacks. Passed by reference.
     330         */
     331        public function do_all_hook( &$args ) {
     332                $nesting_level = $this->nesting_level++;
     333                $this->iterations[ $nesting_level ] = array_keys( $this->callbacks );
     334
     335                do {
     336                        $priority = current( $this->iterations[ $nesting_level ] );
     337                        foreach ( $this->callbacks[ $priority ] as $the_ ) {
     338                                call_user_func_array( $the_['function'], $args );
     339                        }
     340                } while ( false !== next( $this->iterations[ $nesting_level ] ) );
     341
     342                unset( $this->iterations[ $nesting_level ] );
     343                $this->nesting_level--;
     344        }
     345
     346        /**
     347         * Normalizes filters setup before WordPress has initialized to WP_Hook objects.
     348         *
     349         * @since 4.7.0
     350         * @access public
     351         * @static
     352         *
     353         * @param array $filters Filters to normalize.
     354         * @return WP_Hook[] Array of normalized filters.
     355         */
     356        public static function build_preinitialized_hooks( $filters ) {
     357                /** @var WP_Hook[] $normalized */
     358                $normalized = array();
     359
     360                foreach ( $filters as $tag => $callback_groups ) {
     361                        if ( is_object( $callback_groups ) && $callback_groups instanceof WP_Hook ) {
     362                                $normalized[ $tag ] = $callback_groups;
     363                                continue;
     364                        }
     365                        $hook = new WP_Hook();
     366
     367                        // Loop through callback groups.
     368                        foreach ( $callback_groups as $priority => $callbacks ) {
     369
     370                                // Loop through callbacks.
     371                                foreach ( $callbacks as $cb ) {
     372                                        $hook->add_filter( $tag, $cb['function'], $priority, $cb['accepted_args'] );
     373                                }
     374                        }
     375                        $normalized[ $tag ] = $hook;
     376                }
     377                return $normalized;
     378        }
     379
     380        /**
     381         * Determines whether an offset value exists.
     382         *
     383         * @since 4.7.0
     384         * @access public
     385         *
     386         * @link http://php.net/manual/en/arrayaccess.offsetexists.php
     387         *
     388         * @param mixed $offset An offset to check for.
     389         * @return bool True if the offset exists, false otherwise.
     390         */
     391        public function offsetExists( $offset ) {
     392                return isset( $this->callbacks[ $offset ] );
     393        }
     394
     395        /**
     396         * Retrieves a value at a specified offset.
     397         *
     398         * @since 4.7.0
     399         * @access public
     400         *
     401         * @link http://php.net/manual/en/arrayaccess.offsetget.php
     402         *
     403         * @param mixed $offset The offset to retrieve.
     404         * @return mixed If set, the value at the specified offset, null otherwise.
     405         */
     406        public function offsetGet( $offset ) {
     407                return isset( $this->callbacks[ $offset ] ) ? $this->callbacks[ $offset ] : null;
     408        }
     409
     410        /**
     411         * Sets a value at a specified offset.
     412         *
     413         * @since 4.7.0
     414         * @access public
     415         *
     416         * @link http://php.net/manual/en/arrayaccess.offsetset.php
     417         *
     418         * @param mixed $offset The offset to assign the value to.
     419         * @param mixed $value The value to set.
     420         */
     421        public function offsetSet( $offset, $value ) {
     422                if ( is_null( $offset ) ) {
     423                        $this->callbacks[] = $value;
     424                } else {
     425                        $this->callbacks[ $offset ] = $value;
     426                }
     427        }
     428
     429        /**
     430         * Unsets a specified offset.
     431         *
     432         * @since 4.7.0
     433         * @access public
     434         *
     435         * @link http://php.net/manual/en/arrayaccess.offsetunset.php
     436         *
     437         * @param mixed $offset The offset to unset.
     438         */
     439        public function offsetUnset( $offset ) {
     440                unset( $this->callbacks[ $offset ] );
     441        }
     442
     443        /**
     444         * Return the current element
     445         *
     446         * @since 4.7.0
     447         * @access public
     448         *
     449         * @link http://php.net/manual/en/iterator.current.php
     450         *
     451         * @return mixed
     452         */
     453        public function current() {
     454                return current( $this->callbacks );
     455        }
     456
     457        /**
     458         * Move forward to the next element
     459         *
     460         * @since 4.7.0
     461         * @access public
     462         *
     463         * @link http://php.net/manual/en/iterator.next.php
     464         */
     465        public function next() {
     466                return next( $this->callbacks );
     467        }
     468
     469        /**
     470         * Return the key of the current element
     471         *
     472         * @since 4.7.0
     473         * @access public
     474         *
     475         * @link http://php.net/manual/en/iterator.key.php
     476         *
     477         * @return mixed Returns scalar on success, or NULL on failure
     478         */
     479        public function key() {
     480                return key( $this->callbacks );
     481        }
     482
     483        /**
     484         * Checks if current position is valid
     485         *
     486         * @since 4.7.0
     487         * @access public
     488         *
     489         * @link http://php.net/manual/en/iterator.valid.php
     490         *
     491         * @return boolean
     492         */
     493        public function valid() {
     494                return key( $this->callbacks ) !== null;
     495        }
     496
     497        /**
     498         * Rewind the Iterator to the first element
     499         *
     500         * @since 4.7.0
     501         * @access public
     502         *
     503         * @link http://php.net/manual/en/iterator.rewind.php
     504         */
     505        public function rewind() {
     506                return reset( $this->callbacks );
     507        }
     508
     509
     510}
  • src/wp-includes/plugin.php

    Property changes on: src/wp-includes/class-wp-hook.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
    2222 */
    2323
    2424// Initialize the filter globals.
    25 global $wp_filter, $wp_actions, $merged_filters, $wp_current_filter;
     25require( ABSPATH . WPINC . '/class-wp-hook.php' );
    2626
    27 if ( ! isset( $wp_filter ) )
     27/** @var WP_Hook[] $wp_filter */
     28global $wp_filter, $wp_actions, $wp_current_filter;
     29
     30if ( $wp_filter ) {
     31        $wp_filter = WP_Hook::build_preinitialized_hooks( $wp_filter );
     32} else {
    2833        $wp_filter = array();
     34}
    2935
    3036if ( ! isset( $wp_actions ) )
    3137        $wp_actions = array();
    3238
    33 if ( ! isset( $merged_filters ) )
    34         $merged_filters = array();
    35 
    3639if ( ! isset( $wp_current_filter ) )
    3740        $wp_current_filter = array();
    3841
     
    8992 * @since 0.71
    9093 *
    9194 * @global array $wp_filter      A multidimensional array of all hooks and the callbacks hooked to them.
    92  * @global array $merged_filters Tracks the tags that need to be merged for later. If the hook is added,
    93  *                               it doesn't need to run through that process.
    9495 *
    9596 * @param string   $tag             The name of the filter to hook the $function_to_add callback to.
    9697 * @param callable $function_to_add The callback to be run when the filter is applied.
     
    103104 * @return true
    104105 */
    105106function add_filter( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
    106         global $wp_filter, $merged_filters;
    107 
    108         $idx = _wp_filter_build_unique_id($tag, $function_to_add, $priority);
    109         $wp_filter[$tag][$priority][$idx] = array('function' => $function_to_add, 'accepted_args' => $accepted_args);
    110         unset( $merged_filters[ $tag ] );
     107        global $wp_filter;
     108        if ( ! isset( $wp_filter[ $tag ] ) ) {
     109                $wp_filter[ $tag ] = new WP_Hook();
     110        }
     111        $wp_filter[ $tag ]->add_filter( $tag, $function_to_add, $priority, $accepted_args );
    111112        return true;
    112113}
    113114
     
    128129 *                   return value.
    129130 */
    130131function has_filter($tag, $function_to_check = false) {
    131         // Don't reset the internal array pointer
    132         $wp_filter = $GLOBALS['wp_filter'];
    133 
    134         $has = ! empty( $wp_filter[ $tag ] );
    135 
    136         // Make sure at least one priority has a filter callback
    137         if ( $has ) {
    138                 $exists = false;
    139                 foreach ( $wp_filter[ $tag ] as $callbacks ) {
    140                         if ( ! empty( $callbacks ) ) {
    141                                 $exists = true;
    142                                 break;
    143                         }
    144                 }
    145 
    146                 if ( ! $exists ) {
    147                         $has = false;
    148                 }
    149         }
    150 
    151         if ( false === $function_to_check || false === $has )
    152                 return $has;
     132        global $wp_filter;
    153133
    154         if ( !$idx = _wp_filter_build_unique_id($tag, $function_to_check, false) )
     134        if ( ! isset( $wp_filter[ $tag ] ) ) {
    155135                return false;
    156 
    157         foreach ( (array) array_keys($wp_filter[$tag]) as $priority ) {
    158                 if ( isset($wp_filter[$tag][$priority][$idx]) )
    159                         return $priority;
    160136        }
    161137
    162         return false;
     138        return $wp_filter[ $tag ]->has_filter( $tag, $function_to_check );
    163139}
    164140
    165141/**
     
    190166 * @since 0.71
    191167 *
    192168 * @global array $wp_filter         Stores all of the filters.
    193  * @global array $merged_filters    Merges the filter hooks using this function.
    194169 * @global array $wp_current_filter Stores the list of current filters with the current one last.
    195170 *
    196171 * @param string $tag     The name of the filter hook.
     
    199174 * @return mixed The filtered value after all hooked functions are applied to it.
    200175 */
    201176function apply_filters( $tag, $value ) {
    202         global $wp_filter, $merged_filters, $wp_current_filter;
     177        global $wp_filter, $wp_current_filter;
    203178
    204179        $args = array();
    205180
     
    219194        if ( !isset($wp_filter['all']) )
    220195                $wp_current_filter[] = $tag;
    221196
    222         // Sort.
    223         if ( !isset( $merged_filters[ $tag ] ) ) {
    224                 ksort($wp_filter[$tag]);
    225                 $merged_filters[ $tag ] = true;
    226         }
    227 
    228         reset( $wp_filter[ $tag ] );
    229 
    230197        if ( empty($args) )
    231198                $args = func_get_args();
    232199
    233         do {
    234                 foreach ( (array) current($wp_filter[$tag]) as $the_ )
    235                         if ( !is_null($the_['function']) ){
    236                                 $args[1] = $value;
    237                                 $value = call_user_func_array($the_['function'], array_slice($args, 1, (int) $the_['accepted_args']));
    238                         }
     200        // don't pass the tag name to WP_Hook
     201        array_shift( $args );
    239202
    240         } while ( next($wp_filter[$tag]) !== false );
     203        $filtered = $wp_filter[ $tag ]->apply_filters( $value, $args );
    241204
    242205        array_pop( $wp_current_filter );
    243206
    244         return $value;
     207        return $filtered;
    245208}
    246209
    247210/**
     
    253216 * functions hooked to `$tag` are supplied using an array.
    254217 *
    255218 * @global array $wp_filter         Stores all of the filters
    256  * @global array $merged_filters    Merges the filter hooks using this function.
    257219 * @global array $wp_current_filter Stores the list of current filters with the current one last
    258220 *
    259221 * @param string $tag  The name of the filter hook.
     
    261223 * @return mixed The filtered value after all hooked functions are applied to it.
    262224 */
    263225function apply_filters_ref_array($tag, $args) {
    264         global $wp_filter, $merged_filters, $wp_current_filter;
     226        global $wp_filter, $wp_current_filter;
    265227
    266228        // Do 'all' actions first
    267229        if ( isset($wp_filter['all']) ) {
     
    279241        if ( !isset($wp_filter['all']) )
    280242                $wp_current_filter[] = $tag;
    281243
    282         // Sort
    283         if ( !isset( $merged_filters[ $tag ] ) ) {
    284                 ksort($wp_filter[$tag]);
    285                 $merged_filters[ $tag ] = true;
    286         }
    287 
    288         reset( $wp_filter[ $tag ] );
    289 
    290         do {
    291                 foreach ( (array) current($wp_filter[$tag]) as $the_ )
    292                         if ( !is_null($the_['function']) )
    293                                 $args[0] = call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
    294 
    295         } while ( next($wp_filter[$tag]) !== false );
     244        $filtered = $wp_filter[ $tag ]->apply_filters( $args[0], $args );
    296245
    297246        array_pop( $wp_current_filter );
    298247
    299         return $args[0];
     248        return $filtered;
    300249}
    301250
    302251/**
     
    313262 * @since 1.2.0
    314263 *
    315264 * @global array $wp_filter         Stores all of the filters
    316  * @global array $merged_filters    Merges the filter hooks using this function.
    317265 *
    318266 * @param string   $tag                The filter hook to which the function to be removed is hooked.
    319267 * @param callable $function_to_remove The name of the function which should be removed.
     
    321269 * @return bool    Whether the function existed before it was removed.
    322270 */
    323271function remove_filter( $tag, $function_to_remove, $priority = 10 ) {
    324         $function_to_remove = _wp_filter_build_unique_id( $tag, $function_to_remove, $priority );
    325 
    326         $r = isset( $GLOBALS['wp_filter'][ $tag ][ $priority ][ $function_to_remove ] );
     272        global $wp_filter;
    327273
    328         if ( true === $r ) {
    329                 unset( $GLOBALS['wp_filter'][ $tag ][ $priority ][ $function_to_remove ] );
    330                 if ( empty( $GLOBALS['wp_filter'][ $tag ][ $priority ] ) ) {
    331                         unset( $GLOBALS['wp_filter'][ $tag ][ $priority ] );
     274        $r = false;
     275        if ( isset( $wp_filter[ $tag ] ) ) {
     276                $r = $wp_filter[ $tag ]->remove_filter( $tag, $function_to_remove, $priority );
     277                if ( ! $wp_filter[ $tag ]->callbacks ) {
     278                        unset( $wp_filter[ $tag ] );
    332279                }
    333                 if ( empty( $GLOBALS['wp_filter'][ $tag ] ) ) {
    334                         $GLOBALS['wp_filter'][ $tag ] = array();
    335                 }
    336                 unset( $GLOBALS['merged_filters'][ $tag ] );
    337280        }
    338281
    339282        return $r;
     
    344287 *
    345288 * @since 2.7.0
    346289 *
    347  * @global array $wp_filter         Stores all of the filters
    348  * @global array $merged_filters    Merges the filter hooks using this function.
     290 * @global array $wp_filter  Stores all of the filters
    349291 *
    350292 * @param string   $tag      The filter to remove hooks from.
    351293 * @param int|bool $priority Optional. The priority number to remove. Default false.
    352294 * @return true True when finished.
    353295 */
    354296function remove_all_filters( $tag, $priority = false ) {
    355         global $wp_filter, $merged_filters;
     297        global $wp_filter;
    356298
    357299        if ( isset( $wp_filter[ $tag ]) ) {
    358                 if ( false === $priority ) {
    359                         $wp_filter[ $tag ] = array();
    360                 } elseif ( isset( $wp_filter[ $tag ][ $priority ] ) ) {
    361                         $wp_filter[ $tag ][ $priority ] = array();
     300                $wp_filter[ $tag ]->remove_all_filters( $priority );
     301                if ( ! $wp_filter[ $tag ]->has_filters() ) {
     302                        unset( $wp_filter[ $tag ] );
    362303                }
    363304        }
    364305
    365         unset( $merged_filters[ $tag ] );
    366 
    367306        return true;
    368307}
    369308
     
    473412 *
    474413 * @global array $wp_filter         Stores all of the filters
    475414 * @global array $wp_actions        Increments the amount of times action was triggered.
    476  * @global array $merged_filters    Merges the filter hooks using this function.
    477415 * @global array $wp_current_filter Stores the list of current filters with the current one last
    478416 *
    479417 * @param string $tag     The name of the action to be executed.
     
    481419 *                        functions hooked to the action. Default empty.
    482420 */
    483421function do_action($tag, $arg = '') {
    484         global $wp_filter, $wp_actions, $merged_filters, $wp_current_filter;
     422        global $wp_filter, $wp_actions, $wp_current_filter;
    485423
    486424        if ( ! isset($wp_actions[$tag]) )
    487425                $wp_actions[$tag] = 1;
     
    512450        for ( $a = 2, $num = func_num_args(); $a < $num; $a++ )
    513451                $args[] = func_get_arg($a);
    514452
    515         // Sort
    516         if ( !isset( $merged_filters[ $tag ] ) ) {
    517                 ksort($wp_filter[$tag]);
    518                 $merged_filters[ $tag ] = true;
    519         }
    520 
    521         reset( $wp_filter[ $tag ] );
    522 
    523         do {
    524                 foreach ( (array) current($wp_filter[$tag]) as $the_ )
    525                         if ( !is_null($the_['function']) )
    526                                 call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
    527 
    528         } while ( next($wp_filter[$tag]) !== false );
     453        $wp_filter[ $tag ]->do_action( $args );
    529454
    530455        array_pop($wp_current_filter);
    531456}
     
    558483 *                  functions hooked to $tag< are supplied using an array.
    559484 * @global array $wp_filter         Stores all of the filters
    560485 * @global array $wp_actions        Increments the amount of times action was triggered.
    561  * @global array $merged_filters    Merges the filter hooks using this function.
    562486 * @global array $wp_current_filter Stores the list of current filters with the current one last
    563487 *
    564488 * @param string $tag  The name of the action to be executed.
    565489 * @param array  $args The arguments supplied to the functions hooked to `$tag`.
    566490 */
    567491function do_action_ref_array($tag, $args) {
    568         global $wp_filter, $wp_actions, $merged_filters, $wp_current_filter;
     492        global $wp_filter, $wp_actions, $wp_current_filter;
    569493
    570494        if ( ! isset($wp_actions[$tag]) )
    571495                $wp_actions[$tag] = 1;
     
    588512        if ( !isset($wp_filter['all']) )
    589513                $wp_current_filter[] = $tag;
    590514
    591         // Sort
    592         if ( !isset( $merged_filters[ $tag ] ) ) {
    593                 ksort($wp_filter[$tag]);
    594                 $merged_filters[ $tag ] = true;
    595         }
    596 
    597         reset( $wp_filter[ $tag ] );
    598 
    599         do {
    600                 foreach ( (array) current($wp_filter[$tag]) as $the_ )
    601                         if ( !is_null($the_['function']) )
    602                                 call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
    603 
    604         } while ( next($wp_filter[$tag]) !== false );
     515        $wp_filter[ $tag ]->do_action( $args );
    605516
    606517        array_pop($wp_current_filter);
    607518}
     
    923834function _wp_call_all_hook($args) {
    924835        global $wp_filter;
    925836
    926         reset( $wp_filter['all'] );
    927         do {
    928                 foreach ( (array) current($wp_filter['all']) as $the_ )
    929                         if ( !is_null($the_['function']) )
    930                                 call_user_func_array($the_['function'], $args);
    931 
    932         } while ( next($wp_filter['all']) !== false );
     837        $wp_filter['all']->do_all_hook( $args );
    933838}
    934839
    935840/**
  • tests/phpunit/includes/functions.php

     
    2121
    2222// For adding hooks before loading WP
    2323function tests_add_filter($tag, $function_to_add, $priority = 10, $accepted_args = 1) {
    24         global $wp_filter, $merged_filters;
     24        global $wp_filter;
    2525
    2626        $idx = _test_filter_build_unique_id($tag, $function_to_add, $priority);
    2727        $wp_filter[$tag][$priority][$idx] = array('function' => $function_to_add, 'accepted_args' => $accepted_args);
    28         unset( $merged_filters[ $tag ] );
    2928        return true;
    3029}
    3130
    3231function _test_filter_build_unique_id($tag, $function, $priority) {
    33         global $wp_filter;
    34         static $filter_id_count = 0;
    35 
    3632        if ( is_string($function) )
    3733                return $function;
    3834
  • tests/phpunit/includes/testcase.php

     
    223223         * @return void
    224224         */
    225225        protected function _backup_hooks() {
    226                 $globals = array( 'merged_filters', 'wp_actions', 'wp_current_filter', 'wp_filter' );
     226                $globals = array( 'wp_actions', 'wp_current_filter' );
    227227                foreach ( $globals as $key ) {
    228228                        self::$hooks_saved[ $key ] = $GLOBALS[ $key ];
    229229                }
     230                self::$hooks_saved['wp_filter'] = array();
     231                foreach ( $GLOBALS['wp_filter'] as $hook_name => $hook_object ) {
     232                        self::$hooks_saved['wp_filter'][ $hook_name ] = clone $hook_object;
     233                }
    230234        }
    231235
    232236        /**
     
    240244         * @return void
    241245         */
    242246        protected function _restore_hooks() {
    243                 $globals = array( 'merged_filters', 'wp_actions', 'wp_current_filter', 'wp_filter' );
     247                $globals = array( 'wp_actions', 'wp_current_filter' );
    244248                foreach ( $globals as $key ) {
    245249                        if ( isset( self::$hooks_saved[ $key ] ) ) {
    246250                                $GLOBALS[ $key ] = self::$hooks_saved[ $key ];
    247251                        }
    248252                }
     253                if ( isset( self::$hooks_saved['wp_filter'] ) ) {
     254                        $GLOBALS['wp_filter'] = array();
     255                        foreach ( self::$hooks_saved['wp_filter'] as $hook_name => $hook_object ) {
     256                                $GLOBALS['wp_filter'][ $hook_name ] = clone $hook_object;
     257                        }
     258                }
    249259        }
    250260
    251261        static function flush_cache() {
  • tests/phpunit/tests/actions.php

     
    114114                $this->assertEquals( array( $val1 ), array_pop( $argsvar2 ) );
    115115        }
    116116
     117        /**
     118         * Test that multiple callbacks receive the correct number of args even when the number
     119         * is less than, or greater than previous hooks.
     120         *
     121         * @see https://core.trac.wordpress.org/ticket/17817#comment:72
     122         * @ticket 17817
     123         */
     124        function test_action_args_3() {
     125                $a1 = new MockAction();
     126                $a2 = new MockAction();
     127                $a3 = new MockAction();
     128                $tag = rand_str();
     129                $val1 = rand_str();
     130                $val2 = rand_str();
     131
     132                // a1 accepts two arguments, a2 doesn't, a3 accepts two arguments
     133                add_action( $tag, array( &$a1, 'action' ), 10, 2 );
     134                add_action( $tag, array( &$a2, 'action' ) );
     135                add_action( $tag, array( &$a3, 'action' ), 10, 2 );
     136                // call the action with two arguments
     137                do_action( $tag, $val1, $val2 );
     138
     139                $call_count = $a1->get_call_count();
     140                // a1 should be called with both args
     141                $this->assertEquals( 1, $call_count );
     142                $argsvar1 = $a1->get_args();
     143                $this->assertEquals( array( $val1, $val2 ), array_pop( $argsvar1 ) );
     144
     145                // a2 should be called with one only
     146                $this->assertEquals( 1, $a2->get_call_count() );
     147                $argsvar2 = $a2->get_args();
     148                $this->assertEquals( array( $val1 ), array_pop( $argsvar2 ) );
     149
     150                // a3 should be called with both args
     151                $this->assertEquals( 1, $a3->get_call_count() );
     152                $argsvar3 = $a3->get_args();
     153                $this->assertEquals( array( $val1, $val2 ), array_pop( $argsvar3 ) );
     154        }
     155
    117156        function test_action_priority() {
    118157                $a = new MockAction();
    119158                $tag = rand_str();
     
    258297        }
    259298
    260299        /**
     300         * @ticket 17817
     301         */
     302        function test_action_recursion() {
     303                $tag = rand_str();
     304                $a = new MockAction();
     305                $b = new MockAction();
     306
     307                add_action( $tag, array( $a, 'action' ), 11, 1 );
     308                add_action( $tag, array( $b, 'action' ), 13, 1 );
     309                add_action( $tag, array( $this, 'action_that_causes_recursion' ), 12, 1 );
     310                do_action( $tag, $tag );
     311
     312                $this->assertEquals( 2, $a->get_call_count(), 'recursive actions should call all callbacks with earlier priority' );
     313                $this->assertEquals( 2, $b->get_call_count(), 'recursive actions should call callbacks with later priority' );
     314        }
     315
     316        function action_that_causes_recursion( $tag ) {
     317                static $recursing = false;
     318                if ( ! $recursing ) {
     319                        $recursing = true;
     320                        do_action( $tag, $tag );
     321                }
     322                $recursing = false;
     323        }
     324
     325        /**
     326         * @ticket 9968
     327         * @ticket 17817
     328         */
     329        function test_action_callback_manipulation_while_running() {
     330                $tag = rand_str();
     331                $a = new MockAction();
     332                $b = new MockAction();
     333                $c = new MockAction();
     334                $d = new MockAction();
     335                $e = new MockAction();
     336
     337                add_action( $tag, array( $a, 'action' ), 11, 2 );
     338                add_action( $tag, array( $this, 'action_that_manipulates_a_running_hook' ), 12, 2 );
     339                add_action( $tag, array( $b, 'action' ), 12, 2 );
     340
     341                do_action( $tag, $tag, array( $a, $b, $c, $d, $e ) );
     342                do_action( $tag, $tag, array( $a, $b, $c, $d, $e ) );
     343
     344                $this->assertEquals( 2, $a->get_call_count(), 'callbacks should run unless otherwise instructed' );
     345                $this->assertEquals( 1, $b->get_call_count(), 'callback removed by same priority callback should still get called' );
     346                $this->assertEquals( 1, $c->get_call_count(), 'callback added by same priority callback should not get called' );
     347                $this->assertEquals( 2, $d->get_call_count(), 'callback added by earlier priority callback should get called' );
     348                $this->assertEquals( 1, $e->get_call_count(), 'callback added by later priority callback should not get called' );
     349        }
     350
     351        function action_that_manipulates_a_running_hook( $tag, $mocks ) {
     352                remove_action( $tag, array( $mocks[ 1 ], 'action' ), 12, 2 );
     353                add_action( $tag, array( $mocks[ 2 ], 'action' ), 12, 2 );
     354                add_action( $tag, array( $mocks[ 3 ], 'action' ), 13, 2 );
     355                add_action( $tag, array( $mocks[ 4 ], 'action' ), 10, 2 );
     356        }
     357
     358        /**
     359         * @ticket 17817
     360         *
     361         * This specificaly addresses the concern raised at
     362         * https://core.trac.wordpress.org/ticket/17817#comment:52
     363         */
     364        function test_remove_anonymous_callback() {
     365                $tag = rand_str();
     366                $a = new MockAction();
     367                add_action( $tag, array( $a, 'action' ), 12, 1 );
     368                $this->assertTrue( has_action( $tag ) );
     369
     370                $hook = $GLOBALS['wp_filter'][ $tag ];
     371
     372                // From http://wordpress.stackexchange.com/a/57088/6445
     373                foreach ( $hook as $priority => $filter ) {
     374                        foreach ( $filter as $identifier => $function ) {
     375                                if ( is_array( $function )
     376                                        && is_a( $function['function'][ 0 ], 'MockAction' )
     377                                        && 'action' === $function['function'][ 1 ]
     378                                ) {
     379                                        remove_filter(
     380                                                $tag,
     381                                                array( $function['function'][ 0 ], 'action' ),
     382                                                $priority
     383                                        );
     384                                }
     385                        }
     386                }
     387
     388                $this->assertFalse( has_action( $tag ) );
     389        }
     390
     391
     392        /**
     393         * Test the ArrayAccess methods of WP_Hook
     394         *
     395         * @ticket 17817
     396         */
     397        function test_array_access_of_wp_filter_global() {
     398                global $wp_filter;
     399                $tag = rand_str();
     400
     401                add_action( $tag, '__return_null', 11, 1 );
     402
     403                $this->assertTrue( isset( $wp_filter[ $tag ][ 11 ] ) );
     404                $this->assertArrayHasKey( '__return_null', $wp_filter[ $tag ][ 11 ] );
     405
     406                unset( $wp_filter[ $tag ][ 11 ] );
     407                $this->assertFalse( has_action( $tag, '__return_null' ) );
     408
     409                $wp_filter[ $tag ][ 11 ] = array( '__return_null' => array( 'function' => '__return_null', 'accepted_args' => 1 ) );
     410                $this->assertEquals( 11, has_action( $tag, '__return_null' ) );
     411        }
     412
     413        /**
    261414         * Make sure current_action() behaves as current_filter()
    262415         *
    263416         * @ticket 14994
  • tests/phpunit/tests/filters.php

     
    296296        }
    297297
    298298        /**
    299          * @ticket 29070
    300          */
    301          function test_has_filter_doesnt_reset_wp_filter() {
    302                 add_action( 'action_test_has_filter_doesnt_reset_wp_filter', '__return_null', 1 );
    303                 add_action( 'action_test_has_filter_doesnt_reset_wp_filter', '__return_null', 2 );
    304                 add_action( 'action_test_has_filter_doesnt_reset_wp_filter', '__return_null', 3 );
    305                 add_action( 'action_test_has_filter_doesnt_reset_wp_filter', array( $this, '_action_test_has_filter_doesnt_reset_wp_filter' ), 4 );
    306 
    307                 do_action( 'action_test_has_filter_doesnt_reset_wp_filter' );
    308          }
    309          function _action_test_has_filter_doesnt_reset_wp_filter() {
    310                 global $wp_filter;
    311 
    312                 has_action( 'action_test_has_filter_doesnt_reset_wp_filter', '_function_that_doesnt_exist' );
    313 
    314                 $filters = current( $wp_filter['action_test_has_filter_doesnt_reset_wp_filter'] );
    315                 $the_ = current( $filters );
    316                 $this->assertEquals( $the_['function'], array( $this, '_action_test_has_filter_doesnt_reset_wp_filter' ) );
    317          }
    318 
    319         /**
    320299         * @ticket 10441
    321300         * @expectedDeprecated tests_apply_filters_deprecated
    322301         */
  • tests/phpunit/tests/hooks/add_filter.php

     
     1<?php
     2
     3
     4/**
     5 * Test the add_filter method of WP_Hook
     6 *
     7 * @group hooks
     8 */
     9class Tests_WP_Hook_Add_Filter extends WP_UnitTestCase {
     10
     11        public $hook;
     12
     13        public function test_add_filter_with_function() {
     14                $callback = '__return_null';
     15                $hook = new WP_Hook();
     16                $tag = rand_str();
     17                $priority = rand( 1, 100 );
     18                $accepted_args = rand( 1, 100 );
     19
     20                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     21
     22                $function_index = _wp_filter_build_unique_id( $tag, $callback, $priority );
     23                $this->assertEquals( $callback, $hook->callbacks[ $priority ][ $function_index ]['function'] );
     24                $this->assertEquals( $accepted_args, $hook->callbacks[ $priority ][ $function_index ]['accepted_args'] );
     25        }
     26
     27        public function test_add_filter_with_object() {
     28                $a = new MockAction();
     29                $callback = array( $a, 'action' );
     30                $hook = new WP_Hook();
     31                $tag = rand_str();
     32                $priority = rand( 1, 100 );
     33                $accepted_args = rand( 1, 100 );
     34
     35                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     36
     37                $function_index = _wp_filter_build_unique_id( $tag, $callback, $priority );
     38                $this->assertEquals( $callback, $hook->callbacks[ $priority ][ $function_index ]['function'] );
     39                $this->assertEquals( $accepted_args, $hook->callbacks[ $priority ][ $function_index ]['accepted_args'] );
     40        }
     41
     42        public function test_add_filter_with_static_method() {
     43                $callback = array( 'MockAction', 'action' );
     44                $hook = new WP_Hook();
     45                $tag = rand_str();
     46                $priority = rand( 1, 100 );
     47                $accepted_args = rand( 1, 100 );
     48
     49                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     50
     51                $function_index = _wp_filter_build_unique_id( $tag, $callback, $priority );
     52                $this->assertEquals( $callback, $hook->callbacks[ $priority ][ $function_index ]['function'] );
     53                $this->assertEquals( $accepted_args, $hook->callbacks[ $priority ][ $function_index ]['accepted_args'] );
     54        }
     55
     56        public function test_add_two_filters_with_same_priority() {
     57                $callback_one = '__return_null';
     58                $callback_two = '__return_false';
     59                $hook = new WP_Hook();
     60                $tag = rand_str();
     61                $priority = rand( 1, 100 );
     62                $accepted_args = rand( 1, 100 );
     63
     64                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     65                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     66
     67                $hook->add_filter( $tag, $callback_two, $priority, $accepted_args );
     68                $this->assertCount( 2, $hook->callbacks[ $priority ] );
     69        }
     70
     71        public function test_add_two_filters_with_different_priority() {
     72                $callback_one = '__return_null';
     73                $callback_two = '__return_false';
     74                $hook = new WP_Hook();
     75                $tag = rand_str();
     76                $priority = rand( 1, 100 );
     77                $accepted_args = rand( 1, 100 );
     78
     79                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     80                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     81
     82                $hook->add_filter( $tag, $callback_two, $priority + 1, $accepted_args );
     83                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     84                $this->assertCount( 1, $hook->callbacks[ $priority + 1 ] );
     85        }
     86
     87        public function test_readd_filter() {
     88                $callback = '__return_null';
     89                $hook = new WP_Hook();
     90                $tag = rand_str();
     91                $priority = rand( 1, 100 );
     92                $accepted_args = rand( 1, 100 );
     93
     94                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     95                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     96
     97                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     98                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     99        }
     100
     101        public function test_readd_filter_with_different_priority() {
     102                $callback = '__return_null';
     103                $hook = new WP_Hook();
     104                $tag = rand_str();
     105                $priority = rand( 1, 100 );
     106                $accepted_args = rand( 1, 100 );
     107
     108                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     109                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     110
     111                $hook->add_filter( $tag, $callback, $priority + 1, $accepted_args );
     112                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     113                $this->assertCount( 1, $hook->callbacks[ $priority + 1 ] );
     114        }
     115
     116        public function test_sort_after_add_filter() {
     117                $a = new MockAction();
     118                $b = new MockAction();
     119                $c = new MockAction();
     120                $hook = new WP_Hook();
     121                $tag = rand_str();
     122
     123                $hook->add_filter( $tag, array( $a, 'action' ), 10, 1 );
     124                $hook->add_filter( $tag, array( $b, 'action' ), 5, 1 );
     125                $hook->add_filter( $tag, array( $c, 'action' ), 8, 1 );
     126
     127                $this->assertEquals( array( 5, 8, 10 ), array_keys( $hook->callbacks ) );
     128        }
     129
     130        public function test_remove_and_add() {
     131                $this->hook = new Wp_Hook();
     132
     133                $this->hook->add_filter( 'remove_and_add', '__return_empty_string', 10, 0 );
     134
     135                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add2' ), 11, 1 );
     136
     137                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add4' ), 12, 1 );
     138
     139                $value = $this->hook->apply_filters( '', array() );
     140
     141                $this->assertSame( '24', $value );
     142        }
     143
     144        public function test_remove_and_add_last_filter() {
     145                $this->hook = new Wp_Hook();
     146
     147                $this->hook->add_filter( 'remove_and_add', '__return_empty_string', 10, 0 );
     148
     149                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add1' ), 11, 1 );
     150
     151                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add2' ), 12, 1 );
     152
     153                $value = $this->hook->apply_filters( '', array() );
     154
     155                $this->assertSame( '12', $value );
     156        }
     157
     158        public function test_remove_and_recurse_and_add() {
     159                $this->hook = new Wp_Hook();
     160
     161                $this->hook->add_filter( 'remove_and_add', '__return_empty_string', 10, 0 );
     162
     163                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add1' ), 11, 1 );
     164                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_recurse_and_add2' ), 11, 1 );
     165                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add3' ), 11, 1 );
     166
     167                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add4' ), 12, 1 );
     168
     169                $value = $this->hook->apply_filters( '', array() );
     170
     171                $this->assertSame( '1-134-234', $value );
     172        }
     173
     174        public function _filter_remove_and_add1( $string ) {
     175                return $string . '1';
     176        }
     177
     178        public function _filter_remove_and_add2( $string ) {
     179                $this->hook->remove_filter( 'remove_and_add', array( $this, '_filter_remove_and_add2' ), 11 );
     180                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_add2' ), 11, 1 );
     181
     182                return $string . '2';
     183        }
     184
     185        public function _filter_remove_and_recurse_and_add2( $string ) {
     186                $this->hook->remove_filter( 'remove_and_add', array( $this, '_filter_remove_and_recurse_and_add2' ), 11 );
     187
     188                $string .= '-' . $this->hook->apply_filters( '', array() ) . '-';
     189
     190                $this->hook->add_filter( 'remove_and_add', array( $this, '_filter_remove_and_recurse_and_add2' ), 11, 1 );
     191
     192                return $string . '2';
     193        }
     194
     195        public function _filter_remove_and_add3( $string ) {
     196                return $string . '3';
     197        }
     198
     199        public function _filter_remove_and_add4( $string ) {
     200                return $string . '4';
     201        }
     202
     203        public function test_remove_and_add_action() {
     204                $this->hook = new Wp_Hook();
     205                $this->action_output = '';
     206
     207                $this->hook->add_filter( 'remove_and_add_action', '__return_empty_string', 10, 0 );
     208
     209                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add2' ), 11, 0 );
     210
     211                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add4' ), 12, 0 );
     212
     213                $this->hook->do_action( array() );
     214
     215                $this->assertSame( '24', $this->action_output );
     216        }
     217
     218        public function test_remove_and_add_last_action() {
     219                $this->hook = new Wp_Hook();
     220                $this->action_output = '';
     221
     222                $this->hook->add_filter( 'remove_and_add_action', '__return_empty_string', 10, 0 );
     223
     224                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add1' ), 11, 0 );
     225
     226                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add2' ), 12, 0 );
     227
     228                $this->hook->do_action( array() );
     229
     230                $this->assertSame( '12', $this->action_output );
     231        }
     232
     233        public function test_remove_and_recurse_and_add_action() {
     234                $this->hook = new Wp_Hook();
     235                $this->action_output = '';
     236
     237                $this->hook->add_filter( 'remove_and_add_action', '__return_empty_string', 10, 0 );
     238
     239                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add1' ), 11, 0 );
     240                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_recurse_and_add2' ), 11, 0 );
     241                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add3' ), 11, 0 );
     242
     243                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add4' ), 12, 0 );
     244
     245                $this->hook->do_action( array() );
     246
     247                $this->assertSame( '1-134-234', $this->action_output );
     248        }
     249
     250        public function _action_remove_and_add1() {
     251                $this->action_output .= 1;
     252        }
     253
     254        public function _action_remove_and_add2() {
     255                $this->hook->remove_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add2' ), 11 );
     256                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_add2' ), 11, 0 );
     257
     258                $this->action_output .= '2';
     259        }
     260
     261        public function _action_remove_and_recurse_and_add2() {
     262                $this->hook->remove_filter( 'remove_and_add_action', array( $this, '_action_remove_and_recurse_and_add2' ), 11 );
     263
     264                $this->action_output .= '-';
     265                $this->hook->do_action( array() );
     266                $this->action_output .= '-';
     267
     268                $this->hook->add_filter( 'remove_and_add_action', array( $this, '_action_remove_and_recurse_and_add2' ), 11, 0 );
     269
     270                $this->action_output .= '2';
     271        }
     272
     273        public function _action_remove_and_add3() {
     274                $this->action_output .= '3';
     275        }
     276
     277        public function _action_remove_and_add4() {
     278                $this->action_output .= '4';
     279        }
     280}
  • tests/phpunit/tests/hooks/apply_filters.php

    Property changes on: tests/phpunit/tests/hooks/add_filter.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the apply_filters method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Apply_Filters extends WP_UnitTestCase {
     9
     10        public function test_apply_filters_with_callback() {
     11                $a = new MockAction();
     12                $callback = array( $a, 'filter' );
     13                $hook = new WP_Hook();
     14                $tag = rand_str();
     15                $priority = rand( 1, 100 );
     16                $accepted_args = rand( 1, 100 );
     17                $arg = rand_str();
     18
     19                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     20
     21                $returned = $hook->apply_filters( $arg, array( $arg ) );
     22
     23                $this->assertEquals( $returned, $arg );
     24                $this->assertEquals( 1, $a->get_call_count() );
     25        }
     26
     27        public function test_apply_filters_with_multiple_calls() {
     28                $a = new MockAction();
     29                $callback = array( $a, 'filter' );
     30                $hook = new WP_Hook();
     31                $tag = rand_str();
     32                $priority = rand( 1, 100 );
     33                $accepted_args = rand( 1, 100 );
     34                $arg = rand_str();
     35
     36                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     37
     38                $returned_one = $hook->apply_filters( $arg, array( $arg ) );
     39                $returned_two = $hook->apply_filters( $returned_one, array( $returned_one ) );
     40
     41                $this->assertEquals( $returned_two, $arg );
     42                $this->assertEquals( 2, $a->get_call_count() );
     43        }
     44
     45}
  • tests/phpunit/tests/hooks/do_action.php

    Property changes on: tests/phpunit/tests/hooks/apply_filters.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the do_action method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Do_Action extends WP_UnitTestCase {
     9        private $events = array();
     10        private $action_output = '';
     11
     12        public function setUp() {
     13                parent::setUp();
     14                $this->events = array();
     15        }
     16
     17        public function test_do_action_with_callback() {
     18                $a = new MockAction();
     19                $callback = array( $a, 'action' );
     20                $hook = new WP_Hook();
     21                $tag = rand_str();
     22                $priority = rand( 1, 100 );
     23                $accepted_args = rand( 1, 100 );
     24                $arg = rand_str();
     25
     26                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     27                $hook->do_action( array( $arg ) );
     28
     29                $this->assertEquals( 1, $a->get_call_count() );
     30        }
     31
     32        public function test_do_action_with_multiple_calls() {
     33                $a = new MockAction();
     34                $callback = array( $a, 'filter' );
     35                $hook = new WP_Hook();
     36                $tag = rand_str();
     37                $priority = rand( 1, 100 );
     38                $accepted_args = rand( 1, 100 );
     39                $arg = rand_str();
     40
     41                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     42                $hook->do_action( array( $arg ) );
     43                $hook->do_action( array( $arg ) );
     44
     45                $this->assertEquals( 2, $a->get_call_count() );
     46        }
     47
     48        public function test_do_action_with_multiple_callbacks_on_same_priority() {
     49                $a = new MockAction();
     50                $b = new MockAction();
     51                $callback_one = array( $a, 'filter' );
     52                $callback_two = array( $b, 'filter' );
     53                $hook = new WP_Hook();
     54                $tag = rand_str();
     55                $priority = rand( 1, 100 );
     56                $accepted_args = rand( 1, 100 );
     57                $arg = rand_str();
     58
     59                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     60                $hook->add_filter( $tag, $callback_two, $priority, $accepted_args );
     61                $hook->do_action( array( $arg ) );
     62
     63                $this->assertEquals( 1, $a->get_call_count() );
     64                $this->assertEquals( 1, $a->get_call_count() );
     65        }
     66
     67        public function test_do_action_with_multiple_callbacks_on_different_priorities() {
     68                $a = new MockAction();
     69                $b = new MockAction();
     70                $callback_one = array( $a, 'filter' );
     71                $callback_two = array( $b, 'filter' );
     72                $hook = new WP_Hook();
     73                $tag = rand_str();
     74                $priority = rand( 1, 100 );
     75                $accepted_args = rand( 1, 100 );
     76                $arg = rand_str();
     77
     78                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     79                $hook->add_filter( $tag, $callback_two, $priority, $accepted_args );
     80                $hook->do_action( array( $arg ) );
     81
     82                $this->assertEquals( 1, $a->get_call_count() );
     83                $this->assertEquals( 1, $a->get_call_count() );
     84        }
     85
     86        public function test_do_action_with_no_accepted_args() {
     87                $callback = array( $this, '_action_callback' );
     88                $hook = new WP_Hook();
     89                $tag = rand_str();
     90                $priority = rand( 1, 100 );
     91                $accepted_args = 0;
     92                $arg = rand_str();
     93
     94                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     95                $hook->do_action( array( $arg ) );
     96
     97                $this->assertEmpty( $this->events[0]['args'] );
     98        }
     99
     100        public function test_do_action_with_one_accepted_arg() {
     101                $callback = array( $this, '_action_callback' );
     102                $hook = new WP_Hook();
     103                $tag = rand_str();
     104                $priority = rand( 1, 100 );
     105                $accepted_args = 1;
     106                $arg = rand_str();
     107
     108                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     109                $hook->do_action( array( $arg ) );
     110
     111                $this->assertCount( 1, $this->events[0]['args'] );
     112        }
     113
     114        public function test_do_action_with_more_accepted_args() {
     115                $callback = array( $this, '_action_callback' );
     116                $hook = new WP_Hook();
     117                $tag = rand_str();
     118                $priority = rand( 1, 100 );
     119                $accepted_args = 1000;
     120                $arg = rand_str();
     121
     122                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     123                $hook->do_action( array( $arg ) );
     124
     125                $this->assertCount( 1, $this->events[0]['args'] );
     126        }
     127
     128        public function test_do_action_doesnt_change_value() {
     129                $hook = new WP_Hook();
     130                $this->action_output = '';
     131
     132                $hook->add_filter( 'do_action_doesnt_change_value', array( $this, '_filter_do_action_doesnt_change_value1' ), 10, 1 );
     133                $hook->add_filter( 'do_action_doesnt_change_value', array( $this, '_filter_do_action_doesnt_change_value2' ), 10, 1 );
     134                $hook->add_filter( 'do_action_doesnt_change_value', array( $this, '_filter_do_action_doesnt_change_value3' ), 11, 1 );
     135
     136                $hook->do_action( array( '0' ) );
     137
     138                $this->assertSame( '010203', $this->action_output );
     139        }
     140
     141        public function _filter_do_action_doesnt_change_value1( $value ) {
     142                $this->action_output .= $value . 1;
     143                return 'x1';
     144        }
     145        public function _filter_do_action_doesnt_change_value2( $value ) {
     146                $this->action_output .= $value . 2;
     147                return 'x2';
     148        }
     149
     150        public function _filter_do_action_doesnt_change_value3( $value ) {
     151                $this->action_output .= $value . 3;
     152                return 'x3';
     153        }
     154
     155        /**
     156         * Use this rather than MockAction so we can test callbacks with no args
     157         */
     158        public function _action_callback() {
     159                $args = func_get_args();
     160                $this->events[] = array('action' => __FUNCTION__, 'args'=>$args);
     161        }
     162}
  • tests/phpunit/tests/hooks/do_all_hook.php

    Property changes on: tests/phpunit/tests/hooks/do_action.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the do_all_hook method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Do_All_Hook extends WP_UnitTestCase {
     9
     10        public function test_do_all_hook_with_multiple_calls() {
     11                $a = new MockAction();
     12                $callback = array( $a, 'action' );
     13                $hook = new WP_Hook();
     14                $tag = 'all';
     15                $priority = rand( 1, 100 );
     16                $accepted_args = rand( 1, 100 );
     17                $arg = rand_str();
     18
     19                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     20                $args = array( $arg );
     21                $hook->do_all_hook( $args );
     22                $hook->do_all_hook( $args );
     23
     24                $this->assertEquals( 2, $a->get_call_count() );
     25        }
     26}
  • tests/phpunit/tests/hooks/has_filter.php

    Property changes on: tests/phpunit/tests/hooks/do_all_hook.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the has_filter method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Has_Filter extends WP_UnitTestCase {
     9
     10        public function test_has_filter_with_function() {
     11                $callback = '__return_null';
     12                $hook = new WP_Hook();
     13                $tag = rand_str();
     14                $priority = rand( 1, 100 );
     15                $accepted_args = rand( 1, 100 );
     16
     17                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     18
     19                $this->assertEquals( $priority, $hook->has_filter( $tag, $callback ) );
     20        }
     21
     22        public function test_has_filter_with_object() {
     23                $a = new MockAction();
     24                $callback = array( $a, 'action' );
     25                $hook = new WP_Hook();
     26                $tag = rand_str();
     27                $priority = rand( 1, 100 );
     28                $accepted_args = rand( 1, 100 );
     29
     30                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     31
     32                $this->assertEquals( $priority, $hook->has_filter( $tag, $callback ) );
     33        }
     34
     35        public function test_has_filter_with_static_method() {
     36                $callback = array( 'MockAction', 'action' );
     37                $hook = new WP_Hook();
     38                $tag = rand_str();
     39                $priority = rand( 1, 100 );
     40                $accepted_args = rand( 1, 100 );
     41
     42                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     43
     44                $this->assertEquals( $priority, $hook->has_filter( $tag, $callback ) );
     45        }
     46
     47        public function test_has_filter_without_callback() {
     48                $callback = '__return_null';
     49                $hook = new WP_Hook();
     50                $tag = rand_str();
     51                $priority = rand( 1, 100 );
     52                $accepted_args = rand( 1, 100 );
     53
     54                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     55
     56                $this->assertTrue( $hook->has_filter() );
     57        }
     58
     59        public function test_not_has_filter_without_callback() {
     60                $hook = new WP_Hook();
     61                $this->assertFalse( $hook->has_filter() );
     62        }
     63
     64        public function test_not_has_filter_with_callback() {
     65                $callback = '__return_null';
     66                $hook = new WP_Hook();
     67                $tag = rand_str();
     68
     69                $this->assertFalse( $hook->has_filter( $tag, $callback ) );
     70        }
     71
     72        public function test_has_filter_with_wrong_callback() {
     73                $callback = '__return_null';
     74                $hook = new WP_Hook();
     75                $tag = rand_str();
     76                $priority = rand( 1, 100 );
     77                $accepted_args = rand( 1, 100 );
     78
     79                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     80
     81                $this->assertFalse( $hook->has_filter( $tag, '__return_false' ) );
     82        }
     83}
  • tests/phpunit/tests/hooks/has_filters.php

    Property changes on: tests/phpunit/tests/hooks/has_filter.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the has_filters method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Has_Filters extends WP_UnitTestCase {
     9
     10        public function test_has_filters_with_callback() {
     11                $callback = '__return_null';
     12                $hook = new WP_Hook();
     13                $tag = rand_str();
     14                $priority = rand( 1, 100 );
     15                $accepted_args = rand( 1, 100 );
     16
     17                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     18
     19                $this->assertTrue( $hook->has_filters() );
     20        }
     21
     22        public function test_has_filters_without_callback() {
     23                $hook = new WP_Hook();
     24                $this->assertFalse( $hook->has_filters() );
     25        }
     26
     27        public function test_not_has_filters_with_removed_callback() {
     28                $callback = '__return_null';
     29                $hook = new WP_Hook();
     30                $tag = rand_str();
     31                $priority = rand( 1, 100 );
     32                $accepted_args = rand( 1, 100 );
     33
     34                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     35                $hook->remove_filter( $tag, $callback, $priority );
     36                $this->assertFalse( $hook->has_filters() );
     37        }
     38
     39        public function test_not_has_filter_with_directly_removed_callback() {
     40                $callback = '__return_null';
     41                $hook = new WP_Hook();
     42                $tag = rand_str();
     43                $priority = rand( 1, 100 );
     44                $accepted_args = rand( 1, 100 );
     45
     46                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     47                $function_key = _wp_filter_build_unique_id( $tag, $callback, $priority );
     48                unset( $hook->callbacks[ $priority ][ $function_key ] );
     49
     50                $this->assertFalse( $hook->has_filters() );
     51        }
     52}
  • tests/phpunit/tests/hooks/iterator.php

    Property changes on: tests/phpunit/tests/hooks/has_filters.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the Iterator implementation of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Iterator extends WP_UnitTestCase {
     9
     10        public function test_foreach() {
     11                $callback_one = '__return_null';
     12                $callback_two = '__return_false';
     13                $hook = new WP_Hook();
     14                $tag = rand_str();
     15                $priority = rand( 1, 100 );
     16                $accepted_args = rand( 1, 100 );
     17
     18                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     19                $hook->add_filter( $tag, $callback_two, $priority + 1, $accepted_args );
     20
     21                $functions = array();
     22                $priorities = array();
     23                foreach ( $hook as $key => $callbacks ) {
     24                        $priorities[] = $key;
     25                        foreach ( $callbacks as $function_index => $the_ ) {
     26                                $functions[] = $the_['function'];
     27                        }
     28                }
     29                $this->assertEqualSets( array( $priority, $priority + 1 ), $priorities );
     30                $this->assertEqualSets( array( $callback_one, $callback_two ), $functions );
     31        }
     32}
  • tests/phpunit/tests/hooks/preinit_hooks.php

    Property changes on: tests/phpunit/tests/hooks/iterator.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the IteratorAggregate implementation of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Preinit_Hooks extends WP_UnitTestCase {
     9
     10        public function test_array_to_hooks() {
     11                $tag1 = rand_str();
     12                $priority1 = rand( 1, 100 );
     13                $tag2 = rand_str();
     14                $priority2 = rand( 1, 100 );
     15                $filters = array(
     16                        $tag1 => array(
     17                                $priority1 => array(
     18                                        'test1' => array(
     19                                                'function' => '__return_false',
     20                                                'accepted_args' => 2,
     21                                        ),
     22                                ),
     23                        ),
     24                        $tag2 => array(
     25                                $priority2 => array(
     26                                        'test1' => array(
     27                                                'function' => '__return_null',
     28                                                'accepted_args' => 1,
     29                                        ),
     30                                ),
     31                        ),
     32                );
     33
     34                $hooks = WP_Hook::build_preinitialized_hooks( $filters );
     35
     36                $this->assertEquals( $priority1, $hooks[ $tag1 ]->has_filter( $tag1, '__return_false' ) );
     37                $this->assertEquals( $priority2, $hooks[ $tag2 ]->has_filter( $tag2, '__return_null' ) );
     38        }
     39}
  • tests/phpunit/tests/hooks/remove_all_filters.php

    Property changes on: tests/phpunit/tests/hooks/preinit_hooks.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the remove_all_filters method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Remove_All_Filters extends WP_UnitTestCase {
     9
     10        public function test_remove_all_filters() {
     11                $callback = '__return_null';
     12                $hook = new WP_Hook();
     13                $tag = rand_str();
     14                $priority = rand( 1, 100 );
     15                $accepted_args = rand( 1, 100 );
     16
     17                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     18
     19                $hook->remove_all_filters();
     20
     21                $this->assertFalse( $hook->has_filters() );
     22        }
     23
     24        public function test_remove_all_filters_with_priority() {
     25                $callback_one = '__return_null';
     26                $callback_two = '__return_false';
     27                $hook = new WP_Hook();
     28                $tag = rand_str();
     29                $priority = rand( 1, 100 );
     30                $accepted_args = rand( 1, 100 );
     31
     32                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     33                $hook->add_filter( $tag, $callback_two, $priority + 1, $accepted_args );
     34
     35                $hook->remove_all_filters( $priority );
     36
     37                $this->assertFalse( $hook->has_filter( $tag, $callback_one ) );
     38                $this->assertTrue( $hook->has_filters() );
     39                $this->assertEquals( $priority + 1, $hook->has_filter( $tag, $callback_two ) );
     40        }
     41}
  • tests/phpunit/tests/hooks/remove_filter.php

    Property changes on: tests/phpunit/tests/hooks/remove_all_filters.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3/**
     4 * Test the remove_filter method of WP_Hook
     5 *
     6 * @group hooks
     7 */
     8class Tests_WP_Hook_Remove_Filter extends WP_UnitTestCase {
     9
     10        public function test_remove_filter_with_function() {
     11                $callback = '__return_null';
     12                $hook = new WP_Hook();
     13                $tag = rand_str();
     14                $priority = rand( 1, 100 );
     15                $accepted_args = rand( 1, 100 );
     16
     17                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     18                $hook->remove_filter( $tag, $callback, $priority );
     19
     20                $this->assertFalse( isset( $hook->callbacks[ $priority ] ) );
     21        }
     22
     23        public function test_remove_filter_with_object() {
     24                $a = new MockAction();
     25                $callback = array( $a, 'action' );
     26                $hook = new WP_Hook();
     27                $tag = rand_str();
     28                $priority = rand( 1, 100 );
     29                $accepted_args = rand( 1, 100 );
     30
     31                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     32                $hook->remove_filter( $tag, $callback, $priority );
     33
     34                $this->assertFalse( isset( $hook->callbacks[ $priority ] ) );
     35        }
     36
     37        public function test_remove_filter_with_static_method() {
     38                $callback = array( 'MockAction', 'action' );
     39                $hook = new WP_Hook();
     40                $tag = rand_str();
     41                $priority = rand( 1, 100 );
     42                $accepted_args = rand( 1, 100 );
     43
     44                $hook->add_filter( $tag, $callback, $priority, $accepted_args );
     45                $hook->remove_filter( $tag, $callback, $priority );
     46
     47                $this->assertFalse( isset( $hook->callbacks[ $priority ] ) );
     48        }
     49
     50        public function test_remove_filters_with_another_at_same_priority() {
     51                $callback_one = '__return_null';
     52                $callback_two = '__return_false';
     53                $hook = new WP_Hook();
     54                $tag = rand_str();
     55                $priority = rand( 1, 100 );
     56                $accepted_args = rand( 1, 100 );
     57
     58                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     59                $hook->add_filter( $tag, $callback_two, $priority, $accepted_args );
     60
     61                $hook->remove_filter( $tag, $callback_one, $priority );
     62
     63                $this->assertCount( 1, $hook->callbacks[ $priority ] );
     64        }
     65
     66        public function test_remove_filter_with_another_at_different_priority() {
     67                $callback_one = '__return_null';
     68                $callback_two = '__return_false';
     69                $hook = new WP_Hook();
     70                $tag = rand_str();
     71                $priority = rand( 1, 100 );
     72                $accepted_args = rand( 1, 100 );
     73
     74                $hook->add_filter( $tag, $callback_one, $priority, $accepted_args );
     75                $hook->add_filter( $tag, $callback_two, $priority + 1, $accepted_args );
     76
     77                $hook->remove_filter( $tag, $callback_one, $priority );
     78                $this->assertFalse( isset( $hook->callbacks[ $priority ] ) );
     79                $this->assertCount( 1, $hook->callbacks[ $priority + 1 ] );
     80        }
     81}
  • tests/phpunit/tests/post/types.php

    Property changes on: tests/phpunit/tests/hooks/remove_filter.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
    446446
    447447                $this->assertSame( 1, count( $wp_filter['future_foo'] ) );
    448448                $this->assertTrue( unregister_post_type( 'foo' ) );
    449                 $this->assertSame( array(), $wp_filter['future_foo'] );
     449                $this->assertArrayNotHasKey( 'future_foo', $wp_filter );
    450450        }
    451451
    452452        /**
     
    462462
    463463                $this->assertSame( 1, count( $wp_filter['add_meta_boxes_foo'] ) );
    464464                $this->assertTrue( unregister_post_type( 'foo' ) );
    465                 $this->assertSame( array(), $wp_filter['add_meta_boxes_foo'] );
     465                $this->assertArrayNotHasKey( 'add_meta_boxes_foo', $wp_filter );
    466466        }
    467467
    468468        /**
  • tests/phpunit/tests/taxonomy.php

     
    697697
    698698                $this->assertSame( 1, count( $wp_filter['wp_ajax_add-foo'] ) );
    699699                $this->assertTrue( unregister_taxonomy( 'foo' ) );
    700                 $this->assertSame( array(), $wp_filter['wp_ajax_add-foo'] );
     700                $this->assertArrayNotHasKey( 'wp_ajax_add-foo', $wp_filter );
    701701        }
    702702
    703703        /**