WordPress.org

Make WordPress Core

Changeset 407 in tests


Ignore:
Timestamp:
08/04/11 20:38:26 (3 years ago)
Author:
ryan
Message:

Pinking shears

Files:
29 edited

Legend:

Unmodified
Added
Removed
  • wp-mail-real-test.php

    r368 r407  
    22/** 
    33 * wp-mail-real-test.php 
    4  *  
     4 * 
    55 * Test script for wp_mail with real addresses. 
    66 */ 
     
    1010if (is_callable('getopt')) { 
    1111    $opts = getopt($options); 
    12 } else {     
     12} else { 
    1313    include( dirname(__FILE__) . '/wp-testlib/getopt.php' ); 
    1414    $opts = getoptParser::getopt($options); 
  • wp-test.php

    r358 r407  
    22/** 
    33 * wp-test.php 
    4  *  
     4 * 
    55 * WordPress Testrunner 
    6  *  
     6 * 
    77 * Example: 
    8  *  
     8 * 
    99 * # php wp-test.php -l 
    10  *  
     10 * 
    1111 */ 
    1212 
     
    1515if (is_callable('getopt')) { 
    1616    $opts = getopt($options); 
    17 } else {     
     17} else { 
    1818    include( dirname(__FILE__) . '/wp-testlib/getopt.php' ); 
    1919    $opts = getoptParser::getopt($options); 
     
    121121} else { 
    122122    do_action('test_start'); 
    123      
     123 
    124124    // hide warnings during testing, since that's the normal WP behaviour 
    125125    if ( !WP_DEBUG ) { 
  • wp-testcase/test_actions.php

    r301 r407  
    3939 
    4040    } 
    41      
     41 
    4242    function test_has_action() { 
    4343            $tag = rand_str(); 
    4444            $func = rand_str(); 
    45              
     45 
    4646            $this->assertFalse( has_action($tag, $func) ); 
    4747            $this->assertFalse( has_action($tag) ); 
     
    202202        $a = new MockAction(); 
    203203        $tags = array(rand_str(), rand_str(), rand_str(), rand_str(), rand_str()); 
    204          
     204 
    205205        // two actions per tag 
    206206        foreach ($tags as $tag) { 
     
    238238        $this->assertFalse( empty($args[0][0]->foo) ); 
    239239    } 
    240      
     240 
    241241    function test_action_keyed_array() { 
    242242        $this->knownWPBug(11241); 
     
    246246 
    247247        add_action($tag, array(&$a, 'action')); 
    248          
     248 
    249249        $context = array( rand_str() => rand_str() ); 
    250250        do_action($tag, $context); 
     
    258258        $args = $a->get_args(); 
    259259        $this->assertSame($args[1][0], $context2); 
    260          
     260 
    261261    } 
    262262 
     
    270270 
    271271        $this->assertSame( 10, has_action($tag, $closure) ); 
    272          
     272 
    273273        $context = array( rand_str(), rand_str() ); 
    274274        do_action($tag, $context[0], $context[1]); 
    275          
     275 
    276276        $this->assertSame($GLOBALS[$context[0]], $context[1]); 
    277          
     277 
    278278        $tag2 = rand_str(); 
    279279        $closure2 = function() { $GLOBALS['closure_no_args'] = true;}; 
     
    281281 
    282282        $this->assertSame( 10, has_action($tag2, $closure2) ); 
    283          
     283 
    284284        do_action($tag2); 
    285          
     285 
    286286        $this->assertTrue($GLOBALS['closure_no_args']); 
    287          
     287 
    288288    } 
    289289 
  • wp-testcase/test_admin_includes_template.php

    r366 r407  
    44        $this->assertEquals(' selected=\'selected\'', selected('foo','foo',false)); 
    55        $this->assertEquals(' checked=\'checked\'', checked('foo','foo',false)); 
    6          
     6 
    77        $this->assertEquals(' selected=\'selected\'', selected('1',1,false)); 
    88        $this->assertEquals(' checked=\'checked\'', checked('1',1,false)); 
    9          
     9 
    1010        $this->assertEquals(' selected=\'selected\'', selected('1',true,false)); 
    1111        $this->assertEquals(' checked=\'checked\'', checked('1',true,false)); 
    12          
     12 
    1313        $this->assertEquals(' selected=\'selected\'', selected(1,1,false)); 
    1414        $this->assertEquals(' checked=\'checked\'', checked(1,1,false)); 
    15          
     15 
    1616        $this->assertEquals(' selected=\'selected\'', selected(1,true,false)); 
    1717        $this->assertEquals(' checked=\'checked\'', checked(1,true,false)); 
    18          
     18 
    1919        $this->assertEquals(' selected=\'selected\'', selected(true,true,false)); 
    2020        $this->assertEquals(' checked=\'checked\'', checked(true,true,false)); 
    21          
     21 
    2222        $this->assertEquals(' selected=\'selected\'', selected('0',0,false)); 
    2323        $this->assertEquals(' checked=\'checked\'', checked('0',0,false)); 
    24          
     24 
    2525        $this->assertEquals(' selected=\'selected\'', selected(0,0,false)); 
    2626        $this->assertEquals(' checked=\'checked\'', checked(0,0,false)); 
    27          
     27 
    2828        $this->assertEquals(' selected=\'selected\'', selected('',false,false)); 
    2929        $this->assertEquals(' checked=\'checked\'', checked('',false,false)); 
    30          
     30 
    3131        $this->assertEquals(' selected=\'selected\'', selected(false,false,false)); 
    3232        $this->assertEquals(' checked=\'checked\'', checked(false,false,false)); 
    3333    } 
    34      
     34 
    3535    function test_notequal() { 
    3636        $this->assertEquals('', selected('0','',false)); 
    3737        $this->assertEquals('', checked('0','',false)); 
    38          
     38 
    3939        $this->assertEquals('', selected(0,'',false)); 
    4040        $this->assertEquals('', checked(0,'',false)); 
    41          
     41 
    4242        $this->assertEquals('', selected(0,false,false)); 
    4343        $this->assertEquals('', checked(0,false,false)); 
  • wp-testcase/test_cron.php

    r366 r407  
    1414        _set_cron_array(array()); 
    1515    } 
    16      
     16 
    1717    function test_wp_get_schedule_empty() { 
    1818        // nothing scheduled 
     
    153153        $multi_hook = rand_str(); 
    154154        $multi_args = array(rand_str(), rand_str()); 
    155          
     155 
    156156        // schedule several events with and without arguments 
    157157        wp_schedule_single_event( strtotime('+1 hour'), $hook ); 
     
    161161        wp_schedule_single_event( strtotime('+5 hour'), $multi_hook, $multi_args ); 
    162162        wp_schedule_single_event( strtotime('+6 hour'), $multi_hook, $multi_args ); 
    163          
     163 
    164164        // make sure they're returned by wp_next_scheduled() 
    165165        $this->assertTrue( wp_next_scheduled($hook) > 0 ); 
     
    181181        wp_clear_scheduled_hook($multi_hook, $multi_args); 
    182182        $this->assertFalse( wp_next_scheduled($multi_hook, $multi_args) ); 
    183          
     183 
    184184    } 
    185185 
     
    191191        $ts1 = strtotime('+5 minutes'); 
    192192        $ts2 = strtotime('+3 minutes'); 
    193          
     193 
    194194        // first one works 
    195195        wp_schedule_single_event( $ts1, $hook, $args ); 
    196196        // second one is ignored 
    197197        wp_schedule_single_event( $ts2, $hook, $args ); 
    198          
     198 
    199199        // the next event should be at +5 minutes, not +3 
    200200        $this->assertEquals( $ts1, wp_next_scheduled($hook, $args) ); 
     
    208208        $ts1 = strtotime('+30 minutes'); 
    209209        $ts2 = strtotime('+3 minutes'); 
    210          
     210 
    211211        // first one works 
    212212        wp_schedule_single_event( $ts1, $hook, $args ); 
    213213        // second works too 
    214214        wp_schedule_single_event( $ts2, $hook, $args ); 
    215          
     215 
    216216        // the next event should be at +5 minutes, not +3 
    217217        $this->assertEquals( $ts2, wp_next_scheduled($hook, $args) ); 
     
    225225 * Disable the WP Cron running test for the moment as it kills the whole test suite. 
    226226 * TODO - Fix it to work with the new cron implementation in trunk 
    227  *  
     227 * 
    228228class WPTestCronRunning extends _WPEmptyBlog { 
    229229    function setUp() { 
     
    264264        $this->assertEquals( 1, $a->get_call_count() ); 
    265265        $this->assertEquals( array($args), $a->get_args() ); 
    266          
     266 
    267267        // it shouldn't appear in the schedule anymore 
    268268        $this->assertFalse( wp_next_scheduled($hook, $args) ); 
    269269 
    270270    } 
    271      
     271 
    272272    function test_run_schedule_recurring() { 
    273273        // schedule a recurring event, run it, and make sure the hook is called 
     
    292292        $this->assertEquals( 1, $a->get_call_count() ); 
    293293        $this->assertEquals( array($args), $a->get_args() ); 
    294          
     294 
    295295        // it should appear in the schedule to run again in an hour's time 
    296296        $this->assertEquals( $timestamp + 3600, wp_next_scheduled($hook, $args) ); 
  • wp-testcase/test_filters.php

    r366 r407  
    4141 
    4242    } 
    43      
     43 
    4444    function test_has_filter() { 
    4545            $tag = rand_str(); 
    4646            $func = rand_str(); 
    47              
     47 
    4848            $this->assertFalse( has_filter($tag, $func) ); 
    4949            $this->assertFalse( has_filter($tag) ); 
     
    216216        add_action($tag, array(&$a, 'filter_append'), 10, 2); 
    217217        add_action($tag, array(&$b, 'filter_append'), 10, 2); 
    218          
     218 
    219219        $result = apply_filters_ref_array($tag, array('string', &$obj)); 
    220220 
    221221        $this->assertEquals($result, 'string_append_append'); 
    222          
     222 
    223223        $args = $a->get_args(); 
    224224        $this->assertSame($args[0][1], $obj); 
     
    232232        $obj->foo = true; 
    233233        $this->assertFalse( empty($args[0][1]->foo) ); 
    234          
     234 
    235235    } 
    236236} 
  • wp-testcase/test_http.php

    r366 r407  
    3232    } 
    3333 
    34     function test_redirect_on_301() {    
     34    function test_redirect_on_301() { 
    3535        // 5 : 5 & 301 
    3636        $res = wp_remote_request($this->redirection_script . '?code=301&rt=' . 5, array('redirection' => 5) ); 
     
    3838    } 
    3939 
    40     function test_redirect_on_302() {    
     40    function test_redirect_on_302() { 
    4141        // 5 : 5 & 302 
    4242        $res = wp_remote_request($this->redirection_script . '?code=302&rt=' . 5, array('redirection' => 5) ); 
    4343        $this->assertEquals(200, (is_wp_error($res) ? 0 : (int)$res['response']['code']) ); 
    4444    } 
    45      
     45 
    4646    function test_redirect_on_301_no_redirect() { 
    4747        $this->knownWPBug(16855); 
     
    5858    } 
    5959 
    60     function test_redirections_equal() {     
     60    function test_redirections_equal() { 
    6161        // 5 - 5 
    6262        $res = wp_remote_request($this->redirection_script . '?rt=' . 5, array('redirection' => 5) ); 
     
    9999        // 0 redirections asked for, Should return the document? 
    100100        $res = wp_remote_request($this->redirection_script . '?code=302&rt=' . 5, array('redirection' => 0) ); 
    101         $this->assertEquals( 302, (is_wp_error($res) ? 0 : (int)$res['response']['code']) );         
     101        $this->assertEquals( 302, (is_wp_error($res) ? 0 : (int)$res['response']['code']) ); 
    102102    } 
    103      
     103 
    104104    function test_location_header_on_200() { 
    105105        //$this->knownWPBug(16889); 
    106106        // Is this valid? Streams, cURL and therefor, PHP Extension (ie. all PHP Internal) follow redirects on all status codes, currently all of WP_HTTP follows this template. 
    107          
     107 
    108108        // Do not redirect on non 3xx status codes 
    109109        //$res = wp_remote_request( $this->redirection_script . '?200-location=true' ); // Prints PASS on initial load, FAIL if the client follows the specified redirection 
    110110        //$this->assertEquals( 'PASS', $res['body']); 
    111111    } 
    112      
     112 
    113113    function test_send_headers() { 
    114114        $this->knownWPBug(11888); 
     
    132132        //$this->assertTrue( isset($headers['test3']) && '' === $headers['test3'] ); 
    133133    } 
    134      
     134 
    135135    function test_file_stream() { 
    136136        $url = 'http://unit-tests.svn.wordpress.org/wp-testdata/images/2004-07-22-DSC_0007.jpg'; // we'll test against a file in the unit test data 
  • wp-testcase/test_image.php

    r402 r407  
    8080 
    8181    } 
    82      
     82 
    8383    function test_exif_error() { 
    8484        if (!is_callable('wp_read_image_metadata')) 
    8585            $this->markTestSkipped(); 
    86              
     86 
    8787        $this->knownWPBug(6571); 
    88              
     88 
    8989        // http://trac.wordpress.org/ticket/6571 
    9090        // this triggers a warning mesage when reading the exif block 
     
    106106        if (!is_callable('wp_read_image_metadata')) 
    107107            $this->markTestSkipped(); 
    108              
     108 
    109109        // no exif data in this image (from burningwell.org) 
    110110        $out = wp_read_image_metadata(DIR_TESTDATA.'/images/canola.jpg'); 
     
    121121        $this->assertEquals('', $out['title']); 
    122122    } 
    123      
     123 
    124124} 
    125125 
     
    128128        if (!is_callable('wp_constrain_dimensions')) 
    129129            $this->markTestSkipped(); 
    130              
     130 
    131131        // no constraint - should have no effect 
    132132        $out = wp_constrain_dimensions(640, 480, 0, 0); 
     
    135135        $out = wp_constrain_dimensions(640, 480); 
    136136        $this->assertEquals(array(640, 480), $out); 
    137          
     137 
    138138        $out = wp_constrain_dimensions(0, 0, 0, 0); 
    139139        $this->assertEquals(array(0, 0), $out); 
    140140    } 
    141      
     141 
    142142    function test_constrain_dims_smaller() { 
    143143        if (!is_callable('wp_constrain_dimensions')) 
    144144            $this->markTestSkipped(); 
    145              
     145 
    146146        // image size is smaller than the constraint - no effect 
    147147        $out = wp_constrain_dimensions(500, 600, 1024, 768); 
     
    158158        if (!is_callable('wp_constrain_dimensions')) 
    159159            $this->markTestSkipped(); 
    160              
     160 
    161161        // image size is equal to the constraint - no effect 
    162162        $out = wp_constrain_dimensions(1024, 768, 1024, 768); 
     
    169169        $this->assertequals(array(1024, 768), $out); 
    170170    } 
    171      
     171 
    172172    function test_constrain_dims_larger() { 
    173173        if (!is_callable('wp_constrain_dimensions')) 
    174174            $this->markTestSkipped(); 
    175              
     175 
    176176        // image size is larger than the constraint - result should be constrained 
    177177        $out = wp_constrain_dimensions(1024, 768, 500, 600); 
     
    183183        $out = wp_constrain_dimensions(1024, 768, 500, 0); 
    184184        $this->assertequals(array(500, 375), $out); 
    185          
     185 
    186186        // also try a portrait oriented image 
    187187        $out = wp_constrain_dimensions(300, 800, 500, 600); 
     
    198198        if (!is_callable('wp_constrain_dimensions')) 
    199199            $this->markTestSkipped(); 
    200              
     200 
    201201        // one dimension is larger than the constraint, one smaller - result should be constrained 
    202202        $out = wp_constrain_dimensions(1024, 768, 500, 800); 
    203203        $this->assertequals(array(500, 375), $out); 
    204          
     204 
    205205        $out = wp_constrain_dimensions(1024, 768, 2000, 700); 
    206206        $this->assertequals(array(933, 700), $out); 
     
    209209        $out = wp_constrain_dimensions(768, 1024, 800, 500); 
    210210        $this->assertequals(array(375, 500), $out); 
    211          
     211 
    212212        $out = wp_constrain_dimensions(768, 1024, 2000, 700); 
    213213        $this->assertequals(array(525, 700), $out); 
    214214    } 
    215      
     215 
    216216    function test_shrink_dimensions_default() { 
    217217        $out = wp_shrink_dimensions(640, 480); 
     
    253253        $out = wp_shrink_dimensions(1024, 768, 500, 800); 
    254254        $this->assertequals(array(500, 375), $out); 
    255          
     255 
    256256        $out = wp_shrink_dimensions(1024, 768, 2000, 700); 
    257257        $this->assertequals(array(933, 700), $out); 
     
    260260        $out = wp_shrink_dimensions(768, 1024, 800, 500); 
    261261        $this->assertequals(array(375, 500), $out); 
    262          
     262 
    263263        $out = wp_shrink_dimensions(768, 1024, 2000, 700); 
    264264        $this->assertequals(array(525, 700), $out); 
    265265    } 
    266      
     266 
    267267    function test_constrain_size_for_editor_thumb() { 
    268268        $out = image_constrain_size_for_editor(600, 400, 'thumb'); 
    269269        $this->assertEquals(array(150, 100), $out); 
    270          
     270 
    271271        $out = image_constrain_size_for_editor(64, 64, 'thumb'); 
    272272        $this->assertEquals(array(64, 64), $out); 
     
    279279        update_option('medium_size_w', 500); 
    280280        update_option('medium_size_h', 0); 
    281          
     281 
    282282        $out = image_constrain_size_for_editor(600, 400, 'medium'); 
    283283        $this->assertEquals(array(500, 333), $out); 
     
    285285        $out = image_constrain_size_for_editor(400, 600, 'medium'); 
    286286        $this->assertEquals(array(400, 600), $out); 
    287          
     287 
    288288        $out = image_constrain_size_for_editor(64, 64, 'medium'); 
    289289        $this->assertEquals(array(64, 64), $out); 
    290          
     290 
    291291        // content_width should be ignored 
    292292        $content_width = 350; 
     
    300300        $out = image_constrain_size_for_editor(600, 400, 'full'); 
    301301        $this->assertEquals(array(600, 400), $out); 
    302          
     302 
    303303        $out = image_constrain_size_for_editor(64, 64, 'full'); 
    304304        $this->assertEquals(array(64, 64), $out); 
    305          
     305 
    306306        // content_width default is 500 
    307307        $content_width = 0; 
     
    309309        $out = image_constrain_size_for_editor(600, 400, 'full'); 
    310310        $this->assertEquals(array(600, 400), $out); 
    311          
     311 
    312312        $out = image_constrain_size_for_editor(64, 64, 'full'); 
    313313        $this->assertEquals(array(64, 64), $out); 
    314     } 
    315      
     314<<<<<<< .mine 
     315 
     316======= 
     317>>>>>>> .r406 
     318    } 
     319 
    316320} 
    317321 
     
    328332        $this->assertEquals( array(0, 0, 0, 0, 300, 400, 480, 640), $out ); 
    329333    } 
    330      
     334 
    331335    function test_400x0_no_crop() { 
    332336        // landscape: resize 640x480 to fit 400w: 400x300 
     
    402406        $this->assertEquals( array(0, 0, 0, 80, 400, 400, 480, 480), $out ); 
    403407    } 
    404      
     408 
    405409    function test_400x0_crop() { 
    406410        // landscape: resize 640x480 to fit 400w: 400x300 
     
    426430        $this->assertEquals( array(0, 0, 0, 0, 300, 400, 480, 640), $out ); 
    427431    } 
    428      
     432 
    429433    function test_400x500_crop() { 
    430434        // landscape: crop 640x480 to fit 400x500: 400x400 taken from a 480x480 crop at (80. 0) 
     
    438442        $this->assertEquals( array(0, 0, 0, 20, 400, 500, 480, 600), $out ); 
    439443    } 
    440      
     444 
    441445} 
    442446 
     
    480484        $this->assertEquals( 'error_getting_dimensions', $image->get_error_code() ); 
    481485    } 
    482      
     486 
    483487    function test_resize_thumb_128x96() { 
    484488        $image = image_resize( DIR_TESTDATA.'/images/2007-06-17DSC_4173.JPG', 128, 96 ); 
     
    571575            'test-image.jpg', 
    572576            ); 
    573              
     577 
    574578        foreach ($files as $file) { 
    575579            $this->assertTrue( file_is_valid_image( DIR_TESTDATA.'/images/'.$file ), "file_is_valid_image($file) should return true" ); 
    576580        } 
    577581    } 
    578      
     582 
    579583    function test_is_image_negative() { 
    580584        // these are actually image files but aren't recognized or usable by php 
     
    584588            'test-image.sgi', 
    585589            ); 
    586              
     590 
    587591        foreach ($files as $file) { 
    588592            $this->assertFalse( file_is_valid_image( DIR_TESTDATA.'/images/'.$file ), "file_is_valid_image($file) should return false" ); 
    589593        } 
    590594    } 
    591      
     595 
    592596    function test_is_displayable_image_positive() { 
    593597        // these are all usable in typical web browsers 
     
    597601            'test-image.jpg', 
    598602            ); 
    599              
     603 
    600604        foreach ($files as $file) { 
    601605            $this->assertTrue( file_is_displayable_image( DIR_TESTDATA.'/images/'.$file ), "file_is_valid_image($file) should return true" ); 
    602606        } 
    603607    } 
    604      
     608 
    605609    function test_is_displayable_image_negative() { 
    606610        // these are image files but aren't suitable for web pages because of compatibility or size issues 
     
    623627        } 
    624628    } 
    625      
    626      
    627      
     629 
     630 
     631 
    628632} 
    629633 
  • wp-testcase/test_import_wp.php

    r366 r407  
    66 
    77// _nuke_main_tables style function on tearDown? (Should this be part of _WPEmptyBlog tearDown?) 
    8         
     8 
    99class WXRParserTest extends WPTestCase { 
    1010    function setUp() { 
     
    1313        if ( ! defined( 'WP_IMPORTING' ) ) 
    1414            define( 'WP_IMPORTING', true ); 
    15              
     15 
    1616        if ( ! defined( 'WP_LOAD_IMPORTERS' ) ) 
    17             define( 'WP_LOAD_IMPORTERS', true );         
     17            define( 'WP_LOAD_IMPORTERS', true ); 
    1818 
    1919        require_once DIR_TESTDATA . '/plugins/wordpress-importer/wordpress-importer.php'; 
     
    2323        parent::tearDown(); 
    2424    } 
    25      
     25 
    2626    function test_malformed_wxr() { 
    2727        $file = DIR_TESTDATA . '/export/malformed.xml'; 
    28      
     28 
    2929        // regex based parser cannot detect malformed XML 
    3030        foreach ( array( 'WXR_Parser_SimpleXML', 'WXR_Parser_XML' ) as $p ) { 
     
    3232            $result = $parser->parse($file); 
    3333            $this->assertTrue( is_wp_error( $result ) ); 
    34             $this->assertEquals( 'There was an error when reading this WXR file', $result->get_error_message() );    
    35         }    
    36     }    
     34            $this->assertEquals( 'There was an error when reading this WXR file', $result->get_error_message() ); 
     35        } 
     36    } 
    3737 
    3838    function test_invalid_wxr() { 
    3939        $f1 = DIR_TESTDATA . '/export/missing-version-tag.xml'; 
    4040        $f2 = DIR_TESTDATA . '/export/invalid-version-tag.xml'; 
    41      
     41 
    4242        foreach ( array( 'WXR_Parser_SimpleXML', 'WXR_Parser_XML', 'WXR_Parser_Regex' ) as $p ) { 
    4343            foreach ( array( $f1, $f2 ) as $file ) { 
    4444                $parser = new $p; 
    45                 $result = $parser->parse( $file );               
     45                $result = $parser->parse( $file ); 
    4646                $this->assertTrue( is_wp_error( $result ) ); 
    47                 $this->assertEquals( 'This does not appear to be a WXR file, missing/invalid WXR version number', $result->get_error_message() );    
     47                $this->assertEquals( 'This does not appear to be a WXR file, missing/invalid WXR version number', $result->get_error_message() ); 
    4848            } 
    49         }            
    50     } 
    51      
     49        } 
     50    } 
     51 
    5252    function test_wxr_version_1_1() { 
    5353        $file = DIR_TESTDATA . '/export/valid-wxr-1.1.xml'; 
    54               
     54 
    5555        foreach ( array( 'WXR_Parser_SimpleXML', 'WXR_Parser_XML', 'WXR_Parser_Regex' ) as $p ) { 
    5656            $message = $p . ' failed'; 
    5757            $parser = new $p; 
    58             $result = $parser->parse( $file );   
    59              
    60             $this->assertTrue( is_array( $result ), $message );          
     58            $result = $parser->parse( $file ); 
     59 
     60            $this->assertTrue( is_array( $result ), $message ); 
    6161            $this->assertEquals( 'http://localhost/', $result['base_url'], $message ); 
    62             $this->assertEquals( array(   
     62            $this->assertEquals( array( 
    6363                'author_id' => 2, 
    6464                'author_login' => 'john', 
     
    7373                'category_parent' => '', 
    7474                'cat_name' => 'alpha', 
    75                 'category_description' => 'The alpha category'           
     75                'category_description' => 'The alpha category' 
    7676            ), $result['categories'][0], $message ); 
    7777            $this->assertEquals( array( 
     
    7979                'tag_slug' => 'clippable', 
    8080                'tag_name' => 'Clippable', 
    81                 'tag_description' => 'The Clippable post_tag'        
     81                'tag_description' => 'The Clippable post_tag' 
    8282            ), $result['tags'][0], $message ); 
    8383            $this->assertEquals( array( 
     
    8585                'term_taxonomy' => 'post_tax', 
    8686                'slug' => 'bieup', 
    87                 'term_parent' => '',                 
     87                'term_parent' => '', 
    8888                'term_name' => 'bieup', 
    89                 'term_description' => 'The bieup post_tax'       
    90             ), $result['terms'][0], $message );                  
     89                'term_description' => 'The bieup post_tax' 
     90            ), $result['terms'][0], $message ); 
    9191 
    9292            $this->assertEquals( 2, count($result['posts']), $message ); 
     
    100100            $this->assertEquals( array( 
    101101                array( 'key' => '_wp_page_template', 'value' => 'default' ) 
    102             ), $result['posts'][1]['postmeta'], $message );  
     102            ), $result['posts'][1]['postmeta'], $message ); 
    103103        } 
    104104    } 
    105      
     105 
    106106    function test_wxr_version_1_0() { 
    107107        $file = DIR_TESTDATA . '/export/valid-wxr-1.0.xml'; 
    108          
     108 
    109109        foreach ( array( 'WXR_Parser_SimpleXML', 'WXR_Parser_XML', 'WXR_Parser_Regex' ) as $p ) { 
    110110            $message = $p . ' failed'; 
    111111            $parser = new $p; 
    112112            $result = $parser->parse( $file ); 
    113              
    114             $this->assertTrue( is_array( $result ), $message );          
     113 
     114            $this->assertTrue( is_array( $result ), $message ); 
    115115            $this->assertEquals( 'http://localhost/', $result['base_url'], $message ); 
    116116            $this->assertEquals( $result['categories'][0]['category_nicename'], 'alpha', $message ); 
     
    119119            $this->assertEquals( $result['categories'][0]['category_description'], 'The alpha category', $message ); 
    120120            $this->assertEquals( $result['tags'][0]['tag_slug'], 'chicken', $message ); 
    121             $this->assertEquals( $result['tags'][0]['tag_name'], 'chicken', $message );  
     121            $this->assertEquals( $result['tags'][0]['tag_name'], 'chicken', $message ); 
    122122 
    123123            $this->assertEquals( 6, count($result['posts']), $message ); 
     
    144144        } 
    145145    } 
    146      
     146 
    147147    // tags in CDATA #11574 
    148148} 
     
    154154        if ( ! defined( 'WP_IMPORTING' ) ) 
    155155            define( 'WP_IMPORTING', true ); 
    156              
     156 
    157157        if ( ! defined( 'WP_LOAD_IMPORTERS' ) ) 
    158158            define( 'WP_LOAD_IMPORTERS', true ); 
    159              
     159 
    160160        require_once DIR_TESTDATA . '/plugins/wordpress-importer/wordpress-importer.php'; 
    161161 
     
    178178            wp_delete_user( $user->ID ); 
    179179    } 
    180      
     180 
    181181    function test_small_import() { 
    182182        global $wpdb; 
    183183 
    184         $authors = array( 'admin' => false, 'editor' => false, 'author' => false );  
     184        $authors = array( 'admin' => false, 'editor' => false, 'author' => false ); 
    185185        $this->_import_wp( DIR_TESTDATA . '/export/small-export.xml', $authors ); 
    186186 
     
    335335        $this->assertEquals( 1, count($cats) ); 
    336336    } 
    337      
     337 
    338338    function test_double_import() { 
    339339        $authors = array( 'admin' => false, 'editor' => false, 'author' => false ); 
     
    379379    function setUp() { 
    380380        parent::setUp(); 
    381          
     381 
    382382        if ( ! defined( 'WP_IMPORTING' ) ) 
    383383            define( 'WP_IMPORTING', true ); 
    384              
     384 
    385385        if ( ! defined( 'WP_LOAD_IMPORTERS' ) ) 
    386386            define( 'WP_LOAD_IMPORTERS', true ); 
    387              
     387 
    388388        require_once DIR_TESTDATA . '/plugins/wordpress-importer/wordpress-importer.php'; 
    389389    } 
     
    392392        parent::tearDown(); 
    393393    } 
    394      
     394 
    395395    function test_serialized_postmeta_no_cdata() { 
    396         $this->_import_wp( DIR_TESTDATA . '/export/test-serialized-postmeta-no-cdata.xml', array( 'johncoswell' => false ) );    
     396        $this->_import_wp( DIR_TESTDATA . '/export/test-serialized-postmeta-no-cdata.xml', array( 'johncoswell' => false ) ); 
    397397        $expected['special_post_title'] = 'A special title'; 
    398         $expected['is_calendar'] = '';   
     398        $expected['is_calendar'] = ''; 
    399399        $this->assertEquals( $expected, get_post_meta( 122, 'post-options', true ) ); 
    400400    } 
    401      
     401 
    402402    function test_utw_postmeta() { 
    403403        $this->_import_wp( DIR_TESTDATA . '/export/test-utw-post-meta-import.xml', array( 'johncoswell' => false ) ); 
     
    414414        $classy = new StdClass(); 
    415415        $classy->tag =  "artwork"; 
    416         $expected[] = $classy;   
     416        $expected[] = $classy; 
    417417        $classy = new StdClass(); 
    418418        $classy->tag =  "dead-tracks"; 
    419         $expected[] = $classy;   
     419        $expected[] = $classy; 
    420420        $classy = new StdClass(); 
    421421        $classy->tag =  "ipod"; 
     
    429429        $classy = new StdClass(); 
    430430        $classy->tag =  "lyrics"; 
    431         $expected[] = $classy;   
     431        $expected[] = $classy; 
    432432        $classy = new StdClass(); 
    433433        $classy->tag =  "script"; 
    434         $expected[] = $classy;   
     434        $expected[] = $classy; 
    435435        $classy = new StdClass(); 
    436436        $classy->tag =  "tracks"; 
    437         $expected[] = $classy;   
     437        $expected[] = $classy; 
    438438        $classy = new StdClass(); 
    439439        $classy->tag =  "windows-scripting-host"; 
    440         $expected[] = $classy;   
     440        $expected[] = $classy; 
    441441        $classy = new StdClass(); 
    442442        $classy->tag =  "wscript"; 
    443         $expected[] = $classy;   
    444          
     443        $expected[] = $classy; 
     444 
    445445        $this->assertEquals( $expected, get_post_meta( 150, 'test', true ) ); 
    446446    } 
     
    469469 
    470470        //HTML in the CDATA should work with old WordPress version 
    471         $this->assertEquals( '<pre>some html</pre>', get_post_meta( 10, 'contains-html', true ) );       
     471        $this->assertEquals( '<pre>some html</pre>', get_post_meta( 10, 'contains-html', true ) ); 
    472472        //Serialised will only work with 3.0 onwards. 
    473473        $expected["special_post_title"] = "A special title"; 
    474474        $expected["is_calendar"] = ""; 
    475         $this->assertEquals( $expected, get_post_meta( 10, 'post-options', true ) );         
     475        $this->assertEquals( $expected, get_post_meta( 10, 'post-options', true ) ); 
    476476    } 
    477477 
  • wp-testcase/test_includes_canonical.php

    r365 r407  
    2020 
    2121        $wp_rewrite->flush_rules(); 
    22          
     22 
    2323    } 
    2424 
     
    7171        if ( isset($expected['url']) ) 
    7272            $this->assertEquals( $expected['url'], $parsed_can_url['path'] . (!empty($parsed_can_url['query']) ? '?' . $parsed_can_url['query'] : ''), $ticket_ref ); 
    73      
    74         if ( isset($expected['qv']) ) {  
     73 
     74        if ( isset($expected['qv']) ) { 
    7575 
    7676            // "make" that the request and check the query is correct 
     
    7979            // Are all query vars accounted for, And correct? 
    8080            global $wp; 
    81      
     81 
    8282            $query_vars = array_diff($wp->query_vars, $wp->extra_query_vars); 
    8383            if ( !empty($parsed_can_url['query']) ) { 
    8484                parse_str($parsed_can_url['query'], $_qv); 
    85      
     85 
    8686                // $_qv should not contain any elements which are set in $query_vars already (ie. $_GET vars should not be present in the Rewrite) 
    8787                $this->assertEquals( array(), array_intersect( $query_vars, $_qv ), 'Query vars are duplicated from the Rewrite into $_GET; ' . $ticket_ref ); 
    88                  
     88 
    8989                $query_vars = array_merge($query_vars, $_qv); 
    9090            } 
    91      
     91 
    9292            $this->assertEquals( $expected['qv'], $query_vars ); 
    9393        } //isset $expected['qv'] 
     
    109109                array( '/category/uncategorized/?paged=2', array( 'url' => '/category/uncategorized/page/2/', 'qv' => array( 'category_name' => 'uncategorized', 'paged' => 2) ) ), 
    110110                array( '/category/uncategorized/?paged=2&category_name=uncategorized', array( 'url' => '/category/uncategorized/page/2/', 'qv' => array( 'category_name' => 'uncategorized', 'paged' => 2) ), 17174 ), 
    111                  
     111 
    112112                // Categories & Intersections with other vars 
    113113                array( '/category/uncategorized/?tag=post-formats', array( 'url' => '/category/uncategorized/?tag=post-formats', 'qv' => array('category_name' => 'uncategorized', 'tag' => 'post-formats') ) ), 
    114114                array( '/?category_name=cat-a,cat-b', array( 'url' => '/?category_name=cat-a,cat-b', 'qv' => array('category_name' => 'cat-a,cat-b' ) ) ), 
    115                  
     115 
    116116                // Categories with Dates 
    117117                array( '/category/uncategorized/?paged=2&year=2008', array( 'url' => '/category/uncategorized/page/2/?year=2008', 'qv' => array( 'category_name' => 'uncategorized', 'paged' => 2, 'year' => 2008) ), 17661 ), 
     
    131131                array( '/?page_id=144', '/parent-page/child-page-1/'), 
    132132                array( '/abo', '/about/' ), 
    133                  
    134                  
     133 
     134 
    135135                // Posts 
    136136                array( '?p=587', '/2008/06/02/post-format-test-audio/'), 
     
    143143                array( '/2010/post-format-test-au/', '/2008/06/02/post-format-test-audio/'), // A Year the post is not in 
    144144                array( '/post-format-test-au/', '/2008/06/02/post-format-test-audio/'), 
    145                  
     145 
    146146                array( '/2008/09/03/images-test/3/', array( 'url' => '/2008/09/03/images-test/3/', 'qv' => array( 'name' => 'images-test', 'year' => '2008', 'monthnum' => '09', 'day' => '03', 'page' => '/3' ) ) ), // page = /3 ?! 
    147147                array( '/2008/09/03/images-test/8/', '/2008/09/03/images-test/4/' ), // post with 4 pages 
     
    153153                array( '/2008/09/03/images-test/canola2/', '/2008/06/10/post-format-test-gallery/canola2/' ), // Image accessed via incorrect parent 
    154154                array( '/2008/06/10/post-format-test-gallery/?attachment_id=611', '/2008/06/10/post-format-test-gallery/canola2/' ), 
    155                  
     155 
    156156                // Dates 
    157157                array( '/?m=2008', '/2008/' ), 
     
    159159                array( '/?m=20080905', '/2008/09/05/'), 
    160160                array( '/?m=2008095', '/2008/09/'), // Invalid date, /09/ or /09/05/ perhaps? 
    161                  
     161 
    162162                array( '/2008/?day=05', '/2008/?day=05'), // no redirect 
    163163                array( '/2008/09/?day=05', '/2008/09/05/'), 
    164164                array( '/2008/?monthnum=9', '/2008/09/'), 
    165                  
     165 
    166166                array( '/?year=2008', '/2008/'), 
    167                  
     167 
    168168                // Authors 
    169169                array( '/?author=3', '/author/chip-bennett/' ), 
    170170                array( '/?author=3&year=2008', '/2008/?author=3'), 
    171171                array( '/author/chip-bennett/?year=2008', '/2008/?author=3'), //Either or, see previous testcase. 
    172                  
     172 
    173173                // Todo: Endpoints (feeds, trackbacks, etc), More fuzzed mixed query variables, comment paging, Home page (Static) 
    174174 
  • wp-testcase/test_includes_class-wp-dependencies.php

    r392 r407  
    44        // Create a new object 
    55        $dep = new WP_Dependencies; 
    6          
     6 
    77        $this->assertTrue($dep->add( 'one', '' )); 
    88        $this->assertTrue($dep->add( 'two', '' )); 
     
    1818        // Create a new object 
    1919        $dep = new WP_Dependencies; 
    20          
     20 
    2121        $this->assertTrue($dep->add( 'one', '' )); 
    2222        $this->assertTrue($dep->add( 'two', '' )); 
    2323 
    2424        $dep->remove( 'one' ); 
    25          
     25 
    2626        $this->assertFalse($dep->query( 'one')); 
    2727        $this->assertInstanceOf('_WP_Dependency', $dep->query( 'two' )); 
    28          
     28 
    2929    } 
    30      
     30 
    3131    function test_enqueue() { 
    3232        // Create a new object 
    3333        $dep = new WP_Dependencies; 
    34          
     34 
    3535        $this->assertTrue($dep->add( 'one', '' )); 
    3636        $this->assertTrue($dep->add( 'two', '' )); 
     
    4040        $this->assertTrue($dep->query( 'one', 'queue' )); 
    4141        $this->assertFalse($dep->query( 'two', 'queue' )); 
    42          
     42 
    4343        $dep->enqueue('two'); 
    4444        $this->assertTrue($dep->query( 'one', 'queue' )); 
     
    4949        // Create a new object 
    5050        $dep = new WP_Dependencies; 
    51          
     51 
    5252        $this->assertTrue($dep->add( 'one', '' )); 
    5353        $this->assertTrue($dep->add( 'two', '' )); 
     
    6666        $this->assertFalse($dep->query( 'two', 'queue' )); 
    6767    } 
    68      
     68 
    6969    function test_enqueue_args() { 
    7070        // Create a new object 
    7171        $dep = new WP_Dependencies; 
    72          
     72 
    7373        $this->assertTrue($dep->add( 'one', '' )); 
    7474        $this->assertTrue($dep->add( 'two', '' )); 
     
    8989        // Create a new object 
    9090        $dep = new WP_Dependencies; 
    91          
     91 
    9292        $this->assertTrue($dep->add( 'one', '' )); 
    9393        $this->assertTrue($dep->add( 'two', '' )); 
     
    104104        $this->assertTrue($dep->query( 'two', 'queue' )); 
    105105        $this->assertFalse(isset($dep->args['one'])); 
    106          
     106 
    107107        $dep->dequeue('two'); 
    108108        $this->assertFalse($dep->query( 'one', 'queue' )); 
     
    110110        $this->assertFalse(isset($dep->args['two'])); 
    111111    } 
    112      
     112 
    113113} 
    114114?> 
  • wp-testcase/test_includes_compat.php

    r366 r407  
    1515        $this->assertEquals('993003b95758e0ac2eba451a4c5877eb1bb7b92a', _hash_hmac('sha1', 'simple', 'key')); 
    1616    } 
    17      
     17 
    1818    function test_key_padding() { 
    1919        $this->assertEquals('3c1399103807cf12ec38228614416a8c', _hash_hmac('md5', 'simple', '65 character key 65 character key 65 character key 65 character k')); 
     
    2525        $this->assertEquals(array( 1 => '993003b95758e0ac2eba451a4c5877eb1bb7b92a'), unpack('H40', _hash_hmac('sha1', 'simple', 'key', true))); 
    2626    } 
    27      
     27 
    2828} 
    2929 
  • wp-testcase/test_includes_file.php

    r395 r407  
    33class TestIncludesFile extends WPTestCase { 
    44 
    5 // function wp_unique_filename( $dir, $name, $ext, $unique_filename_callback = NULL )    
     5// function wp_unique_filename( $dir, $name, $ext, $unique_filename_callback = NULL ) 
    66 
    77    function setUp() { 
    88        $this->dir = dirname(tempnam('/tmp', 'foo')); 
    9          
     9 
    1010        $this->badchars = '"\'[]*&?$'; 
    1111    } 
    12      
     12 
    1313    function is_unique_writable_file($path, $filename) { 
    1414        $fullpath = $path . DIRECTORY_SEPARATOR . $filename; 
    15          
     15 
    1616        $fp = fopen( $fullpath, 'x' ); 
    1717        // file already exists? 
    1818        if (!$fp) 
    1919            return false; 
    20          
     20 
    2121        // write some random contents 
    2222        $c = rand_str(); 
    2323        fwrite($fp, $c); 
    2424        fclose($fp); 
    25          
     25 
    2626        if ( file_get_contents($fullpath) === $c ) 
    2727            $result = true; 
    2828        else 
    2929            $result = false; 
    30              
     30 
    3131        return $result; 
    3232    } 
    33      
     33 
    3434    function test_unique_filename_is_valid() { 
    3535        // make sure it produces a valid, writable, unique filename 
     
    5252        // the two should be different 
    5353        $this->assertNotEquals( $filename1, $filename2 ); 
    54          
     54 
    5555        unlink($this->dir . DIRECTORY_SEPARATOR . $filename1); 
    5656        unlink($this->dir . DIRECTORY_SEPARATOR . $filename2); 
    5757    } 
    58      
     58 
    5959    function test_unique_filename_is_sanitized() { 
    6060        $name = rand_str(); 
     
    6363        // make sure the bad characters were all stripped out 
    6464        $this->assertEquals( $name . '.txt', $filename ); 
    65              
     65 
    6666        $this->assertTrue( $this->is_unique_writable_file($this->dir, $filename) ); 
    6767 
     
    8888        // "foo.php.txt" becomes "foo.php_.txt" 
    8989        $this->assertEquals( $name . '.php_.txt', $filename ); 
    90              
     90 
    9191        $this->assertTrue( $this->is_unique_writable_file($this->dir, $filename) ); 
    9292 
     
    9999 
    100100        $this->assertEquals( $name, $filename ); 
    101              
     101 
    102102        $this->assertTrue( $this->is_unique_writable_file($this->dir, $filename) ); 
    103103 
  • wp-testcase/test_includes_formatting.php

    r405 r407  
    665665            'video/mpeg', 
    666666        ); 
    667      
     667 
    668668        foreach ( $inputs as $input ) { 
    669669            $this->assertEquals($input, sanitize_mime_type($input)); 
  • wp-testcase/test_includes_meta.php

    r384 r407  
    1414        foreach ($this->post_ids as $id) 
    1515            wp_delete_post($id); 
    16              
     16 
    1717        delete_metadata( 'user', $this->author->ID, 'meta_key', '', true ); 
    1818        delete_metadata( 'user', $this->author->ID, 'delete_meta_key', '', true ); 
     
    3434        $this->assertEquals( 'sanitized', $meta ); 
    3535    } 
    36      
     36 
    3737    function test_delete_metadata_by_mid() { 
    3838        if ( ! function_exists( 'delete_metadata_by_mid' ) || ! function_exists( 'get_metadata_by_mid' ) ) 
    3939            return; 
    40          
     40 
    4141        // Let's try and delete a non-existing ID, non existing meta 
    4242        $this->assertFalse( delete_metadata_by_mid( 'user', 0 ) ); 
    4343        $this->assertFalse( delete_metadata_by_mid( 'non_existing_meta', $this->delete_meta_id ) ); 
    44          
     44 
    4545        // Now let's delete the real meta data 
    4646        $this->assertTrue( delete_metadata_by_mid( 'user', $this->delete_meta_id ) ); 
    47          
     47 
    4848        // And make sure it's been deleted 
    4949        $this->assertFalse( get_metadata_by_mid( 'user', $this->delete_meta_id ) ); 
    50          
     50 
    5151        // Make sure the caches are cleared 
    5252        $this->assertFalse( (bool) get_user_meta( $this->author->ID, 'delete_meta_key' ) ); 
    5353    } 
    54      
     54 
    5555    function test_update_metadata_by_mid() { 
    5656        if ( ! function_exists( 'update_metadata_by_mid' ) || ! function_exists( 'get_metadata_by_mid') ) 
    5757            return; 
    58          
     58 
    5959        // Setup 
    6060        $meta = get_metadata_by_mid( 'user', $this->meta_id ); 
     
    6262        // Update the meta value 
    6363        $this->assertTrue( update_metadata_by_mid( 'user', $this->meta_id, 'meta_new_value' ) ); 
    64         $meta = get_metadata_by_mid( 'user', $this->meta_id );       
     64        $meta = get_metadata_by_mid( 'user', $this->meta_id ); 
    6565        $this->assertEquals( 'meta_new_value', $meta->meta_value ); 
    66          
     66 
    6767        // Update the meta value 
    6868        $this->assertTrue( update_metadata_by_mid( 'user', $this->meta_id, 'meta_new_value', 'meta_new_key' ) ); 
    6969        $meta = get_metadata_by_mid( 'user', $this->meta_id ); 
    7070        $this->assertEquals( 'meta_new_key', $meta->meta_key ); 
    71          
     71 
    7272        // Update the key and value 
    7373        $this->assertTrue( update_metadata_by_mid( 'user', $this->meta_id, 'meta_value', 'meta_key' ) ); 
     
    7575        $this->assertEquals( 'meta_key', $meta->meta_key ); 
    7676        $this->assertEquals( 'meta_value', $meta->meta_value ); 
    77          
     77 
    7878        // Update the value that has to be serialized 
    7979        $this->assertTrue( update_metadata_by_mid( 'user', $this->meta_id, array( 'first', 'second' ) ) ); 
    8080        $meta = get_metadata_by_mid( 'user', $this->meta_id ); 
    8181        $this->assertEquals( array( 'first', 'second' ), $meta->meta_value ); 
    82          
     82 
    8383        // Let's try some invalid meta data 
    8484        $this->assertFalse( update_metadata_by_mid( 'user', 0, 'meta_value' ) ); 
    8585        $this->assertFalse( update_metadata_by_mid( 'user', $this->meta_id, 'meta_value', array('invalid', 'key' ) ) ); 
    86          
     86 
    8787        // Let's see if caches get cleared after updates. 
    8888        $meta = get_metadata_by_mid( 'user', $this->meta_id ); 
  • wp-testcase/test_includes_pluggable.php

    r366 r407  
    144144    function test_wp_mail_rfc2822_addresses() { 
    145145        $this->knownWPBug(17305); 
    146          
     146 
    147147        $to = "Name <address@tld.com>"; 
    148148        $from = "Another Name <another_address@different-tld.com>"; 
     
    180180    function test_wp_mail_multiple_rfc2822_to_addresses() { 
    181181        $this->knownWPBug(17305); 
    182          
     182 
    183183        $to = "Name <address@tld.com>, Another Name <another_address@different-tld.com>"; 
    184184        $subject = "RFC2822 Testing"; 
  • wp-testcase/test_includes_post.php

    r389 r407  
    4545        $this->assertEquals($post['post_author'], $out->post_author); 
    4646    } 
    47      
    48      
     47 
     48 
    4949    function test_vb_insert_future() { 
    5050        // insert a post with a future date, and make sure the status and cron schedule are correct 
     
    7878        $this->assertEquals($future_date, $this->_next_schedule_for_post('publish_future_post', $id)); 
    7979    } 
    80      
     80 
    8181    function test_vb_insert_future_over_dst() { 
    8282        // insert a post with a future date, and make sure the status and cron schedule are correct 
    83          
    84         // Some magic days - one dst one not  
     83 
     84        // Some magic days - one dst one not 
    8585        $future_date_1 = strtotime('June 21st +1 year'); 
    8686        $future_date_2 = strtotime('Jan 11th +1 year'); 
    87                  
     87 
    8888 
    8989        $post = array( 
     
    119119 
    120120        // and the correct date on the cron job 
    121         $this->assertEquals($future_date_2, $this->_next_schedule_for_post('publish_future_post', $id));         
    122     }    
     121        $this->assertEquals($future_date_2, $this->_next_schedule_for_post('publish_future_post', $id)); 
     122    } 
    123123 
    124124function test_vb_insert_future_edit_bug() { 
     
    194194        // there should be a publish_future_post hook scheduled on the future date 
    195195        $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id)); 
    196          
     196 
    197197    } 
    198198 
     
    240240 
    241241        $statuses = array('draft', 'static', 'object', 'attachment', 'inherit', 'pending'); 
    242          
     242 
    243243        foreach ($statuses as $status) { 
    244244            $post = array( 
     
    346346        $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id)); 
    347347    } 
    348              
     348 
    349349    function test_delete_future_post_cron() { 
    350350        // http://trac.wordpress.org/ticket/5364 
    351351        // "When I delete a future post using wp_delete_post($post->ID) it does not update the cron correctly." 
    352          
     352 
    353353        #$this->knownWPBug(5364); 
    354          
     354 
    355355        $future_date = strtotime('+1 day'); 
    356356 
     
    364364 
    365365        // insert a post and make sure the ID is ok 
    366         $id = $this->post_ids[] = wp_insert_post($post);         
     366        $id = $this->post_ids[] = wp_insert_post($post); 
    367367 
    368368        // check that there's a publish_future_post job scheduled at the right time 
     
    371371        // now delete the post and make sure the cron entry is removed 
    372372        wp_delete_post($id); 
    373          
     373 
    374374        $this->assertFalse($this->_next_schedule_for_post('publish_future_post', $id)); 
    375375    } 
     
    378378        // bug: permalink doesn't work if post title is empty 
    379379        // wpcom #663, also http://trac.wordpress.org/ticket/5305 
    380          
     380 
    381381        global $wp_rewrite; 
    382382        $wp_rewrite->set_permalink_structure('/%year%/%monthnum%/%day%/%postname%/'); 
     
    400400        $wp_rewrite->set_permalink_structure(''); 
    401401    } 
    402      
     402 
    403403    function test_attachment_url() { 
    404404    } 
     
    406406 
    407407class WPTestAttachments extends _WPEmptyBlog { 
    408      
     408 
    409409    function tearDown() { 
    410410        parent::tearDown(); 
     
    415415        update_option('thumbnail_size_h', 150); 
    416416    } 
    417      
     417 
    418418    function _make_attachment($upload, $parent_post_id=-1) { 
    419          
     419 
    420420        $type = ''; 
    421421        if ( !empty($upload['type']) ) 
     
    426426                $type = $mime['type']; 
    427427        } 
    428          
     428 
    429429        $attachment = array( 
    430430            'post_title' => basename( $upload['file'] ), 
     
    439439        $id = wp_insert_attachment( $attachment, $upload[ 'file' ], $parent_post_id ); 
    440440        wp_update_attachment_metadata( $id, wp_generate_attachment_metadata( $id, $upload['file'] ) ); 
    441          
     441 
    442442        return $this->ids[] = $id; 
    443          
    444     } 
    445      
     443 
     444    } 
     445 
    446446    function test_insert_bogus_image() { 
    447447        $filename = rand_str().'.jpg'; 
    448448        $contents = rand_str(); 
    449          
     449 
    450450        $upload = wp_upload_bits($filename, 'image/jpeg', $contents); 
    451451        $this->assertTrue( empty($upload['error']) ); 
    452          
     452 
    453453        $id = $this->_make_attachment($upload); 
    454454    } 
    455      
     455 
    456456    function test_insert_image_no_thumb() { 
    457          
     457 
    458458        // this image is smaller than the thumbnail size so it won't have one 
    459459        $filename = ( DIR_TESTDATA.'/images/test-image.jpg' ); 
    460460        $contents = file_get_contents($filename); 
    461          
     461 
    462462        $upload = wp_upload_bits($filename, 'image/jpeg', $contents); 
    463463        $this->assertTrue( empty($upload['error']) ); 
     
    471471        // the thumb url should point to the thumbnail intermediate 
    472472        $this->assertEquals( $thumb['url'], wp_get_attachment_thumb_url($id) ); 
    473          
     473 
    474474        // image_downsize() should return the correct images and sizes 
    475475        $this->assertFalse( image_downsize($id, 'thumbnail') ); 
     
    489489 
    490490    function test_insert_image_default_thumb() { 
    491          
     491 
    492492        // this image is smaller than the thumbnail size so it won't have one 
    493493        $filename = ( DIR_TESTDATA.'/images/a2-small.jpg' ); 
    494494        $contents = file_get_contents($filename); 
    495          
     495 
    496496        $upload = wp_upload_bits($filename, 'image/jpeg', $contents); 
    497497        $this->assertTrue( empty($upload['error']) ); 
     
    503503        $this->assertEquals( 'a2-small-150x150.jpg', $thumb['file'] ); 
    504504        $this->assertTrue( is_file($thumb['path']) ); 
    505          
     505 
    506506        $this->assertFalse( image_get_intermediate_size($id, 'medium') ); 
    507507 
    508508        // the thumb url should point to the thumbnail intermediate 
    509509        $this->assertEquals( $thumb['url'], wp_get_attachment_thumb_url($id) ); 
    510          
     510 
    511511        // image_downsize() should return the correct images and sizes 
    512512        $downsize = image_downsize($id, 'thumbnail'); 
     
    532532        update_option('medium_size_w', '400'); 
    533533        update_option('medium_size_h', ''); 
    534          
     534 
    535535        // this image is smaller than the thumbnail size so it won't have one 
    536536        $filename = ( DIR_TESTDATA.'/images/2007-06-17DSC_4173.JPG' ); 
    537537        $contents = file_get_contents($filename); 
    538          
     538 
    539539        $upload = wp_upload_bits($filename, 'image/jpeg', $contents); 
    540540        $this->assertTrue( empty($upload['error']) ); 
    541541 
    542542        $id = $this->_make_attachment($upload); 
    543              
     543 
    544544        // intermediate copies should exist: thumbnail and medium 
    545545        $thumb = image_get_intermediate_size($id, 'thumbnail'); 
     
    550550        $this->assertEquals( '2007-06-17dsc_4173-400x602.jpg', $medium['file'] ); 
    551551        $this->assertTrue( is_file($medium['path']) ); 
    552          
     552 
    553553        // the thumb url should point to the thumbnail intermediate 
    554554        $this->assertEquals( $thumb['url'], wp_get_attachment_thumb_url($id) ); 
    555          
     555 
    556556        // image_downsize() should return the correct images and sizes 
    557557        $downsize = image_downsize($id, 'thumbnail'); 
     
    559559        $this->assertEquals( 150, $downsize[1] ); 
    560560        $this->assertEquals( 150, $downsize[2] ); 
    561          
     561 
    562562        $downsize = image_downsize($id, 'medium'); 
    563563        $this->assertEquals( '2007-06-17dsc_4173-400x602.jpg', basename($downsize[0]) ); 
    564564        $this->assertEquals( 400, $downsize[1] ); 
    565565        $this->assertEquals( 602, $downsize[2] ); 
    566          
     566 
    567567        $downsize = image_downsize($id, 'full'); 
    568568        $this->assertEquals( '2007-06-17dsc_4173.jpg', basename($downsize[0]) ); 
     
    576576        update_option('medium_size_w', '400'); 
    577577        update_option('medium_size_h', ''); 
    578          
     578 
    579579        // this image is smaller than the thumbnail size so it won't have one 
    580580        $filename = ( DIR_TESTDATA.'/images/2007-06-17DSC_4173.JPG' ); 
    581581        $contents = file_get_contents($filename); 
    582          
     582 
    583583        $upload = wp_upload_bits($filename, 'image/jpeg', $contents); 
    584584        $this->assertTrue( empty($upload['error']) ); 
    585585 
    586586        $id = $this->_make_attachment($upload); 
    587          
     587 
    588588        // check that the file and intermediates exist 
    589589        $thumb = image_get_intermediate_size($id, 'thumbnail'); 
     
    598598        $original = $meta['file']; 
    599599        $this->assertTrue( is_file($original) ); 
    600          
     600 
    601601        // now delete the attachment and make sure all files are gone 
    602602        wp_delete_attachment($id); 
     
    612612    function setUp() { 
    613613        parent::setUp(); 
    614          
     614 
    615615        $this->author = get_userdatabylogin(WP_USER_NAME); 
    616          
     616 
    617617        $post = array( 
    618618            'post_author' => $this->author->ID, 
     
    625625        $this->post_id = wp_insert_post($post); 
    626626 
    627          
     627 
    628628        $post = array( 
    629629            'post_author' => $this->author->ID, 
     
    646646        // Add a unique post meta item 
    647647        $this->assertInternalType( 'integer', add_post_meta($this->post_id, 'unique', 'value', true) ); 
    648          
     648 
    649649        // Check unique is enforced 
    650650        $this->assertFalse(add_post_meta($this->post_id, 'unique', 'another value', true)); 
    651          
     651 
    652652        //Check it exists 
    653653        $this->assertEquals('value', get_post_meta($this->post_id, 'unique', true)); 
    654654        $this->assertEquals(array('value'), get_post_meta($this->post_id, 'unique', false)); 
    655          
     655 
    656656        //Fail to delete the wrong value 
    657657        $this->assertFalse(delete_post_meta($this->post_id, 'unique', 'wrong value')); 
    658          
     658 
    659659        //Delete it 
    660660        $this->assertTrue(delete_post_meta($this->post_id, 'unique', 'value')); 
     
    663663        $this->assertEquals('', get_post_meta($this->post_id, 'unique', true)); 
    664664        $this->assertEquals(array(), get_post_meta($this->post_id, 'unique', false)); 
    665          
    666     } 
    667      
     665 
     666    } 
     667 
    668668    function test_nonunique_postmeta() { 
    669669        // Add two non unique post meta item 
    670670        $this->assertInternalType( 'integer', add_post_meta($this->post_id, 'nonunique', 'value') ); 
    671671        $this->assertInternalType( 'integer', add_post_meta($this->post_id, 'nonunique', 'another value')); 
    672          
     672 
    673673        //Check they exists 
    674674        $this->assertEquals('value', get_post_meta($this->post_id, 'nonunique', true)); 
    675675        $this->assertEquals(array('value', 'another value'), get_post_meta($this->post_id, 'nonunique', false)); 
    676          
     676 
    677677        //Fail to delete the wrong value 
    678678        $this->assertFalse(delete_post_meta($this->post_id, 'nonunique', 'wrong value')); 
    679          
     679 
    680680        //Delete the first one 
    681681        $this->assertTrue(delete_post_meta($this->post_id, 'nonunique', 'value')); 
     
    684684        $this->assertEquals('another value', get_post_meta($this->post_id, 'nonunique', true)); 
    685685        $this->assertEquals(array('another value'), get_post_meta($this->post_id, 'nonunique', false)); 
    686          
     686 
    687687        //Add a third one 
    688688        $this->assertInternalType( 'integer', add_post_meta($this->post_id, 'nonunique', 'someother value') ); 
    689          
     689 
    690690        //Check they exists 
    691691        $this->assertEquals('someother value', get_post_meta($this->post_id, 'nonunique', true)); 
    692692        $this->assertEquals(array('someother value', 'another value'), get_post_meta($this->post_id, 'nonunique', false)); 
    693          
     693 
    694694        //Delete the lot 
    695695        $this->assertTrue(delete_post_meta_by_key('nonunique')); 
    696696    } 
    697      
     697 
    698698    function test_update_post_meta() { 
    699699        // Add a unique post meta item 
     
    709709        $this->assertEquals('value', get_post_meta($this->post_id, 'nonunique_update', true)); 
    710710        $this->assertEquals(array('value', 'another value'), get_post_meta($this->post_id, 'nonunique_update', false)); 
    711          
     711 
    712712        // Update them 
    713713        $this->assertTrue(update_post_meta($this->post_id, 'unique_update', 'new', 'value')); 
     
    720720        $this->assertEquals('new', get_post_meta($this->post_id, 'nonunique_update', true)); 
    721721        $this->assertEquals(array('new', 'another new'), get_post_meta($this->post_id, 'nonunique_update', false)); 
    722          
    723     } 
    724      
     722 
     723    } 
     724 
    725725    function test_delete_post_meta() { 
    726726        // Add a unique post meta item 
     
    731731        $this->assertEquals('value', get_post_meta($this->post_id, 'unique_delete', true)); 
    732732        $this->assertEquals('value', get_post_meta($this->post_id_2, 'unique_delete', true)); 
    733      
     733 
    734734        //Delete one of them 
    735735        $this->assertTrue(delete_post_meta($this->post_id, 'unique_delete', 'value')); 
     
    738738        $this->assertEquals('value', get_post_meta($this->post_id_2, 'unique_delete', true)); 
    739739 
    740          
     740 
    741741    } 
    742742 
     
    749749        $this->assertEquals('value', get_post_meta($this->post_id, 'unique_delete_by_key', true)); 
    750750        $this->assertEquals('value', get_post_meta($this->post_id_2, 'unique_delete_by_key', true)); 
    751      
     751 
    752752        //Delete one of them 
    753753        $this->assertTrue(delete_post_meta_by_key('unique_delete_by_key')); 
     
    801801        $this->assertEquals('value', get_post_meta($this->post_id, 'nonunique_update', true)); 
    802802        $this->assertEquals(array('value', 'another value'), get_post_meta($this->post_id, 'nonunique_update', false)); 
    803          
     803 
    804804        // Update them 
    805805        $this->assertTrue( update_meta( $mid1, 'unique_update', 'new' ) ); 
     
    822822    function test_funky_post_meta() { 
    823823        $this->knownWPBug(12860); 
    824          
     824 
    825825        $classy = new StdClass(); 
    826826        $classy->ID = 1; 
    827827        $classy->stringy = "I love slashes\\\\"; 
    828828        $funky_meta[] = $classy; 
    829          
     829 
    830830        $classy = new StdClass(); 
    831831        $classy->ID = 2; 
    832832        $classy->stringy = "I love slashes\\\\ more"; 
    833833        $funky_meta[] = $classy; 
    834          
     834 
    835835        // Add a post meta item 
    836836        $this->assertInternalType( 'integer', add_post_meta($this->post_id, 'test_funky_post_meta', $funky_meta, true) ); 
     
    838838        //Check they exists 
    839839        $this->assertEquals($funky_meta, get_post_meta($this->post_id, 'test_funky_post_meta', true)); 
    840      
     840 
    841841    } 
    842842} 
  • wp-testcase/test_includes_taxonomy.php

    r396 r407  
    66        $this->assertEquals(array('category', 'post_tag', 'post_format'), get_object_taxonomies('post')); 
    77    } 
    8      
     8 
    99    function test_get_link_taxonomies() { 
    1010        $this->assertEquals(array('link_category'), get_object_taxonomies('link')); 
    1111    } 
    12      
     12 
    1313    function test_get_unknown_taxonomies() { 
    1414        // taxonomies for an unknown object type 
     
    1919        $this->assertEquals( array(), get_object_taxonomies(NULL) ); 
    2020    } 
    21      
     21 
    2222    function test_get_post_taxonomy() { 
    2323        foreach ( get_object_taxonomies('post') as $taxonomy ) { 
     
    4545        $this->assertTrue( is_taxonomy('link_category') ); 
    4646    } 
    47      
     47 
    4848    function test_is_taxonomy_unknown() { 
    4949        $this->assertFalse( is_taxonomy(rand_str()) ); 
     
    5252        $this->assertFalse( is_taxonomy(NULL) ); 
    5353    } 
    54      
     54 
    5555    function test_is_taxonomy_hierarchical() { 
    5656        $this->assertTrue( is_taxonomy_hierarchical('category') ); 
     
    5858        $this->assertFalse( is_taxonomy_hierarchical('link_category') ); 
    5959    } 
    60      
     60 
    6161    function test_is_taxonomy_hierarchical_unknown() { 
    6262        $this->assertFalse( is_taxonomy_hierarchical(rand_str()) ); 
     
    6565        $this->assertFalse( is_taxonomy_hierarchical(NULL) ); 
    6666    } 
    67      
     67 
    6868    function test_register_taxonomy() { 
    69          
     69 
    7070        // make up a new taxonomy name, and ensure it's unused 
    7171        $tax = rand_str(); 
    7272        $this->assertFalse( is_taxonomy($tax) ); 
    73          
     73 
    7474        register_taxonomy( $tax, 'post' ); 
    7575        $this->assertTrue( is_taxonomy($tax) ); 
    76         $this->assertFalse( is_taxonomy_hierarchical($tax) );        
    77          
     76        $this->assertFalse( is_taxonomy_hierarchical($tax) ); 
     77 
    7878        // clean up 
    7979        unset($GLOBALS['wp_taxonomies'][$tax]); 
    8080    } 
    81      
     81 
    8282    function test_register_hierarchical_taxonomy() { 
    83          
     83 
    8484        // make up a new taxonomy name, and ensure it's unused 
    8585        $tax = rand_str(); 
    8686        $this->assertFalse( is_taxonomy($tax) ); 
    87          
     87 
    8888        register_taxonomy( $tax, 'post', array('hierarchical'=>true) ); 
    8989        $this->assertTrue( is_taxonomy($tax) ); 
    90         $this->assertTrue( is_taxonomy_hierarchical($tax) );         
    91          
     90        $this->assertTrue( is_taxonomy_hierarchical($tax) ); 
     91 
    9292        // clean up 
    9393        unset($GLOBALS['wp_taxonomies'][$tax]); 
     
    9797class TestTermAPI extends _WPEmptyBlog { 
    9898    var $taxonomy = 'category'; 
    99      
     99 
    100100    function setUp() { 
    101101        parent::setUp(); 
     
    106106            wp_insert_term( $term, $tax ); 
    107107    } 
    108      
     108 
    109109    function test_wp_insert_delete_term() { 
    110110        // a new unused term 
    111111        $term = rand_str(); 
    112112        $this->assertNull( is_term($term) ); 
    113          
     113 
    114114        $initial_count = wp_count_terms( $this->taxonomy ); 
    115          
     115 
    116116        $t = wp_insert_term( $term, $this->taxonomy ); 
    117117        $this->assertTrue( is_array($t) ); 
     
    120120        $this->assertTrue( $t['term_taxonomy_id'] > 0 ); 
    121121        $this->assertEquals( $initial_count + 1, wp_count_terms($this->taxonomy) ); 
    122          
     122 
    123123        // make sure the term exists 
    124124        $this->assertTrue( is_term($term) > 0 ); 
    125125        $this->assertTrue( is_term($t['term_id']) > 0 ); 
    126          
     126 
    127127        // now delete it 
    128128        $this->assertTrue( wp_delete_term($t['term_id'], $this->taxonomy) ); 
     
    131131        $this->assertEquals( $initial_count, wp_count_terms($this->taxonomy) ); 
    132132    } 
    133      
     133 
    134134    function test_is_term_known() { 
    135135        // insert a term 
    136136        $term = rand_str(); 
    137137        $t = wp_insert_term( $term, $this->taxonomy ); 
    138          
     138 
    139139        $this->assertEquals( $t['term_id'], is_term($t['term_id']) ); 
    140140        $this->assertEquals( $t['term_id'], is_term($term) ); 
    141          
     141 
    142142        // clean up 
    143143        $this->assertTrue( wp_delete_term($t['term_id'], $this->taxonomy) ); 
    144144    } 
    145      
     145 
    146146    function test_is_term_unknown() { 
    147147        $this->assertNull( is_term(rand_str()) ); 
     
    150150        $this->assertEquals( 0, is_term(NULL) ); 
    151151    } 
    152      
     152 
    153153    function test_is_term_type() { 
    154154        // insert a term 
     
    163163        $this->assertTrue( wp_delete_term($t['term_id'], $this->taxonomy) ); 
    164164    } 
    165      
     165 
    166166    function test_set_object_terms_by_id() { 
    167167        $this->_insert_quick_posts(5); 
    168              
     168 
    169169        $terms = array(); 
    170170        for ($i=0; $i<3; $i++ ) { 
     
    173173            $term_id[$term] = $result['term_id']; 
    174174        } 
    175          
     175 
    176176        foreach ($this->post_ids as $id) { 
    177177                $tt = wp_set_object_terms( $id, array_values($term_id), $this->taxonomy ); 
     
    185185            $this->assertEquals( $this->post_ids, array_map('intval', $actual) ); 
    186186        } 
    187          
     187 
    188188        // each term should have a count of 5 
    189189        foreach (array_keys($term_id) as $term) { 
     
    192192        } 
    193193    } 
    194      
     194 
    195195    function test_set_object_terms_by_name() { 
    196196        $this->_insert_quick_posts(5); 
    197              
     197 
    198198        $terms = array( 
    199199                rand_str(), 
    200200                rand_str(), 
    201201                rand_str()); 
    202                  
     202 
    203203        foreach ($this->post_ids as $id) { 
    204204                $tt = wp_set_object_terms( $id, $terms, $this->taxonomy ); 
     
    217217            $this->assertEquals( $this->post_ids, array_map('intval', $actual) ); 
    218218        } 
    219          
     219 
    220220        // each term should have a count of 5 
    221221        foreach ($terms as $term) { 
     
    224224        } 
    225225    } 
    226      
     226 
    227227    function test_change_object_terms_by_name() { 
    228228        // set some terms on an object; then change them while leaving one intact 
    229          
     229 
    230230        $this->_insert_quick_posts(1); 
    231231        $post_id = end($this->post_ids); 
     
    233233        $terms_1 = array('foo', 'bar', 'baz'); 
    234234        $terms_2 = array('bar', 'bing'); 
    235          
     235 
    236236        // set the initial terms 
    237237        $tt_1 = wp_set_object_terms( $post_id, $terms_1, $this->taxonomy ); 
     
    241241        $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 't.term_id')); 
    242242        $this->assertEquals( $terms_1, $terms ); 
    243          
     243 
    244244        // change the terms 
    245245        $tt_2 = wp_set_object_terms( $post_id, $terms_2, $this->taxonomy ); 
     
    249249        $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'names', 'orderby' => 't.term_id')); 
    250250        $this->assertEquals( $terms_2, $terms ); 
    251          
     251 
    252252        // make sure the tt id for 'bar' matches 
    253253        $this->assertEquals( $tt_1[1], $tt_2[0] ); 
    254          
     254 
    255255    } 
    256256 
    257257    function test_change_object_terms_by_id() { 
    258258        // set some terms on an object; then change them while leaving one intact 
    259          
     259 
    260260        $this->_insert_quick_posts(1); 
    261261        $post_id = end($this->post_ids); 
     
    272272        $terms_2 = array(); 
    273273        $terms_2[0] = $terms_1[1]; 
    274          
     274 
    275275        $term = rand_str(); 
    276276        $result = wp_insert_term( $term, $this->taxonomy ); 
    277277        $terms_2[1] = $result['term_id']; 
    278278 
    279          
     279 
    280280        // set the initial terms 
    281281        $tt_1 = wp_set_object_terms( $post_id, $terms_1, $this->taxonomy ); 
     
    285285        $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 't.term_id')); 
    286286        $this->assertEquals( $terms_1, $terms ); 
    287          
     287 
    288288        // change the terms 
    289289        $tt_2 = wp_set_object_terms( $post_id, $terms_2, $this->taxonomy ); 
     
    293293        $terms = wp_get_object_terms($post_id, $this->taxonomy, array('fields' => 'ids', 'orderby' => 't.term_id')); 
    294294        $this->assertEquals( $terms_2, $terms ); 
    295          
     295 
    296296        // make sure the tt id for 'bar' matches 
    297297        $this->assertEquals( $tt_1[1], $tt_2[0] ); 
    298          
    299     } 
    300      
     298 
     299    } 
     300 
    301301    function test_set_object_terms_invalid() { 
    302302        $this->_insert_quick_posts(1); 
     
    307307        $this->assertTrue( is_wp_error($result) ); 
    308308    } 
    309      
     309 
    310310} 
    311311 
  • wp-testcase/test_includes_wp-scripts.php

    r366 r407  
    22class TestWP_Scripts extends WPTestCase { 
    33    var $old_wp_scripts; 
    4      
     4 
    55    function setUp() { 
    66        parent::setUp(); 
     
    99        $GLOBALS['wp_scripts'] = new WP_Scripts(); 
    1010        $GLOBALS['wp_scripts']->default_version = get_bloginfo( 'version' ); 
    11          
     11 
    1212    } 
    13      
     13 
    1414    function tearDown() { 
    1515        $GLOBALS['wp_scripts'] = $this->old_wp_scripts; 
     
    1717        parent::tearDown(); 
    1818    } 
    19      
     19 
    2020    // Test versioning 
    2121    function test_wp_enqueue_script() { 
  • wp-testcase/test_meta.php

    r366 r407  
    44class WPTestMeta extends WPTestCase { 
    55    var $val; 
    6      
     6 
    77    function setUp() { 
    88        parent::setUp(); 
     
    2323        global $test_foo; 
    2424        $test_foo = array('foo', 'bar', 'baz'); 
    25          
     25 
    2626        function test_globals_foo() { 
    2727            unset($GLOBALS['test_foo'][1]); 
    2828        } 
    29          
     29 
    3030        test_globals_foo(); 
    31          
     31 
    3232        $this->assertEquals($test_foo, array(0=>'foo', 2=>'baz')); 
    3333        $this->assertEquals($test_foo, $GLOBALS['test_foo']); 
    3434    } 
    35      
     35 
    3636    function test_globals_bar() { 
    3737        global $test_bar; 
     
    3939        $this->assertEquals($test_bar, $GLOBALS['test_bar']); 
    4040    } 
    41      
     41 
    4242} 
    4343 
     
    4949        $this->assertEquals('foo', strip_ws('foo')); 
    5050        $this->assertEquals('', strip_ws("\r\n\t  \n\r\t")); 
    51          
     51 
    5252        $in = <<<EOF 
    5353asdf 
     
    7575 
    7676    } 
    77      
     77 
    7878    function test_mask_input_value() { 
    7979        $in = <<<EOF 
  • wp-testcase/test_post_filtering.php

    r366 r407  
    1010        update_option('use_balanceTags', 1); 
    1111        kses_init_filters(); 
    12          
    13     } 
    14      
     12 
     13    } 
     14 
    1515    function tearDown() { 
    1616        parent::tearDown(); 
    1717        kses_remove_filters(); 
    1818    } 
    19      
     19 
    2020    function _insert_quick_post($title, $content, $more=array()) { 
    2121        return $this->post_ids[] = wp_insert_post(array_merge(array( 
     
    2626            ), $more)); 
    2727    } 
    28      
     28 
    2929    // a simple test to make sure unclosed tags are fixed 
    3030    function test_post_content_unknown_tag() { 
    31          
     31 
    3232        $content = <<<EOF 
    3333<foobar>no such tag</foobar> 
     
    4040        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    4141        $post = get_post($id); 
    42          
    43         $this->assertEquals( $expected, $post->post_content ); 
    44     } 
    45      
     42 
     43        $this->assertEquals( $expected, $post->post_content ); 
     44    } 
     45 
    4646    // a simple test to make sure unbalanced tags are fixed 
    4747    function test_post_content_unbalanced_tag() { 
    48          
     48 
    4949        $content = <<<EOF 
    5050<i>italics 
     
    5757        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    5858        $post = get_post($id); 
    59          
     59 
    6060        $this->assertEquals( $expected, $post->post_content ); 
    6161    } 
     
    6363    // test kses filtering of disallowed attribute 
    6464    function test_post_content_disallowed_attr() { 
    65          
     65 
    6666        $content = <<<EOF 
    6767<img src='foo' width='500' href='shlorp' /> 
     
    7474        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    7575        $post = get_post($id); 
    76          
     76 
    7777        $this->assertEquals( $expected, $post->post_content ); 
    7878    } 
     
    8181    // empty element 
    8282    function test_post_content_xhtml_empty_elem() { 
    83         $this->knownWPBug( 12394 );      
     83        $this->knownWPBug( 12394 ); 
    8484        $content = <<<EOF 
    8585<img src='foo' width='500' height='300'/> 
     
    9292        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    9393        $post = get_post($id); 
    94          
     94 
    9595        $this->assertEquals( $expected, $post->post_content ); 
    9696    } 
     
    9898    // make sure unbalanced tags are fixed when they span a --more-- tag 
    9999    function test_post_content_unbalanced_more() { 
    100          
     100 
    101101        $content = <<<EOF 
    102102<em>some text<!--more--> 
     
    111111        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    112112        $post = get_post($id); 
    113          
     113 
    114114        $this->assertEquals( $expected, $post->post_content ); 
    115115    } 
     
    117117    // make sure unbalanced tags are fixed when they span a --nextpage-- tag 
    118118    function test_post_content_unbalanced_nextpage() { 
    119          
     119 
    120120        $content = <<<EOF 
    121121<em>some text<!--nextpage--> 
     
    130130        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    131131        $post = get_post($id); 
    132          
     132 
    133133        $this->assertEquals( $expected, $post->post_content ); 
    134134    } 
     
    136136    // make sure unbalanced tags are fixed when they span both --more-- and --nextpage-- tags (in that order) 
    137137    function test_post_content_unbalanced_more_nextpage() { 
    138          
     138 
    139139        $content = <<<EOF 
    140140<em>some text<!--more--> 
     
    157157        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    158158        $post = get_post($id); 
    159          
    160         $this->assertEquals( $expected, $post->post_content ); 
    161     } 
    162      
     159 
     160        $this->assertEquals( $expected, $post->post_content ); 
     161    } 
     162 
    163163    // make sure unbalanced tags are fixed when they span both --nextpage-- and --more-- tags (in that order) 
    164164    function test_post_content_unbalanced_nextpage_more() { 
    165          
     165 
    166166        $content = <<<EOF 
    167167<em>some text<!--nextpage--> 
     
    184184        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    185185        $post = get_post($id); 
    186          
    187         $this->assertEquals( $expected, $post->post_content ); 
    188     } 
    189      
     186 
     187        $this->assertEquals( $expected, $post->post_content ); 
     188    } 
     189 
    190190    // make sure unbalanced tags are untouched when the balance option is off 
    191191    function test_post_content_nobalance_nextpage_more() { 
    192192 
    193193        update_option('use_balanceTags', 0); 
    194          
     194 
    195195        $content = <<<EOF 
    196196<em>some text<!--nextpage--> 
     
    204204        $id = $this->_insert_quick_post(__FUNCTION__, $content); 
    205205        $post = get_post($id); 
    206          
     206 
    207207        $this->assertEquals( $content, $post->post_content ); 
    208     }        
     208    } 
    209209} 
    210210 
  • wp-testcase/test_post_output.php

    r366 r407  
    9898[paragraph]my graf[/paragraph] 
    9999 
    100   [paragraph foo="bar"]another graf with whitespace[/paragraph]   
     100  [paragraph foo="bar"]another graf with whitespace[/paragraph] 
    101101 
    102102An [paragraph]inline graf[/paragraph], this doesn't make much sense. 
     
    137137        $wp_rewrite->flush_rules(); 
    138138    } 
    139      
     139 
    140140    function test_the_content() { 
    141141        // permalink page 
     
    144144        // filtered output 
    145145        $out = get_echo('the_content'); 
    146          
     146 
    147147        $expected = <<<EOF 
    148148<p>There are ten images attached to this post.  Here&#8217;s a gallery:</p> 
     
    207207    function test_gallery_attributes() { 
    208208        // make sure the gallery shortcode attributes are parsed correctly 
    209          
     209 
    210210        $id = 575; 
    211211        $post = get_post($id); 
    212212        $post->post_content = '[gallery columns="1" size="medium"]'; 
    213213        wp_update_post($post); 
    214          
     214 
    215215        // permalink page 
    216216        $this->http('/2008/04/01/simple-gallery-test/'); 
  • wp-testcase/test_query.php

    r366 r407  
    5656        $passed = true; 
    5757        $not_false = $not_true = array(); // properties that were not set to expected values 
    58          
     58 
    5959        foreach ( $all as $query_thing ) { 
    6060            $result = is_callable( $query_thing ) ? call_user_func( $query_thing ) : $wp_query->$query_thing; 
     
    426426        $this->assertQueryTrue('is_archive', 'is_day', 'is_date'); 
    427427    } 
    428      
     428 
    429429    // '([0-9]{4})/([0-9]{1,2})/feed/(feed|rdf|rss|rss2|atom)/?$' => 'index.php?year=$matches[1]&monthnum=$matches[2]&feed=$matches[3]', 
    430430    // '([0-9]{4})/([0-9]{1,2})/(feed|rdf|rss|rss2|atom)/?$' => 'index.php?year=$matches[1]&monthnum=$matches[2]&feed=$matches[3]', 
     
    502502        foreach ($this->_all_post_ids() as $id) { 
    503503            $permalink = get_permalink($id); 
    504              
     504 
    505505            $types = array('feed', 'rdf', 'rss', 'rss2', 'atom'); 
    506506            foreach ($types as $type) { 
     
    535535        // should is_paged be true also? 
    536536        $this->assertQueryTrue('is_single', 'is_singular'); 
    537          
    538     } 
    539      
     537 
     538    } 
     539 
    540540    // '[0-9]{4}/[0-9]{1,2}/[0-9]{1,2}/[^/]+/([^/]+)/?$' => 'index.php?attachment=$matches[1]', 
    541541    function test_post_attachment() { 
  • wp-testcase/test_uploads.php

    r399 r407  
    44 
    55class TestUploadFunctions extends WPTestCase { 
    6      
     6 
    77    var $siteurl = 'http://example.com/foo'; 
    8      
     8 
    99    function setUp() { 
    1010        update_option( 'siteurl', $this->siteurl ); 
     
    1313        update_option( 'upload_url_path', '' ); 
    1414        update_option( 'uploads_use_yearmonth_folders', 1 ); 
    15          
     15 
    1616    } 
    17      
     17 
    1818    function test_upload_dir_default() { 
    1919        // wp_upload_dir() with default parameters 
     
    2424        $this->assertEquals( '', $info['error'] ); 
    2525    } 
    26      
     26 
    2727    function test_upload_dir_relative() { 
    2828        // wp_upload_dir() with a relative upload path 
     
    3434        $this->assertEquals( '', $info['error'] ); 
    3535    } 
    36      
     36 
    3737    function test_upload_dir_absolute() { 
    3838        $this->knownWPBug(5953); 
     
    4747        $this->assertEquals( '', $info['error'] ); 
    4848    } 
    49      
     49 
    5050    function test_upload_dir_no_yearnum() { 
    5151        update_option( 'uploads_use_yearmonth_folders', 0 ); 
     
    5656        $this->assertEquals( '', $info['error'] ); 
    5757    } 
    58      
     58 
    5959    function test_upload_path_absolute() { 
    6060        update_option( 'upload_url_path', 'http://example.org/asdf' ); 
     
    6565        $this->assertEquals( '', $info['error'] ); 
    6666    } 
    67      
     67 
    6868    function test_upload_dir_empty() { 
    6969        // upload path setting is empty - it should default to 'wp-content/uploads' 
     
    7575        $this->assertEquals( '', $info['error'] ); 
    7676    } 
    77      
     77 
    7878} 
    7979 
  • wp-testcase/test_user.php

    r406 r407  
    113113        // there is already some stuff in the array 
    114114        $this->assertTrue(is_array(get_usermeta($user_id))); 
    115          
     115 
    116116        foreach ($vals as $k=>$v) 
    117117            update_usermeta( $user_id, $k, $v ); 
    118          
     118 
    119119        // get the complete usermeta array 
    120120        $out = get_usermeta($user_id); 
     
    124124        foreach ($vals as $v) 
    125125            $this->assertTrue(in_array($v, $out)); 
    126              
     126 
    127127        // delete one key and check again 
    128128        $key_to_delete = array_pop(array_keys($vals)); 
  • wp-testcase/test_user_capabilities.php

    r377 r407  
    2020        foreach ($this->user_ids as $id) 
    2121            wp_delete_user($id); 
    22              
     22 
    2323    } 
    2424 
     
    9595        $this->assertFalse($user->has_cap('level_3')); 
    9696    } 
    97      
     97 
    9898    function test_user_contributor() { 
    9999        $id = $this->_make_user('contributor'); 
     
    149149        $user = new WP_User($id); 
    150150        $user->add_role('contributor'); 
    151          
     151 
    152152        // nuke and re-fetch the object to make sure it was stored 
    153153        $user = NULL; 
     
    168168        $this->assertFalse($user->has_cap('level_2')); 
    169169    } 
    170      
     170 
    171171    function test_add_empty_role() { 
    172172        // add_role($role, $display_name, $capabilities = '') 
     
    177177        $this->_flush_roles(); 
    178178        $this->assertTrue($wp_roles->is_role($role_name)); 
    179          
     179 
    180180        $id = $this->_make_user($role_name); 
    181          
    182         $user = new WP_User($id); 
    183          
     181 
     182        $user = new WP_User($id); 
     183 
    184184        $this->assertEquals(array($role_name), $user->roles); 
    185          
     185 
    186186        // user shouldn't have any capabilities; test a quick sample 
    187187        $this->assertFalse($user->has_cap('upload_files')); 
     
    195195        $this->assertFalse($wp_roles->is_role($role_name)); 
    196196    } 
    197      
    198      
     197 
     198 
    199199    function test_add_role() { 
    200200        // add_role($role, $display_name, $capabilities = '') 
     
    205205        $this->_flush_roles(); 
    206206        $this->assertTrue($wp_roles->is_role($role_name)); 
    207          
     207 
    208208        $id = $this->_make_user($role_name); 
    209          
    210         $user = new WP_User($id); 
    211          
     209 
     210        $user = new WP_User($id); 
     211 
    212212        $this->assertEquals(array($role_name), $user->roles); 
    213          
     213 
    214214        // the user should have all the above caps 
    215215        $this->assertTrue($user->has_cap($role_name)); 
     
    219219        $this->assertTrue($user->has_cap('level_1')); 
    220220        $this->assertTrue($user->has_cap('level_2')); 
    221          
     221 
    222222        // shouldn't have any other caps 
    223223        $this->assertFalse($user->has_cap('upload_files')); 
     
    231231        $this->assertFalse($wp_roles->is_role($role_name)); 
    232232    } 
    233      
     233 
    234234    function test_role_add_cap() { 
    235235        // change the capabilites associated with a role and make sure the change is reflected in has_cap() 
    236          
     236 
    237237        global $wp_roles; 
    238238        $role_name = rand_str(); 
     
    240240        $this->_flush_roles(); 
    241241        $this->assertTrue( $wp_roles->is_role($role_name) ); 
    242          
     242 
    243243        // assign a user to that role 
    244244        $id = $this->_make_user($role_name); 
    245          
     245 
    246246        // now add a cap to the role 
    247247        $wp_roles->add_cap($role_name, 'sweep_floor'); 
     
    255255        $this->assertTrue($user->has_cap('level_1')); 
    256256        $this->assertTrue($user->has_cap('sweep_floor')); 
    257          
     257 
    258258        // shouldn't have any other caps 
    259259        $this->assertFalse($user->has_cap('upload_files')); 
     
    266266        $this->_flush_roles(); 
    267267        $this->assertFalse($wp_roles->is_role($role_name)); 
    268          
    269     } 
    270      
     268 
     269    } 
     270 
    271271    function test_role_remove_cap() { 
    272272        // change the capabilites associated with a role and make sure the change is reflected in has_cap() 
    273          
     273 
    274274        global $wp_roles; 
    275275        $role_name = rand_str(); 
     
    277277        $this->_flush_roles(); 
    278278        $this->assertTrue( $wp_roles->is_role($role_name) ); 
    279          
     279 
    280280        // assign a user to that role 
    281281        $id = $this->_make_user($role_name); 
    282          
     282 
    283283        // now remove a cap from the role 
    284284        $wp_roles->remove_cap($role_name, 'polish_doorknobs'); 
     
    292292        $this->assertTrue($user->has_cap('level_1')); 
    293293        $this->assertTrue($user->has_cap('sweep_floor')); 
    294          
     294 
    295295        // shouldn't have the removed cap 
    296296        $this->assertFalse($user->has_cap('polish_doorknobs')); 
     
    300300        $this->_flush_roles(); 
    301301        $this->assertFalse($wp_roles->is_role($role_name)); 
    302          
     302 
    303303    } 
    304304 
    305305    function test_user_add_cap() { 
    306306        // add an extra capability to a user 
    307          
     307 
    308308        // there are two contributors 
    309309        $id_1 = $this->_make_user('contributor'); 
    310310        $id_2 = $this->_make_user('contributor'); 
    311          
     311 
    312312        // user 1 has an extra capability 
    313313        $user_1 = new WP_User($id_1); 
    314314        $user_1->add_cap('publish_posts'); 
    315          
     315 
    316316        // re-fetch both users from the db 
    317317        $user_1 = new WP_User($id_1); 
     
    325325        $this->assertTrue($user_1->has_cap('publish_posts')); 
    326326        $this->assertFalse($user_2->has_cap('publish_posts')); 
    327          
     327 
    328328        // make sure the other caps didn't get messed up 
    329329        $this->assertTrue($user_1->has_cap('edit_posts')); 
     
    339339    function test_user_remove_cap() { 
    340340        // add an extra capability to a user then remove it 
    341          
     341 
    342342        // there are two contributors 
    343343        $id_1 = $this->_make_user('contributor'); 
    344344        $id_2 = $this->_make_user('contributor'); 
    345          
     345 
    346346        // user 1 has an extra capability 
    347347        $user_1 = new WP_User($id_1); 
    348348        $user_1->add_cap('publish_posts'); 
    349          
     349 
    350350        // now remove the extra cap 
    351351        $user_1->remove_cap('publish_posts'); 
     
    361361        // check the removed cap on both users 
    362362        $this->assertFalse($user_1->has_cap('publish_posts')); 
    363         $this->assertFalse($user_2->has_cap('publish_posts'));       
    364  
    365     } 
    366          
     363        $this->assertFalse($user_2->has_cap('publish_posts')); 
     364 
     365    } 
     366 
    367367    function test_user_level_update() { 
    368368        // make sure the user_level is correctly set and changed with the user's role 
    369          
     369 
    370370        // user starts as an author 
    371371        $id = $this->_make_user('author'); 
    372372        $user = new WP_User($id); 
    373          
     373 
    374374        // author = user level 2 
    375375        $this->assertEquals( 2, $user->user_level ); 
    376          
     376 
    377377        // they get promoted to editor - level should get bumped to 7 
    378378        $user->set_role('editor'); 
    379379        $this->assertEquals( 7, $user->user_level ); 
    380          
     380 
    381381        // demoted to contributor - level is reduced to 1 
    382382        $user->set_role('contributor'); 
    383383        $this->assertEquals( 1, $user->user_level ); 
    384          
     384 
    385385        // if they have two roles, user_level should be the max of the two 
    386386        $user->add_role('editor'); 
     
    388388        $this->assertEquals( 7, $user->user_level ); 
    389389    } 
    390      
     390 
    391391    function test_user_remove_all_caps() { 
    392392        // user starts as an author 
    393393        $id = $this->_make_user('author'); 
    394394        $user = new WP_User($id); 
    395          
     395 
    396396        // add some extra capabilities 
    397397        $user->add_cap('make_coffee'); 
     
    400400        // re-fetch 
    401401        $user = new WP_User($id); 
    402          
     402 
    403403        $this->assertTrue($user->has_cap('make_coffee')); 
    404404        $this->assertTrue($user->has_cap('drink_coffee')); 
    405          
     405 
    406406        // all caps are removed 
    407407        $user->remove_all_caps(); 
    408          
     408 
    409409        // re-fetch 
    410410        $user = new WP_User($id); 
     
    422422        // user level should be empty 
    423423        $this->assertNull( $user->user_level ); 
    424          
    425          
     424 
     425 
    426426    } 
    427427 
    428428    function test_post_meta_caps() { 
    429429        // simple tests for some common meta capabilities 
    430          
     430 
    431431        // make a [pst 
    432432        $this->_insert_quick_posts(1); 
     
    436436        $author = new WP_User($this->author->ID); 
    437437        $author->set_role('author'); 
    438          
     438 
    439439        // add some other users 
    440440        $admin = new WP_User($this->_make_user('administrator')); 
     
    442442        $editor = new WP_User($this->_make_user('editor')); 
    443443        $contributor = new WP_User($this->_make_user('contributor')); 
    444          
     444 
    445445        // administrators, editors and the post owner can edit it 
    446446        $this->assertTrue($admin->has_cap('edit_post', $post)); 
     
    450450        $this->assertFalse($author_2->has_cap('edit_post', $post)); 
    451451        $this->assertFalse($contributor->has_cap('edit_post', $post)); 
    452          
     452 
    453453        // administrators, editors and the post owner can delete it 
    454454        $this->assertTrue($admin->has_cap('delete_post', $post)); 
     
    487487    function test_page_meta_caps() { 
    488488        // simple tests for some common meta capabilities 
    489          
     489 
    490490        // make a page 
    491491        $this->_insert_quick_pages(1); 
     
    495495        $author = new WP_User($this->author->ID); 
    496496        $author->set_role('author'); 
    497          
     497 
    498498        // add some other users 
    499499        $admin = new WP_User($this->_make_user('administrator')); 
     
    501501        $editor = new WP_User($this->_make_user('editor')); 
    502502        $contributor = new WP_User($this->_make_user('contributor')); 
    503          
     503 
    504504        // administrators, editors and the post owner can edit it 
    505505        $this->assertTrue($admin->has_cap('edit_page', $page)); 
     
    509509        $this->assertFalse($author_2->has_cap('edit_page', $page)); 
    510510        $this->assertFalse($contributor->has_cap('edit_page', $page)); 
    511          
     511 
    512512        // administrators, editors and the post owner can delete it 
    513513        $this->assertTrue($admin->has_cap('delete_page', $page)); 
     
    518518        $this->assertFalse($contributor->has_cap('delete_page', $page)); 
    519519    } 
    520      
     520 
    521521    function test_usermeta_caps() { 
    522522 
     
    524524 
    525525        // make sure an old style usermeta capabilities entry is still recognized by the new code 
    526          
     526 
    527527        $id = $this->_make_user('author'); 
    528528        $user = new WP_User($id); 
    529          
     529 
    530530        global $wpdb; 
    531531        if (!empty($wpdb->user_role)) 
    532532            $wpdb->query("DELETE FROM {$wpdb->user_role} WHERE user_id = {$id}"); 
    533          
     533 
    534534        update_usermeta($id, $user->cap_key, array('editor' => true)); 
    535535 
     
    550550 
    551551    function test_upgrade() { 
    552          
     552 
    553553        // only relevant with this patch 
    554554        $this->knownWPBug(5540); 
    555          
     555 
    556556        if ( !is_callable('upgrade_user_roles') ) 
    557557            $this->markTestSkipped('depends on patch #5540'); 
    558          
     558 
    559559        global $wpdb, $blog_id; 
    560          
     560 
    561561        // make some users with old style usermeta roles and caps 
    562562        $id = array(); 
     
    575575        // a user with per-user capabilities 
    576576        update_usermeta($id[4], $user->cap_key, array('subscriber' => true, 'edit_posts' => true, 'upload_files' => true)); 
    577          
     577 
    578578        upgrade_user_roles($wpdb->prefix, $blog_id); 
    579          
     579 
    580580        // make sure the upgrade did insert user_role rows 
    581581        foreach ( $id as $user_id ) { 
     
    604604        $old_caps = get_usermeta($id[1], $user_1->cap_key); 
    605605        $this->assertEquals( array(), $old_caps ); 
    606          
     606 
    607607        $user_2 = new WP_User($id[2]); 
    608608        $this->assertEquals(array('subscriber'), $user_2->roles); 
     
    614614        $old_caps = get_usermeta($id[2], $user_2->cap_key); 
    615615        $this->assertEquals( array(), $old_caps ); 
    616          
     616 
    617617        // user 3 has two roles 
    618618        $user_3 = new WP_User($id[3]); 
     
    627627        $old_caps = get_usermeta($id[3], $user_3->cap_key); 
    628628        $this->assertEquals( array(), $old_caps ); 
    629          
     629 
    630630        // user 4 is a subscriber with some extra per-user caps 
    631631        $user_4 = new WP_User($id[4]); 
     
    641641        $old_caps = get_usermeta($id[4], $user_4->cap_key); 
    642642        $this->assertEquals( array('edit_posts' => true, 'upload_files' => true), $old_caps ); 
    643          
     643 
    644644        // quick test for get_users_of_blog 
    645645        $users = get_users_of_blog(); 
     
    647647        #dmp('now users', $users); 
    648648        $this->assertEquals( 5, count($users) - count($this->orig_users) ); 
    649          
     649 
    650650        #dmp('get_roles_with_cap edit_posts', get_roles_with_cap('edit_posts')); 
    651651        #dmp('get_users_of_blog', get_users_of_blog()); 
     
    657657        foreach (array_keys($wp_roles->roles) as $role) { 
    658658            $obj = $wp_roles->role_objects[$role]; 
    659              
     659 
    660660            echo "\nadd_role('{$role}', '{$obj->name}', ".var_export($obj->capabilities, true)."\n"; 
    661661            echo ")\n"; 
  • wp-testlib/base.php

    r373 r407  
    3636        _enable_wp_die(); 
    3737    } 
    38      
     38 
    3939    /** 
    4040     * Treat any error, which wasn't handled by PHPUnit as a failure 
     
    264264    function _generate_post_content_test(&$posts, $separate_funcs = true) { 
    265265        global $wpdb; 
    266          
     266 
    267267        $out = ''; 
    268268        if (!$separate_funcs) 
     
    313313                } 
    314314            } 
    315              
     315 
    316316            $meta = $wpdb->get_results("SELECT DISTINCT meta_key FROM {$wpdb->postmeta} WHERE post_id = $post->ID"); 
    317317            #$out .= "\t\t".'$this->assertEquals('.count($postmeta).', count($meta));'."\n"; 
     
    320320                $out .= "\t\t".'$this->assertEquals('.var_export(get_post_meta($post->ID, $m->meta_key, false), true).', get_post_meta($post->ID, \''.addslashes($m->meta_key).'\', false));'."\n"; 
    321321            } 
    322              
    323                          
     322 
     323 
    324324            $comments = $wpdb->get_results($wpdb->prepare("SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d ORDER BY comment_date DESC", $post->ID)); 
    325325 
     
    357357        system('mysqldump -u '.DB_USER.' --password='.DB_PASSWORD.' -cqnt '.DB_NAME.' '.$table_list); 
    358358    } 
    359      
     359 
    360360    function _load_sql_dump($file) { 
    361361        $lines = file($file); 
    362          
     362 
    363363        global $wpdb; 
    364364        foreach ($lines as $line) { 
     
    394394 
    395395    /** 
    396      * Checks if track ticket #$ticket_id is resolved  
     396     * Checks if track ticket #$ticket_id is resolved 
    397397     * 
    398398     * @return bool|null true if the ticket is resolved, false if not resolved, null on error 
     
    452452        } 
    453453    } 
    454      
    455      
     454 
     455 
    456456    // convenience function: return the # of posts associated with a tag 
    457457    function _tag_count($name) { 
     
    460460            return $t->count; 
    461461    } 
    462      
     462 
    463463    // convenience function: return the # of posts associated with a category 
    464464    function _category_count($name) { 
     
    467467            return $t->count; 
    468468    } 
    469      
     469 
    470470} 
    471471 
     
    519519/** 
    520520 * Simple function to list out all the test cases for command line interfaces 
    521  *  
     521 * 
    522522 * @param $test_classes The test casses array as returned by wptest_get_all_test_cases() 
    523523 * @return none 
     
    527527    natcasesort( $test_classes ); 
    528528    echo array_reduce($test_classes, '_wptest_listall_testcases_helper'); 
    529     echo "\nUse -t TestCaseName to run individual test cases\n";     
     529    echo "\nUse -t TestCaseName to run individual test cases\n"; 
    530530} 
    531531 
  • wp-testlib/getopt.php

    r288 r407  
    22/** 
    33 * getopt relacement / extenstion 
    4  *  
     4 * 
    55 *  prior to PHP 5.3 getopt is not supported on the windows plattform 
    66 *  and it does not support long options on other plattforms as well. 
    7  *   
    8  *  this file offers a _getopt() function as a replacement. via the   
     7 * 
     8 *  this file offers a _getopt() function as a replacement. via the 
    99 *  php.net manual page for getop(). 
    10  *   
     10 * 
    1111 *  original author is 可愛柚爸 / uberlinuxguy at tulg dot org 
    12  *   
     12 * 
    1313 *  the function has been taken from that website, and refactored 
    1414 *  into a helper class to increase the protability 
     
    1717 * 
    1818 *  CHANGELOG: 
    19  *   
     19 * 
    2020 *   - refactored the functions into a class (better portability) 
    2121 *   - reformatted the code (copy & paste issues) 
    22  *   - removed eval calls (commented)    
     22 *   - removed eval calls (commented) 
    2323 *   - smarter quoting 
    2424 *   - indentation on tab and cleanup of whitespaces 
    2525 *   - deprecated string access ({}) fixed with []. 
    26  *   
     26 * 
    2727 *  TODO: 
    28  *   (empty)  
    29  *   
    30  *   
     28 *   (empty) 
     29 * 
     30 * 
    3131 *  @link http://www.ntu.beautifulworldco.com/weblog/?p=526 
    3232 *  @link http://www.php.net/getopt 
     
    3535/** 
    3636 * getoptParser 
    37  *  
     37 * 
    3838 * getopt() compatible argv parsing. 
    39  *  
     39 * 
    4040 * @see getoptParser::getopt() 
    4141 * @see getoptParser::split_para() 
     
    4343class getoptParser { 
    4444    /** 
    45      * getopt()    
    46      *  
     45     * getopt() 
     46     * 
    4747     * Usage: _getopt ( [$flag,] $short_option [, $long_option] ); 
    48      *  
    49      * Note that another function split_para() is required, which can be  
     48     * 
     49     * Note that another function split_para() is required, which can be 
    5050     * found in the same page. 
    51      *  
    52      * _getopt() fully simulates getopt() which is described at  
    53      * (@see http://us.php.net/manual/en/function.getopt.php} , including long  
    54      * options for PHP version under 5.3.0. (Prior to 5.3.0, long options was  
     51     * 
     52     * _getopt() fully simulates getopt() which is described at 
     53     * (@see http://us.php.net/manual/en/function.getopt.php} , including long 
     54     * options for PHP version under 5.3.0. (Prior to 5.3.0, long options was 
    5555     * only available on few systems) 
    56      *  
    57      * Besides legacy usage of getopt(), I also added a new option to manipulate  
    58      * your own argument lists instead of those from command lines. This new  
     56     * 
     57     * Besides legacy usage of getopt(), I also added a new option to manipulate 
     58     * your own argument lists instead of those from command lines. This new 
    5959     * option can be a string or an array such as 
    60      *  
     60     * 
    6161     *  $flag = "-f value_f -ab --required 9 --optional=PK --option -v test -k"; 
    62      *   
     62     * 
    6363     *  or 
    64      *   
     64     * 
    6565     *  $flag = array ( "-f", "value_f", "-ab", "--required", "9", "--optional=PK", "--option" ); 
    66      *   
     66     * 
    6767     *  So there are four ways to work with _getopt(), 
    68      *   
     68     * 
    6969     *  1. _getopt ( $short_option ); 
    7070     *  it's a legacy usage, same as getopt ( $short_option ). 
    71      *   
     71     * 
    7272     *  2. _getopt ( $short_option, $long_option ); 
    7373     *  it's a legacy usage, same as getopt ( $short_option, $long_option ). 
    74      *   
     74     * 
    7575     *  3. _getopt ( $flag, $short_option ); 
    7676     *  use your own argument lists instead of command line arguments. 
    77      *   
     77     * 
    7878     *  4. _getopt ( $flag, $short_option, $long_option ); 
    79      *  use your own argument lists instead of command line arguments.  
    80      *  
     79     *  use your own argument lists instead of command line arguments. 
     80     * 
    8181     * @version 1.3 
    8282     * @date 2009/05/30 (taken from the website 2010-01-11) 
    8383     * @author 可愛柚爸 / uberlinuxguy at tulg dot org 
    8484     * @see http://www.ntu.beautifulworldco.com/weblog/?p=526 
    85      *  
     85     * 
    8686     * @params mixed 
    8787     * @return array 
    8888     */ 
    8989    static function getopt() { 
    90      
     90 
    9191        if ( func_num_args() == 1 ) { 
    9292            $flag =  $flag_array = $GLOBALS['argv']; 
     
    110110            exit ( "wrong options\n" ); 
    111111        } 
    112      
     112 
    113113        $short_option         = trim($short_option); 
    114114        $short_no_value       = array(); 
     
    119119        $long_optional_value  = array(); 
    120120        $options              = array(); 
    121      
     121 
    122122        for ( $i = 0; $i < strlen ( $short_option ); ) { 
    123123            if ( $short_option[$i] != ':' ) { 
     
    142142            } 
    143143        } 
    144      
     144 
    145145        foreach ( $long_option as $a ) { 
    146146            if ( substr( $a, -2 ) == '::' ) { 
     
    152152            } 
    153153        } 
    154      
     154 
    155155        if ( is_array ( $flag ) ) { 
    156156            $flag_array = $flag; 
     
    159159            $flag_array = self::_split_para($flag); 
    160160        } 
    161      
     161 
    162162        for ( $i = 0; $i < count($flag_array); ) { 
    163      
     163 
    164164            if ( !$flag_array[$i] || ( '-' == $flag_array[$i] ) ) { 
    165165                $i++; 
     
    169169                continue; 
    170170            } 
    171      
     171 
    172172            if ( substr($flag_array[$i], 0, 2) == '--' ) { 
    173173                if (strpos($flag_array[$i], '=') != false) { 
     
    187187                            $i++; 
    188188                        } else { 
    189                             $options[$key][] = FALSE;                        
     189                            $options[$key][] = FALSE; 
    190190                        } 
    191191                    } elseif ( in_array(substr( $flag_array[$i], 2 ), $long_no_value ) ) { 
     
    193193                    } 
    194194                    $i++; 
    195                     continue;                
     195                    continue; 
    196196                } 
    197197            } elseif ( $flag_array[$i][0] == '-' && $flag_array[$i][1] != '-' ) { 
     
    207207                                $i++; 
    208208                            } else { 
    209                                 $options[$flag_array[$i][$j]][] = FALSE;                                 
    210                             }                            
     209                                $options[$flag_array[$i][$j]][] = FALSE; 
     210                            } 
    211211                        } else { 
    212212                            $options[$flag_array[$i][$j]][] = substr ( $flag_array[$i], $j + 1 ); 
    213213                        } 
    214214                        $plus_i = 0; 
    215                         $i++;                            
     215                        $i++; 
    216216                        break; 
    217217                    } elseif ( in_array($flag_array[$i][$j], $short_no_value ) ) { 
     
    229229            $i++; 
    230230        } // for 
    231      
     231 
    232232        // reduce options array depth if possible 
    233233        foreach ( $options as $key => $value ) { 
     
    235235                $options[$key] = $value[0]; 
    236236        } 
    237      
     237 
    238238        return $options; 
    239      
     239 
    240240    } 
    241241 
    242242    /** 
    243243     * split parameters 
    244      *  
     244     * 
    245245     * static helper function 
    246      *  
     246     * 
    247247     * @version 1.0 
    248248     * @date    2008/08/19 
    249249     * @see     http://www.ntu.beautifulworldco.com/weblog/?p=526 
    250      *  
     250     * 
    251251     * This function is to parse parameters and split them into smaller pieces. 
    252252     * preg_split() does similar thing but in our function, besides "space", we 
     
    254254     * and \ (backslash) into consideration because things in a pair of " or ' 
    255255     * should be grouped together. 
    256      *  
     256     * 
    257257     * As an example, this parameter list 
    258      *  
     258     * 
    259259     * -f "test 2" -ab --required "t\"est 1" --optional="te'st 3" --option -v 'test 4' 
    260      *  
     260     * 
    261261     * will be splited into 
    262      *  
     262     * 
    263263     * -f; test 2; -ab; --required; t"est 1; --optional=te'st 3; --option; -v; test 4 
    264      *  
     264     * 
    265265     * see the code below: 
    266      *  
    267      * <code>  
    268      *  $pattern = "-f \"test 2\" -ab --required \"t\\\"est 1\" --optional=\"te'st 3\" --option -v 'test 4'";  
     266     * 
     267     * <code> 
     268     *  $pattern = "-f \"test 2\" -ab --required \"t\\\"est 1\" --optional=\"te'st 3\" --option -v 'test 4'"; 
    269269     *  $result = getoptParser::split_para($pattern); 
    270270     *  echo "ORIGINAL PATTERN: $pattern\n\n"; 
    271271     *  var_dump($result); 
    272272     * </code> 
    273      *  
     273     * 
    274274     * @param string $pattern 
    275275     * @return array 
     
    370370 
    371371        return $result; 
    372     }    
     372    } 
    373373} 
    374374?> 
  • wp-testlib/wp-profiler.php

    r120 r407  
    4242        } 
    4343        $wpdb->queries = array(); 
    44          
     44 
    4545        global $wp_object_cache; 
    4646 
     
    6767        $item['queries'] = $wpdb->queries; 
    6868        global $wp_object_cache; 
    69          
     69 
    7070        $cache_dirty_count = $this->_dirty_objects_count($wp_object_cache->dirty_objects); 
    7171        $cache_dirty_delta = $this->array_sub($cache_dirty_count, $item['cache_dirty_objects']); 
     
    159159        return $out; 
    160160    } 
    161      
     161 
    162162    function _dirty_objects_count($dirty_objects) { 
    163163        $out = array(); 
     
    166166        return $out; 
    167167    } 
    168      
     168 
    169169    function array_add($a, $b) { 
    170170        $out = $a; 
     
    176176        return $out; 
    177177    } 
    178      
     178 
    179179    function array_sub($a, $b) { 
    180180        $out = $a; 
     
    187187    function print_summary() { 
    188188        $results = $this->results(); 
    189          
     189 
    190190        printf("\nname                      calls   time action filter   warm   cold misses  dirty\n"); 
    191191        foreach ($results as $name=>$stats) { 
Note: See TracChangeset for help on using the changeset viewer.