WebSVN – Moodle – Diff – /lib/tests/moodlelib_test.php



 * @category   phpunit
 * @copyright  &copy; 2006 The Open University
 * @author     T.J.Hunt@open.ac.uk
 * @author     nicolas@moodle.com
 */
final class moodlelib_test extends \advanced_testcase {

 
    /**
     * Define a local decimal separator.
     *

        // Ensure the new value is picked up and not taken from the cache.
        $stringmanager = get_string_manager();
        $stringmanager->reset_caches(true);
    }

 
    public function test_cleanremoteaddr(): void {
        // IPv4.
        $this->assertNull(cleanremoteaddr('1023.121.234.1'));

        $this->assertSame('123.121.234.1', cleanremoteaddr('123.121.234.01 '));

        $this->assertSame('1:1:0:0:0:0:0:0', cleanremoteaddr('01:1::', false));
        $this->assertSame('10:0:0:0:0:0:0:10', cleanremoteaddr('10::10', false));
        $this->assertSame('::ffff:c0a8:11', cleanremoteaddr('::ffff:192.168.1.1', true));
    }

 
    public function test_address_in_subnet(): void {
        // 1: xxx.xxx.xxx.xxx/nn or xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/nnn (number of bits in net mask).
        $this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.1/32'));
        $this->assertFalse(address_in_subnet('123.121.23.1', '123.121.23.0/32'));
        $this->assertTrue(address_in_subnet('10.10.10.100',  '123.121.23.45/0'));

 
        // Other incorrect input.
        $this->assertFalse(address_in_subnet('123.123.123.123', ''));

    }
 
    public function test_fix_utf8(): void {
        // Make sure valid data including other types is not changed.
        $this->assertSame(null, fix_utf8(null));
        $this->assertSame(1, fix_utf8(1));

        // Invalid utf8 string.
        $this->assertSame('aš', fix_utf8('a'.chr(130).'š'), 'This fails with buggy iconv() when mbstring extenstion is not available as fallback.');
        $this->assertSame('Hello ', fix_utf8('Hello ï¿¿'));
    }

 
    public function test_optional_param(): void {

        global $CFG;
 
        $_POST['username'] = 'post_user';

            $this->fail('coding_exception expected');
        } catch (\coding_exception $e) {
        }
    }

 
    public function test_optional_param_array(): void {

        global $CFG;
 
        $_POST['username'] = array('a'=>'post_user');

        $_POST['username'] = array('abc123_;-/*-+ '=>'arrggh', 'a1_-'=>'post_user');
        $this->assertSame(array('a1_-'=>'post_user'), optional_param_array('username', array(), PARAM_RAW));
        $this->assertDebuggingCalled();
    }

 
    public function test_required_param(): void {
        $_POST['username'] = 'post_user';
        $_GET['username'] = 'get_user';

        $this->assertSame('post_user', required_param('username', PARAM_RAW));

            $this->fail('coding_exception expected');
        } catch (\coding_exception $e) {
        }
    }

 
    public function test_required_param_array(): void {

        global $CFG;
 
        $_POST['username'] = array('a'=>'post_user');

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param(): void {
        // Forbid objects and arrays.
        try {
            clean_param(array('x', 'y'), PARAM_RAW);
            $this->fail('coding_exception expected');

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_array(): void {
        $this->assertSame(array(), clean_param_array(null, PARAM_RAW));
        $this->assertSame(array('a', 'b'), clean_param_array(array('a', 'b'), PARAM_RAW));

        $this->assertSame(array('a', array('b')), clean_param_array(array('a', array('b')), PARAM_RAW, true));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_raw(): void {
        $this->assertSame(
            '#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)',
            clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_RAW));
        $this->assertSame(null, clean_param(null, PARAM_RAW));

    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_trim(): void {
        $this->assertSame('Frog toad', clean_param("   Frog toad   \r\n  ", PARAM_RAW_TRIMMED));

        $this->assertSame('', clean_param(null, PARAM_RAW_TRIMMED));
    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_clean(): void {
        // PARAM_CLEAN is an ugly hack, do not use in new code (skodak),
        // instead use more specific type, or submit sothing that can be verified properly.

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_alpha(): void {
        $this->assertSame('DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHA));
        $this->assertSame('', clean_param(null, PARAM_ALPHA));

    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_alphanum(): void {
        $this->assertSame('978942897DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHANUM));

        $this->assertSame('', clean_param(null, PARAM_ALPHANUM));
    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_alphaext(): void {

        $this->assertSame('DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHAEXT));
        $this->assertSame('', clean_param(null, PARAM_ALPHAEXT));
    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */

    public function test_clean_param_sequence(): void {
        $this->assertSame(',9789,42897', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_SEQUENCE));
        $this->assertSame('', clean_param(null, PARAM_SEQUENCE));
    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_component(): void {

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */

    public function test_clean_param_localisedfloat(): void {
 
        $this->assertSame(0.5, clean_param('0.5', PARAM_LOCALISEDFLOAT));
        $this->assertSame(false, clean_param('0X5', PARAM_LOCALISEDFLOAT));

        $this->assertSame(false, clean_param('1X000X5', PARAM_LOCALISEDFLOAT));
        $this->assertSame(false, clean_param('nan', PARAM_LOCALISEDFLOAT));
        $this->assertSame(false, clean_param('10X6blah', PARAM_LOCALISEDFLOAT));
    }

 
    public function test_is_valid_plugin_name(): void {
        $this->assertTrue(is_valid_plugin_name('forum'));
        $this->assertTrue(is_valid_plugin_name('forum2'));
        $this->assertTrue(is_valid_plugin_name('feedback360'));
        $this->assertTrue(is_valid_plugin_name('online_users'));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_plugin(): void {
        // Please note the cleaning of plugin names is very strict, no guessing here.
        $this->assertSame('forum', clean_param('forum', PARAM_PLUGIN));
        $this->assertSame('forum2', clean_param('forum2', PARAM_PLUGIN));
        $this->assertSame('feedback360', clean_param('feedback360', PARAM_PLUGIN));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_area(): void {
        // Please note the cleaning of area names is very strict, no guessing here.
        $this->assertSame('something', clean_param('something', PARAM_AREA));
        $this->assertSame('something2', clean_param('something2', PARAM_AREA));
        $this->assertSame('some_thing', clean_param('some_thing', PARAM_AREA));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_text(): void {
        // Standard.
        $this->assertSame('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', PARAM_TEXT));
        $this->assertSame('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', clean_param('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', PARAM_TEXT));
        $this->assertSame('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', PARAM_TEXT));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_url(): void {
        // Test PARAM_URL and PARAM_LOCALURL a bit.
        // Valid URLs.
        $this->assertSame('http://google.com/', clean_param('http://google.com/', PARAM_URL));
        $this->assertSame('http://some.very.long.and.silly.domain/with/a/path/', clean_param('http://some.very.long.and.silly.domain/with/a/path/', PARAM_URL));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_localurl(): void {

        global $CFG;

 

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_file(): void {
        $this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_FILE));
        $this->assertSame('badfile.txt', clean_param('b\'a<d`\\/fi:l>e.t"x|t', PARAM_FILE));
        $this->assertSame('..parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_FILE));
        $this->assertSame('....grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_FILE));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_path(): void {
        $this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_PATH));
        $this->assertSame('bad/file.txt', clean_param('b\'a<d`\\/fi:l>e.t"x|t', PARAM_PATH));
        $this->assertSame('/parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_PATH));
        $this->assertSame('/grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_PATH));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_safepath(): void {
        $this->assertSame('folder/file', clean_param('folder/file', PARAM_SAFEPATH));
        $this->assertSame('folder//file', clean_param('folder/../file', PARAM_SAFEPATH));
        $this->assertSame('', clean_param(null, PARAM_SAFEPATH));

    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_username(): void {

        global $CFG;
        $currentstatus =  $CFG->extendedusernamechars;

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_stringid(): void {
        // Test string identifiers validation.
        // Valid strings.
        $this->assertSame('validstring', clean_param('validstring', PARAM_STRINGID));
        $this->assertSame('mod/foobar:valid_capability', clean_param('mod/foobar:valid_capability', PARAM_STRINGID));

 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_timezone(): void {
        // Test timezone validation.
        $testvalues = array (
            'America/Jamaica'                => 'America/Jamaica',
            'America/Argentina/Cordoba'      => 'America/Argentina/Cordoba',

            '13.5'                           => '',
            '+13.5'                          => '',
            '-13.5'                          => '',
            '0.2'                            => '',
            ''                               => '',
 
        );

 
        foreach ($testvalues as $testvalue => $expectedvalue) {
            $actualvalue = clean_param($testvalue, PARAM_TIMEZONE);
            $this->assertEquals($expectedvalue, $actualvalue);
        }
 
        // Test for null.
        $this->assertEquals('', clean_param(null, PARAM_TIMEZONE));

    }
 
    /**
     * @covers \core\param
     * @covers \clean_param
     */
    public function test_clean_param_null_argument(): void {
        $this->assertEquals(0, clean_param(null, PARAM_INT));
        $this->assertEquals(0, clean_param(null, PARAM_FLOAT));
        $this->assertEquals(0, clean_param(null, PARAM_LOCALISEDFLOAT));

        $this->assertEquals('', clean_param(null, PARAM_LANG));
        $this->assertEquals('', clean_param(null, PARAM_THEME));
        $this->assertEquals('', clean_param(null, PARAM_EMAIL));
    }

 
    public function test_validate_param(): void {
        try {
            $param = validate_param('11a', PARAM_INT);
            $this->fail('invalid_parameter_exception expected');
        } catch (\moodle_exception $ex) {

        } catch (\moodle_exception $ex) {
            $this->assertInstanceOf('invalid_parameter_exception', $ex);
        }
    }

 
    public function test_shorten_text_no_tags_already_short_enough(): void {
        // ......12345678901234567890123456.
        $text = "short text already no tags";
        $this->assertSame($text, shorten_text($text));

    }
 
    public function test_shorten_text_with_tags_already_short_enough(): void {
        // .........123456...7890....12345678.......901234567.
        $text = "<p>short <b>text</b> already</p><p>with tags</p>";

        $this->assertSame($text, shorten_text($text));
    }
 
    public function test_shorten_text_no_tags_needs_shortening(): void {
        // Default truncation is after 30 chars, but allowing 3 for the final '...'.
        // ......12345678901234567890123456789023456789012345678901234.

        $text = "long text without any tags blah de blah blah blah what";
        $this->assertSame('long text without any tags ...', shorten_text($text));
    }
 
    public function test_shorten_text_with_tags_needs_shortening(): void {
        // .......................................123456789012345678901234567890...
        $text = "<div class='frog'><p><blockquote>Long text with tags that will ".

            "be chopped off but <b>should be added back again</b></blockquote></p></div>";
        $this->assertEquals("<div class='frog'><p><blockquote>Long text with " .
            "tags that ...</blockquote></p></div>", shorten_text($text));
    }
 
    public function test_shorten_text_with_tags_and_html_comment(): void {
        $text = "<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with ".

            "tags that will<!--<![endif]--> ".
            "be chopped off but <b>should be added back again</b></blockquote></p></div>";
        $this->assertEquals("<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with " .
            "tags that ...<!--<![endif]--></blockquote></p></div>", shorten_text($text));
    }
 
    public function test_shorten_text_with_entities(): void {
        // Remember to allow 3 chars for the final '...'.

        // ......123456789012345678901234567_____890...
        $text = "some text which shouldn't &nbsp; break there";
        $this->assertSame("some text which shouldn't &nbsp; ...", shorten_text($text, 31));
        $this->assertSame("some text which shouldn't &nbsp;...", shorten_text($text, 30));
        $this->assertSame("some text which shouldn't ...", shorten_text($text, 29));
    }

            shorten_text($text, 42));
        $this->assertSame("<h3>standard 'break-out' sub groups in TGs?</h3>&nbsp;...",
            shorten_text($text, 43));
    }

 
    public function test_shorten_text_no_spaces(): void {
        // ..........123456789.
        $text = "<h1>123456789</h1>"; // A string with no convenient breaks.
        $this->assertSame("<h1>12345...</h1>", shorten_text($text, 8));

    }
 
    public function test_shorten_text_utf8_european(): void {
        // Text without tags.
        // ......123456789012345678901234567.
        $text = "Žluťoučký koníček přeskočil";

        $this->assertSame("<p>Žluťoučký koníček <b>přeskočil</b> pot...</p>", shorten_text($text, 34, true));
        // And in the middle of one tag.
        $this->assertSame("<p>Žluťoučký koníček <b>přeskočil...</b></p>", shorten_text($text, 30, true));
    }

 
    public function test_shorten_text_utf8_oriental(): void {
        // Japanese
        // text without tags
        // ......123456789012345678901234.
        $text = '言語設定言語設定abcdefghijkl';

        $this->assertSame("简体中文简体...", shorten_text($text, 9, false));
        $this->assertSame("简体中文简体中文ab...", shorten_text($text, 13, true));
        $this->assertSame("简体中文简体中文...", shorten_text($text, 13, false));
    }

 
    public function test_shorten_text_multilang(): void {
        // This is not necessaryily specific to multilang. The issue is really
        // tags with attributes, where before we were generating invalid HTML
        // output like shorten_text('<span id="x" class="y">A</span> B', 1)
        // returning '<span id="x" ...</span>'. It is just that multilang

     * @param string $filename
     * @param int $length
     * @param string $expected
     * @param boolean $includehash
     */
    public function test_shorten_filename($filename, $length, $expected, $includehash): void {
        if (null === $length) {
            $length = MAX_FILENAME_SIZE;
        }

 

     * @param array $filenames
     * @param int $length
     * @param string $expected
     * @param boolean $includehash
     */
    public function test_shorten_filenames($filenames, $length, $expected, $includehash): void {
        if (null === $length) {
            $length = MAX_FILENAME_SIZE;
        }

 
        $this->assertSame($expected, shorten_filenames($filenames, $length, $includehash));

    }
 
    public function test_usergetdate(): void {

        global $USER, $CFG, $DB;

        $this->assertDebuggingNotCalled();
        $this->assertSame(1970, usergetdate(null)['year']);
        $this->assertDebuggingCalled(null, DEBUG_DEVELOPER);
    }

 
    public function test_mark_user_preferences_changed(): void {
        $this->resetAfterTest();
        $otheruser = $this->getDataGenerator()->create_user();

        $otheruserid = $otheruser->id;

 
        $this->assertEquals(get_cache_flag('userpreferenceschanged', $otheruserid, time()-10), 1);
        set_cache_flag('userpreferenceschanged', $otheruserid, null);

    }
 
    public function test_check_user_preferences_loaded(): void {

        global $DB;
        $this->resetAfterTest();

        $this->assertCount(3, $user->preference);
        $this->assertSame('bbb', $user->preference['aaa']);
        set_cache_flag('userpreferenceschanged', $user->id, null);
    }

 
    public function test_set_user_preference(): void {
        global $DB, $USER;

        $this->resetAfterTest();

        } catch (\moodle_exception $ex) {
            $this->assertInstanceOf('coding_exception', $ex);
        }
    }

 
    public function test_set_user_preference_for_current_user(): void {
        global $USER;
        $this->resetAfterTest();

        $this->setAdminUser();
 
        set_user_preference('test_pref', 2);
        set_user_preference('test_pref', 1, $USER->id);

        $this->assertEquals(1, get_user_preferences('test_pref'));
    }
 
    public function test_unset_user_preference_for_current_user(): void {

        global $USER;

     *
     * Note: If you don't trust PHP TZ/DST support, can verify the
     * harcoded expectations below with:
     * http://www.tools4noobs.com/online_tools/unix_timestamp_to_datetime/
     */
    public function test_some_moodle_special_dst(): void {
        $stamp = 1365386400; // 2013/04/08 02:00:00 GMT/UTC.

 
        // In Europe/Tallinn it was 2013/04/08 05:00:00.
        $expectation = '2013/04/08 05:00:00';

        $moodleres = userdate($stamp, '%Y/%m/%d %H:%M:%S', 'America/St_Johns', false); // Moodle result.
        $this->assertSame($expectation, $phpres);
        $this->assertSame($expectation, $moodleres);
    }

 
    public function test_userdate(): void {
        global $USER, $CFG, $DB;

        $this->resetAfterTest();

    }

 
    /**
     * Make sure the DST changes happen at the right time in Moodle.
     */
    public function test_dst_changes(): void {
        // DST switching in Prague.
        // From 2AM to 3AM in 1989.
        $date = new \DateTime('1989-03-26T01:59:00+01:00');
        $this->assertSame('Sunday, 26 March 1989, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));

        $this->assertSame('Sunday, 2 November 2014, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
        $date = new \DateTime('2014-11-02T02:01:00-04:00');
        $this->assertSame('Sunday, 2 November 2014, 01:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
    }

 
    public function test_make_timestamp(): void {
        global $USER, $CFG, $DB;

        $this->resetAfterTest();

 
    /**
     * Test get_string and most importantly the implementation of the lang_string
     * object.
     */
    public function test_get_string(): void {

        global $COURSE;
 
        // Make sure we are using English.

 
        // Reset the language.
        $COURSE->lang = $originallang;

    }

 
    public function test_lang_string_var_export(): void {

 

 
        $this->assertInstanceOf(lang_string::class, $str);
        $this->assertEquals('No', $str);

    }
 
    public function test_get_string_limitation(): void {
        // This is one of the limitations to the lang_string class. It can't be
        // used as a key.
        $this->expectException(\TypeError::class);

        $array = array(get_string('yes', null, null, true) => 'yes');
    }
 
    /**

     * Test localised float formatting.
     */

    public function test_format_float(): void {

    }

 
    /**
     * Test localised float unformatting.
     */

    public function test_unformat_float(): void {

 
        // Tests without the localised decimal separator.

    }

 
    /**
     * Test deleting of users.
     */
    public function test_delete_user(): void {

        global $DB, $CFG;

 

    }

 
    /**
     * Test deletion of user with long username
     */
    public function test_delete_user_long_username(): void {

        global $DB;

 

    }

 
    /**
     * Test deletion of user with long email address
     */
    public function test_delete_user_long_email(): void {

        global $DB;

 

    }

 
    /**
     * Test function convert_to_array()
     */
    public function test_convert_to_array(): void {
        // Check that normal classes are converted to arrays the same way as (array) would do.
        $obj = new \stdClass();
        $obj->prop1 = 'hello';
        $obj->prop2 = array('first', 'second', 13);

    }

 
    /**
     * Test the function date_format_string().
     */
    public function test_date_format_string(): void {

        global $CFG;
 

            $str = date_format_string(1293876000, $test['str'], $test['tz']);
            $this->assertSame(\core_text::strtolower($test['expected']), \core_text::strtolower($str));
        }
    }

 
    public function test_get_config(): void {

        global $CFG;

 

        $this->assertFalse($cache->get('core'));
        set_config('phpunit_test_get_config_4', 'test c', 'mod_forum');
        $this->assertFalse($cache->get('mod_forum'));
    }

 
    public function test_get_max_upload_sizes(): void {
        // Test with very low limits so we are not affected by php upload limits.
        // Test activity limit smallest.
        $sitebytes = 102400;
        $coursebytes = 51200;

 
    /**
     * Test function password_is_legacy_hash.
     * @covers ::password_is_legacy_hash
     */
    public function test_password_is_legacy_hash(): void {
        // Well formed bcrypt hashes should be matched.
        foreach (array('some', 'strings', 'to_check!') as $password) {
            $bcrypt = password_hash($password, '2y');
            $this->assertTrue(password_is_legacy_hash($bcrypt));

 
    /**
     * Test function that calculates password pepper entropy.
     * @covers ::calculate_entropy
     */
    public function test_calculate_entropy(): void {
        // Test that the function returns 0 with an empty string.

        $this->assertEquals(0, calculate_entropy(''));
 

 
    /**
     * Test function to get password peppers.
     * @covers ::get_password_peppers
     */
    public function test_get_password_peppers(): void {
        global $CFG;

        $this->resetAfterTest();
 

     * Test function to validate password length.
     *
     * @covers ::exceeds_password_length
     * @return void
     */
    public function test_exceeds_password_length(): void {
        $this->resetAfterTest(true);

 
        // With password less than equals to MAX_PASSWORD_CHARACTERS.

 
    /**
     * Test function validate_internal_user_password.
     * @covers ::validate_internal_user_password
     */
    public function test_validate_internal_user_password(): void {
        $this->resetAfterTest(true);
        // Test bcrypt hashes (these will be updated but will still count as valid).
        $bcrypthashes = [
            'pw' => '$2y$10$LOSDi5eaQJhutSRun.OVJ.ZSxQZabCMay7TO1KmzMkDMPvU40zGXK',

     * Test function validate_internal_user_password() with a peppered password,
     * when the pepper no longer exists.
     *
     * @covers ::validate_internal_user_password
     */
    public function test_validate_internal_user_password_bad_pepper(): void {
        global $CFG;
        $this->resetAfterTest();

 
        // Set a pepper.

 
    /**
     * Test function update_internal_user_password.
     * @covers ::update_internal_user_password
     */
    public function test_hash_internal_user_password(): void {
        global $CFG;
        $this->resetAfterTest();

        $passwords = ['pw', 'abc123', 'C0mP1eX_&}<?@*&%` |\"', 'Ä©Å„Å¥Ä—Å•ÅˆÄƒÅ£Ä©ÅÅ‹ÄÄ¹'];

    }

 
    /**
     * Test function update_internal_user_password().
     */
    public function test_update_internal_user_password(): void {
        global $DB;
        $this->resetAfterTest();
        $passwords = array('password', '1234', 'changeme', '****');
        foreach ($passwords as $password) {

    }

 
    /**
     * Testing that if the password is not cached, that it does not update
     * the user table and fire event.
     *
     * @dataProvider update_internal_user_password_no_cache_provider
     * @covers ::update_internal_user_password
     *
     * @param string $authmethod The authentication method to set for the user.
     * @param string|null $password The new password to set for the user.
     */
    public function test_update_internal_user_password_no_cache(
        string $authmethod,
        ?string $password,
    ): void {
        global $DB;

        $this->resetAfterTest();
 
        $user = $this->getDataGenerator()->create_user(['auth' => $authmethod]);

        $DB->update_record('user', ['id' => $user->id, 'password' => AUTH_PASSWORD_NOT_CACHED]);
        $user->password = AUTH_PASSWORD_NOT_CACHED;
 
        $sink = $this->redirectEvents();

        update_internal_user_password($user, $password);
        $this->assertEquals(0, $sink->count(), 'User updated event should not fire');
    }
 
    /**
     * The data provider will test the {@see test_update_internal_user_password_no_cache}
     * for accounts using the authentication method with prevent_local_passwords set to true (no cache).
     *
     * @return array
     */
    public static function update_internal_user_password_no_cache_provider(): array {
        return [
            'Password is not empty' => ['cas', 'wonkawonka'],
            'Password is an empty string' => ['oauth2', ''],
            'Password is null' => ['oauth2', null],
        ];
    }
 
    /**
     * Test if the user has a password hash, but now their auth method

     * says not to cache it.  Then it should update.
     */
    public function test_update_internal_user_password_update_no_cache(): void {

        $this->assertGreaterThanOrEqual(1, $sink->count(), 'User updated event should fire');

 
        $this->assertEquals(AUTH_PASSWORD_NOT_CACHED, $user->password);

    }
 

    public function test_fullname(): void {

        global $CFG;

        // Tidy up after we finish testing.
        $CFG->fullnamedisplay = $originalcfg->fullnamedisplay;
        $CFG->alternativefullnameformat = $originalcfg->alternativefullnameformat;
    }

 
    public function test_order_in_string(): void {

        $this->resetAfterTest();
 
        // Return an array in an order as they are encountered in a string.

        $formatstring = 'start seconds away second firstquater first firsthalf';
        $expectedarray = array('19' => 'second', '38' => 'first', '44' => 'firsthalf');
        $this->assertEquals($expectedarray, order_in_string($valuearray, $formatstring));
    }

 
    public function test_complete_user_login(): void {

        global $USER, $DB;
 
        $this->resetAfterTest();

    }

 
    /**
     * Test require_logout.
     */
    public function test_require_logout(): void {
        $this->resetAfterTest();
        $user = $this->getDataGenerator()->create_user();

        $this->setUser($user);

     * @dataProvider generate_email_messageid_provider
     *
     * @param string $wwwroot The wwwroot
     * @param array $msgids An array of msgid local parts and the final result
     */
    public function test_generate_email_messageid($wwwroot, $msgids): void {
        global $CFG;

 
        $this->resetAfterTest();

    }

 
    /**
     * Test email with custom headers
     */
    public function test_send_email_with_custom_header(): void {
        global $DB, $CFG;
        $this->preventResetByRollback();

        $this->resetAfterTest();

     * @param string $divertallemailsto An optional email address
     * @param string $divertallemailsexcept An optional exclusion list
     * @param array $addresses An array of test addresses
     * @param boolean $expected Expected result
     */
    public function test_email_should_be_diverted($divertallemailsto, $divertallemailsexcept, $addresses, $expected): void {
        global $CFG;

 
        $this->resetAfterTest();
        $CFG->divertallemailsto = $divertallemailsto;

        foreach ($addresses as $address) {
            $this->assertEquals($expected, email_should_be_diverted($address));
        }
    }

 
    public function test_email_to_user(): void {

        global $CFG;

 

    }

 
    /**
     * Test setnew_password_and_mail.
     */
    public function test_setnew_password_and_mail(): void {

        global $DB, $CFG;

 

        $this->assertEventContextNotUsed($event);
    }

 
    /**
     * Data provider for test_generate_confirmation_link
     * @return array Confirmation urls and expected resultant confirmation links
     */
    public static function generate_confirmation_link_provider(): array {
        global $CFG;
        return [
            "Simple name" => [
                "username" => "simplename",

            "Custom external confirmation url with parameters" => [
                "username" => "many_-.@characters@_@-..-..",
                "confirmationurl" => "http://moodle.org/ext.php?with=some&param=eters",
                "expected" => "http://moodle.org/ext.php?with=some&param=eters&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
            ],
            "Custom external confirmation url with parameters (again)" => [
                "username" => "many_-.@characters@_@-..-..",
                "confirmationurl" => "http://moodle.org/ext.php?with=some&data=test",
                "expected" => "http://moodle.org/ext.php?with=some&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
            ],
        ];

     * @dataProvider generate_confirmation_link_provider
     * @param string $username The name of the user
     * @param string $confirmationurl The url the user should go to to confirm
     * @param string $expected The expected url of the confirmation link
     */
    public function test_generate_confirmation_link($username, $confirmationurl, $expected): void {
        $this->resetAfterTest();
        $sink = $this->redirectEmails();

 
        $user = $this->getDataGenerator()->create_user(

    }

 
    /**
     * Test generate_confirmation_link with custom admin link
     */
    public function test_generate_confirmation_link_with_custom_admin(): void {

        global $CFG;
 

 
    /**
     * Test remove_course_content deletes course contents
     * TODO Add asserts to verify other data related to course is deleted as well.
     */

    public function test_remove_course_contents(): void {

 
        $this->resetAfterTest();

    }

 
    /**
     * Test function username_load_fields_from_object().
     */
    public function test_username_load_fields_from_object(): void {

        $this->resetAfterTest();
 
        // This object represents the information returned from an sql query.

    }

 
    /**
     * Tests the getremoteaddr() function.
     */
    public function test_getremoteaddr(): void {

        global $CFG;

 

    }

 
    /**
     * Test function for creation of random strings.
     */
    public function test_random_string(): void {

        $pool = 'a-zA-Z0-9';
 
        $result = random_string(10);

    }

 
    /**
     * Test function for creation of complex random strings.
     */
    public function test_complex_random_string(): void {

        $pool = preg_quote('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`~!@#%^&*()_+-=[];,./<>?:{} ', '/');
 
        $result = complex_random_string(10);

     * Checks ip_is_public returns false for private ips.
     *
     * @param string $ip the ipaddress to test
     * @dataProvider data_private_ips
     */
    public function test_ip_is_public_private_ips($ip): void {
        $this->assertFalse(ip_is_public($ip));
    }

 
    /**

     * Checks ip_is_public returns true for public ips.
     *
     * @param string $ip the ipaddress to test
     * @dataProvider data_public_ips
     */
    public function test_ip_is_public_public_ips($ip): void {
        $this->assertTrue(ip_is_public($ip));
    }

 
    /**

     * @param bool $samecourse Are the users in the same course?
     * @param string $config The CFG->allowedemaildomains config values
     * @param bool $result The expected result.
     * @dataProvider data_can_send_from_real_email_address
     */
    public function test_can_send_from_real_email_address($email, $display, $samecourse, $config, $result): void {
        $this->resetAfterTest();

 
        $fromuser = $this->getDataGenerator()->create_user();
        $touser = $this->getDataGenerator()->create_user();

    }

 
    /**
     * Test that generate_email_processing_address() returns valid email address.
     */
    public function test_generate_email_processing_address(): void {
        global $CFG;

        $this->resetAfterTest();
 

     * @param string $config The CFG->allowemailaddresses config values
     * @param false/string $result The expected result.
     *
     * @dataProvider data_email_is_not_allowed_for_allowemailaddresses
     */
    public function test_email_is_not_allowed_for_allowemailaddresses($email, $config, $result): void {
        $this->resetAfterTest();

 
        set_config('allowemailaddresses', $config);
        $this->assertEquals($result, email_is_not_allowed($email));

     * @param string $config The CFG->denyemailaddresses config values
     * @param false/string $result The expected result.
     *
     * @dataProvider data_email_is_not_allowed_for_denyemailaddresses
     */
    public function test_email_is_not_allowed_for_denyemailaddresses($email, $config, $result): void {
        $this->resetAfterTest();

 
        set_config('denyemailaddresses', $config);
        $this->assertEquals($result, email_is_not_allowed($email));

    }

 
    /**
     * Test safe method unserialize_array().
     */
    public function test_unserialize_array(): void {
        $a = [1, 2, 3];
        $this->assertEquals($a, unserialize_array(serialize($a)));
        $a = ['a' => 1, 2 => 2, 'b' => 'cde'];
        $this->assertEquals($a, unserialize_array(serialize($a)));

     * Test that the component_class_callback returns the correct default value when the class was not found.
     *
     * @dataProvider component_class_callback_default_provider
     * @param $default
     */
    public function test_component_class_callback_not_found($default): void {
        $this->assertSame($default, component_class_callback('thisIsNotTheClassYouWereLookingFor', 'anymethod', [], $default));
    }

 
    /**
     * Test that the component_class_callback returns the correct default value when the class was not found.
     *
     * @dataProvider component_class_callback_default_provider
     * @param $default
     */
    public function test_component_class_callback_method_not_found($default): void {

        require_once(__DIR__ . '/fixtures/component_class_callback_example.php');
 

     * Test that the component_class_callback returns the default when the method returned null.
     *
     * @dataProvider component_class_callback_default_provider
     * @param $default
     */
    public function test_component_class_callback_found_returns_null($default): void {
        require_once(__DIR__ . '/fixtures/component_class_callback_example.php');

 
        $this->assertSame($default, component_class_callback(\test_component_class_callback_example::class, 'method_returns_value', [null], $default));
        $this->assertSame($default, component_class_callback(\test_component_class_callback_child_example::class, 'method_returns_value', [null], $default));

     * Test that the component_class_callback returns the expected value and not the default when there was a value.
     *
     * @dataProvider component_class_callback_data_provider
     * @param $default
     */
    public function test_component_class_callback_found_returns_value($value): void {
        require_once(__DIR__ . '/fixtures/component_class_callback_example.php');

 
        $this->assertSame($value, component_class_callback(\test_component_class_callback_example::class, 'method_returns_value', [$value], 'This is not the value you were looking for'));
        $this->assertSame($value, component_class_callback(\test_component_class_callback_child_example::class, 'method_returns_value', [$value], 'This is not the value you were looking for'));

     * Test that the component_class_callback handles multiple params correctly.
     *
     * @dataProvider component_class_callback_multiple_params_provider
     * @param $default
     */
    public function test_component_class_callback_found_accepts_multiple($params, $count): void {
        require_once(__DIR__ . '/fixtures/component_class_callback_example.php');

 
        $this->assertSame($count, component_class_callback(\test_component_class_callback_example::class, 'method_returns_all_params', $params, 'This is not the value you were looking for'));
        $this->assertSame($count, component_class_callback(\test_component_class_callback_child_example::class, 'method_returns_all_params', $params, 'This is not the value you were looking for'));

     *
     * @dataProvider callable_names_provider
     * @param callable $callable
     * @param string $expectedname
     */
    public function test_get_callable_name($callable, $expectedname): void {
        $this->assertSame($expectedname, get_callable_name($callable));
    }

 
    /**

     * @param string|boolean $value The field value. When fetching by ID, set true to fetch valid user ID, false otherwise.
     * @param boolean $success Whether we expect for the fetch to succeed or return false.
     * @param int $allowaccountssameemail Value for $CFG->allowaccountssameemail.
     * @param string $expectedexception The exception to be expected.
     */
    public function test_get_complete_user_data($field, $value, $success, $allowaccountssameemail = 0, $expectedexception = ''): void {
        $this->resetAfterTest();

 
        // Set config settings we need for our environment.

    }

 
    /**
     * Test for send_password_change_().
     */
    public function test_send_password_change_info(): void {

        $this->resetAfterTest();

 

     * @param bool $dropzeroes the value passed for the `$dropzeros` param.
     * @param bool $fullformat the value passed for the `$fullformat` param.
     * @covers \get_time_interval_string
     */
    public function test_get_time_interval_string(int $time1, int $time2, ?string $format, string $expected,
            bool $dropzeroes = false, bool $fullformat = false): void {
        if (is_null($format)) {
            $this->assertEquals($expected, get_time_interval_string($time1, $time2));
        } else {
            $this->assertEquals($expected, get_time_interval_string($time1, $time2, $format, $dropzeroes, $fullformat));
        }

    }

 
    /**
     * Tests the rename_to_unused_name function with a file.
     */
    public function test_rename_to_unused_name_file(): void {

        global $CFG;
 
        // Create a new file in dataroot.

    }

 
    /**
     * Tests the rename_to_unused_name function with a directory.
     */
    public function test_rename_to_unused_name_dir(): void {

        global $CFG;
 
        // Create a new directory in dataroot.

    }

 
    /**
     * Tests the rename_to_unused_name function with error cases.
     */
    public function test_rename_to_unused_name_failure(): void {

        global $CFG;
 
        // Rename a file that doesn't exist.

     * Test display_size
     * @dataProvider display_size_provider
     * @param int $size the size in bytes
     * @param string $expected the expected string.
     */
    public function test_display_size($size, $expected): void {
        $result = display_size($size);
        $expected = str_replace(' ', "\xc2\xa0", $expected); // Should be non-breaking space.
        $this->assertEquals($expected, $result);
    }

     * @param int $enabledashboard Whether the dashboard should be enabled or not.
     * @param int $userpreference User preference for the home page setting.
     * @covers ::get_home_page
     */
    public function test_get_home_page(string $user, int $expected, ?int $defaulthomepage = null, ?int $enabledashboard = null,
            ?int $userpreference = null): void {
        global $CFG, $USER;

 

        $this->resetAfterTest();

    /**
     * Test get_default_home_page() method.
     *
     * @covers ::get_default_home_page
     */
    public function test_get_default_home_page(): void {
        global $CFG;

 

        $this->resetAfterTest();

    /**
     * Test the html_is_blank() function.
     *
     * @covers ::html_is_blank
     */
    public function test_html_is_blank(): void {
        $this->assertEquals(true, html_is_blank(null));
        $this->assertEquals(true, html_is_blank(''));
        $this->assertEquals(true, html_is_blank('<p> </p>'));
        $this->assertEquals(false, html_is_blank('<p>.</p>'));
        $this->assertEquals(false, html_is_blank('<img src="#">'));

Rev 1	Rev 11
Línea 25...	Línea 25...
25	`* @category phpunit`	25	`* @category phpunit`
26	`* @copyright © 2006 The Open University`	26	`* @copyright © 2006 The Open University`
27	`* @author T.J.Hunt@open.ac.uk`	27	`* @author T.J.Hunt@open.ac.uk`
28	`* @author nicolas@moodle.com`	28	`* @author nicolas@moodle.com`
29	`*/`	29	`*/`
30	`class moodlelib_test extends \advanced_testcase {`	30	`final class moodlelib_test extends \advanced_testcase {`
Línea 31...	Línea 31...
31		31
32	`/**`	32	`/**`
33	`* Define a local decimal separator.`	33	`* Define a local decimal separator.`
34	`*`	34	`*`
Línea 53...	Línea 53...
53	`// Ensure the new value is picked up and not taken from the cache.`	53	`// Ensure the new value is picked up and not taken from the cache.`
54	`$stringmanager = get_string_manager();`	54	`$stringmanager = get_string_manager();`
55	`$stringmanager->reset_caches(true);`	55	`$stringmanager->reset_caches(true);`
56	`}`	56	`}`
Línea 57...	Línea 57...
57		57
58	`public function test_cleanremoteaddr() {`	58	`public function test_cleanremoteaddr(): void {`
59	`// IPv4.`	59	`// IPv4.`
60	`$this->assertNull(cleanremoteaddr('1023.121.234.1'));`	60	`$this->assertNull(cleanremoteaddr('1023.121.234.1'));`
Línea 61...	Línea 61...
61	`$this->assertSame('123.121.234.1', cleanremoteaddr('123.121.234.01 '));`	61	`$this->assertSame('123.121.234.1', cleanremoteaddr('123.121.234.01 '));`
Línea 72...	Línea 72...
72	`$this->assertSame('1:1:0:0:0:0:0:0', cleanremoteaddr('01:1::', false));`	72	`$this->assertSame('1:1:0:0:0:0:0:0', cleanremoteaddr('01:1::', false));`
73	`$this->assertSame('10:0:0:0:0:0:0:10', cleanremoteaddr('10::10', false));`	73	`$this->assertSame('10:0:0:0:0:0:0:10', cleanremoteaddr('10::10', false));`
74	`$this->assertSame('::ffff:c0a8:11', cleanremoteaddr('::ffff:192.168.1.1', true));`	74	`$this->assertSame('::ffff:c0a8:11', cleanremoteaddr('::ffff:192.168.1.1', true));`
75	`}`	75	`}`
Línea 76...	Línea 76...
76		76
77	`public function test_address_in_subnet() {`	77	`public function test_address_in_subnet(): void {`
78	`// 1: xxx.xxx.xxx.xxx/nn or xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/nnn (number of bits in net mask).`	78	`// 1: xxx.xxx.xxx.xxx/nn or xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/nnn (number of bits in net mask).`
79	`$this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.1/32'));`	79	`$this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.1/32'));`
80	`$this->assertFalse(address_in_subnet('123.121.23.1', '123.121.23.0/32'));`	80	`$this->assertFalse(address_in_subnet('123.121.23.1', '123.121.23.0/32'));`
81	`$this->assertTrue(address_in_subnet('10.10.10.100', '123.121.23.45/0'));`	81	`$this->assertTrue(address_in_subnet('10.10.10.100', '123.121.23.45/0'));`
Línea 157...	Línea 157...
157		157
158	`// Other incorrect input.`	158	`// Other incorrect input.`
159	`$this->assertFalse(address_in_subnet('123.123.123.123', ''));`	159	`$this->assertFalse(address_in_subnet('123.123.123.123', ''));`
Línea 160...	Línea 160...
160	`}`	160	`}`
161		161
162	`public function test_fix_utf8() {`	162	`public function test_fix_utf8(): void {`
163	`// Make sure valid data including other types is not changed.`	163	`// Make sure valid data including other types is not changed.`
164	`$this->assertSame(null, fix_utf8(null));`	164	`$this->assertSame(null, fix_utf8(null));`
165	`$this->assertSame(1, fix_utf8(1));`	165	`$this->assertSame(1, fix_utf8(1));`
Línea 180...	Línea 180...
180	`// Invalid utf8 string.`	180	`// Invalid utf8 string.`
181	`$this->assertSame('aš', fix_utf8('a'.chr(130).'š'), 'This fails with buggy iconv() when mbstring extenstion is not available as fallback.');`	181	`$this->assertSame('aš', fix_utf8('a'.chr(130).'š'), 'This fails with buggy iconv() when mbstring extenstion is not available as fallback.');`
182	`$this->assertSame('Hello ', fix_utf8('Hello ï¿¿'));`	182	`$this->assertSame('Hello ', fix_utf8('Hello ï¿¿'));`
183	`}`	183	`}`
Línea 184...	Línea 184...
184		184
185	`public function test_optional_param() {`	185	`public function test_optional_param(): void {`
Línea 186...	Línea 186...
186	`global $CFG;`	186	`global $CFG;`
187		187
188	`$_POST['username'] = 'post_user';`	188	`$_POST['username'] = 'post_user';`
Línea 202...	Línea 202...
202	`$this->fail('coding_exception expected');`	202	`$this->fail('coding_exception expected');`
203	`} catch (\coding_exception $e) {`	203	`} catch (\coding_exception $e) {`
204	`}`	204	`}`
205	`}`	205	`}`
Línea 206...	Línea 206...
206		206
207	`public function test_optional_param_array() {`	207	`public function test_optional_param_array(): void {`
Línea 208...	Línea 208...
208	`global $CFG;`	208	`global $CFG;`
209		209
210	`$_POST['username'] = array('a'=>'post_user');`	210	`$_POST['username'] = array('a'=>'post_user');`
Línea 235...	Línea 235...
235	`$_POST['username'] = array('abc123_;-/*-+ '=>'arrggh', 'a1_-'=>'post_user');`	235	`$_POST['username'] = array('abc123_;-/*-+ '=>'arrggh', 'a1_-'=>'post_user');`
236	`$this->assertSame(array('a1_-'=>'post_user'), optional_param_array('username', array(), PARAM_RAW));`	236	`$this->assertSame(array('a1_-'=>'post_user'), optional_param_array('username', array(), PARAM_RAW));`
237	`$this->assertDebuggingCalled();`	237	`$this->assertDebuggingCalled();`
238	`}`	238	`}`
Línea 239...	Línea 239...
239		239
240	`public function test_required_param() {`	240	`public function test_required_param(): void {`
241	`$_POST['username'] = 'post_user';`	241	`$_POST['username'] = 'post_user';`
242	`$_GET['username'] = 'get_user';`	242	`$_GET['username'] = 'get_user';`
Línea 243...	Línea 243...
243	`$this->assertSame('post_user', required_param('username', PARAM_RAW));`	243	`$this->assertSame('post_user', required_param('username', PARAM_RAW));`
Línea 266...	Línea 266...
266	`$this->fail('coding_exception expected');`	266	`$this->fail('coding_exception expected');`
267	`} catch (\coding_exception $e) {`	267	`} catch (\coding_exception $e) {`
268	`}`	268	`}`
269	`}`	269	`}`
Línea 270...	Línea 270...
270		270
271	`public function test_required_param_array() {`	271	`public function test_required_param_array(): void {`
Línea 272...	Línea 272...
272	`global $CFG;`	272	`global $CFG;`
273		273
274	`$_POST['username'] = array('a'=>'post_user');`	274	`$_POST['username'] = array('a'=>'post_user');`
Línea 304...	Línea 304...
304		304
305	`/**`	305	`/**`
306	`* @covers \core\param`	306	`* @covers \core\param`
307	`* @covers \clean_param`	307	`* @covers \clean_param`
308	`*/`	308	`*/`
309	`public function test_clean_param() {`	309	`public function test_clean_param(): void {`
310	`// Forbid objects and arrays.`	310	`// Forbid objects and arrays.`
311	`try {`	311	`try {`
312	`clean_param(array('x', 'y'), PARAM_RAW);`	312	`clean_param(array('x', 'y'), PARAM_RAW);`
313	`$this->fail('coding_exception expected');`	313	`$this->fail('coding_exception expected');`
Línea 334...	Línea 334...
334		334
335	`/**`	335	`/**`
336	`* @covers \core\param`	336	`* @covers \core\param`
337	`* @covers \clean_param`	337	`* @covers \clean_param`
338	`*/`	338	`*/`
339	`public function test_clean_param_array() {`	339	`public function test_clean_param_array(): void {`
340	`$this->assertSame(array(), clean_param_array(null, PARAM_RAW));`	340	`$this->assertSame(array(), clean_param_array(null, PARAM_RAW));`
341	`$this->assertSame(array('a', 'b'), clean_param_array(array('a', 'b'), PARAM_RAW));`	341	`$this->assertSame(array('a', 'b'), clean_param_array(array('a', 'b'), PARAM_RAW));`
Línea 342...	Línea 342...
342	`$this->assertSame(array('a', array('b')), clean_param_array(array('a', array('b')), PARAM_RAW, true));`	342	`$this->assertSame(array('a', array('b')), clean_param_array(array('a', array('b')), PARAM_RAW, true));`
Línea 361...	Línea 361...
361		361
362	`/**`	362	`/**`
363	`* @covers \core\param`	363	`* @covers \core\param`
364	`* @covers \clean_param`	364	`* @covers \clean_param`
365	`*/`	365	`*/`
366	`public function test_clean_param_raw() {`	366	`public function test_clean_param_raw(): void {`
367	`$this->assertSame(`	367	`$this->assertSame(`
368	`'#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)',`	368	`'#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)',`
369	`clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_RAW));`	369	`clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_RAW));`
370	`$this->assertSame(null, clean_param(null, PARAM_RAW));`	370	`$this->assertSame(null, clean_param(null, PARAM_RAW));`
Línea 371...	Línea 371...
371	`}`	371	`}`
372		372
373	`/**`	373	`/**`
374	`* @covers \core\param`	374	`* @covers \core\param`
375	`* @covers \clean_param`	375	`* @covers \clean_param`
376	`*/`	376	`*/`
377	`public function test_clean_param_trim() {`	377	`public function test_clean_param_trim(): void {`
378	`$this->assertSame('Frog toad', clean_param(" Frog toad \r\n ", PARAM_RAW_TRIMMED));`	378	`$this->assertSame('Frog toad', clean_param(" Frog toad \r\n ", PARAM_RAW_TRIMMED));`
Línea 379...	Línea 379...
379	`$this->assertSame('', clean_param(null, PARAM_RAW_TRIMMED));`	379	`$this->assertSame('', clean_param(null, PARAM_RAW_TRIMMED));`
380	`}`	380	`}`
381		381
382	`/**`	382	`/**`
383	`* @covers \core\param`	383	`* @covers \core\param`
384	`* @covers \clean_param`	384	`* @covers \clean_param`
385	`*/`	385	`*/`
386	`public function test_clean_param_clean() {`	386	`public function test_clean_param_clean(): void {`
387	`// PARAM_CLEAN is an ugly hack, do not use in new code (skodak),`	387	`// PARAM_CLEAN is an ugly hack, do not use in new code (skodak),`
388	`// instead use more specific type, or submit sothing that can be verified properly.`	388	`// instead use more specific type, or submit sothing that can be verified properly.`
Línea 393...	Línea 393...
393		393
394	`/**`	394	`/**`
395	`* @covers \core\param`	395	`* @covers \core\param`
396	`* @covers \clean_param`	396	`* @covers \clean_param`
397	`*/`	397	`*/`
398	`public function test_clean_param_alpha() {`	398	`public function test_clean_param_alpha(): void {`
399	`$this->assertSame('DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHA));`	399	`$this->assertSame('DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHA));`
400	`$this->assertSame('', clean_param(null, PARAM_ALPHA));`	400	`$this->assertSame('', clean_param(null, PARAM_ALPHA));`
Línea 401...	Línea 401...
401	`}`	401	`}`
402		402
403	`/**`	403	`/**`
404	`* @covers \core\param`	404	`* @covers \core\param`
405	`* @covers \clean_param`	405	`* @covers \clean_param`
406	`*/`	406	`*/`
407	`public function test_clean_param_alphanum() {`	407	`public function test_clean_param_alphanum(): void {`
408	`$this->assertSame('978942897DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHANUM));`	408	`$this->assertSame('978942897DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHANUM));`
Línea 409...	Línea 409...
409	`$this->assertSame('', clean_param(null, PARAM_ALPHANUM));`	409	`$this->assertSame('', clean_param(null, PARAM_ALPHANUM));`
410	`}`	410	`}`
411		411
412	`/**`	412	`/**`
413	`* @covers \core\param`	413	`* @covers \core\param`
414	`* @covers \clean_param`	414	`* @covers \clean_param`
415	`*/`	415	`*/`
416	`public function test_clean_param_alphaext() {`	416	`public function test_clean_param_alphaext(): void {`
Línea 417...	Línea 417...
417	`$this->assertSame('DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHAEXT));`	417	`$this->assertSame('DSFMOSDJ', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_ALPHAEXT));`
418	`$this->assertSame('', clean_param(null, PARAM_ALPHAEXT));`	418	`$this->assertSame('', clean_param(null, PARAM_ALPHAEXT));`
419	`}`	419	`}`
420		420
421	`/**`	421	`/**`
422	`* @covers \core\param`	422	`* @covers \core\param`
423	`* @covers \clean_param`	423	`* @covers \clean_param`
424	`*/`	424	`*/`
Línea 425...	Línea 425...
425	`public function test_clean_param_sequence() {`	425	`public function test_clean_param_sequence(): void {`
426	`$this->assertSame(',9789,42897', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_SEQUENCE));`	426	`$this->assertSame(',9789,42897', clean_param('#()#,9789\'".,<42897></?$(DSFMO#$)(SDJ)($)', PARAM_SEQUENCE));`
427	`$this->assertSame('', clean_param(null, PARAM_SEQUENCE));`	427	`$this->assertSame('', clean_param(null, PARAM_SEQUENCE));`
428	`}`	428	`}`
429		429
430	`/**`	430	`/**`
431	`* @covers \core\param`	431	`* @covers \core\param`
432	`* @covers \clean_param`	432	`* @covers \clean_param`
433	`*/`	433	`*/`
434	`public function test_clean_param_component() {`	434	`public function test_clean_param_component(): void {`
Línea 462...	Línea 462...
462		462
463	`/**`	463	`/**`
464	`* @covers \core\param`	464	`* @covers \core\param`
465	`* @covers \clean_param`	465	`* @covers \clean_param`
466	`*/`	466	`*/`
Línea 467...	Línea 467...
467	`public function test_clean_param_localisedfloat() {`	467	`public function test_clean_param_localisedfloat(): void {`
468		468
469	`$this->assertSame(0.5, clean_param('0.5', PARAM_LOCALISEDFLOAT));`	469	`$this->assertSame(0.5, clean_param('0.5', PARAM_LOCALISEDFLOAT));`
470	`$this->assertSame(false, clean_param('0X5', PARAM_LOCALISEDFLOAT));`	470	`$this->assertSame(false, clean_param('0X5', PARAM_LOCALISEDFLOAT));`
Línea 495...	Línea 495...
495	`$this->assertSame(false, clean_param('1X000X5', PARAM_LOCALISEDFLOAT));`	495	`$this->assertSame(false, clean_param('1X000X5', PARAM_LOCALISEDFLOAT));`
496	`$this->assertSame(false, clean_param('nan', PARAM_LOCALISEDFLOAT));`	496	`$this->assertSame(false, clean_param('nan', PARAM_LOCALISEDFLOAT));`
497	`$this->assertSame(false, clean_param('10X6blah', PARAM_LOCALISEDFLOAT));`	497	`$this->assertSame(false, clean_param('10X6blah', PARAM_LOCALISEDFLOAT));`
498	`}`	498	`}`
Línea 499...	Línea 499...
499		499
500	`public function test_is_valid_plugin_name() {`	500	`public function test_is_valid_plugin_name(): void {`
501	`$this->assertTrue(is_valid_plugin_name('forum'));`	501	`$this->assertTrue(is_valid_plugin_name('forum'));`
502	`$this->assertTrue(is_valid_plugin_name('forum2'));`	502	`$this->assertTrue(is_valid_plugin_name('forum2'));`
503	`$this->assertTrue(is_valid_plugin_name('feedback360'));`	503	`$this->assertTrue(is_valid_plugin_name('feedback360'));`
504	`$this->assertTrue(is_valid_plugin_name('online_users'));`	504	`$this->assertTrue(is_valid_plugin_name('online_users'));`
Línea 515...	Línea 515...
515		515
516	`/**`	516	`/**`
517	`* @covers \core\param`	517	`* @covers \core\param`
518	`* @covers \clean_param`	518	`* @covers \clean_param`
519	`*/`	519	`*/`
520	`public function test_clean_param_plugin() {`	520	`public function test_clean_param_plugin(): void {`
521	`// Please note the cleaning of plugin names is very strict, no guessing here.`	521	`// Please note the cleaning of plugin names is very strict, no guessing here.`
522	`$this->assertSame('forum', clean_param('forum', PARAM_PLUGIN));`	522	`$this->assertSame('forum', clean_param('forum', PARAM_PLUGIN));`
523	`$this->assertSame('forum2', clean_param('forum2', PARAM_PLUGIN));`	523	`$this->assertSame('forum2', clean_param('forum2', PARAM_PLUGIN));`
524	`$this->assertSame('feedback360', clean_param('feedback360', PARAM_PLUGIN));`	524	`$this->assertSame('feedback360', clean_param('feedback360', PARAM_PLUGIN));`
Línea 537...	Línea 537...
537		537
538	`/**`	538	`/**`
539	`* @covers \core\param`	539	`* @covers \core\param`
540	`* @covers \clean_param`	540	`* @covers \clean_param`
541	`*/`	541	`*/`
542	`public function test_clean_param_area() {`	542	`public function test_clean_param_area(): void {`
543	`// Please note the cleaning of area names is very strict, no guessing here.`	543	`// Please note the cleaning of area names is very strict, no guessing here.`
544	`$this->assertSame('something', clean_param('something', PARAM_AREA));`	544	`$this->assertSame('something', clean_param('something', PARAM_AREA));`
545	`$this->assertSame('something2', clean_param('something2', PARAM_AREA));`	545	`$this->assertSame('something2', clean_param('something2', PARAM_AREA));`
546	`$this->assertSame('some_thing', clean_param('some_thing', PARAM_AREA));`	546	`$this->assertSame('some_thing', clean_param('some_thing', PARAM_AREA));`
Línea 558...	Línea 558...
558		558
559	`/**`	559	`/**`
560	`* @covers \core\param`	560	`* @covers \core\param`
561	`* @covers \clean_param`	561	`* @covers \clean_param`
562	`*/`	562	`*/`
563	`public function test_clean_param_text() {`	563	`public function test_clean_param_text(): void {`
564	`// Standard.`	564	`// Standard.`
565	`$this->assertSame('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', PARAM_TEXT));`	565	`$this->assertSame('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa</lang><lang lang="yy">pp</lang>', PARAM_TEXT));`
566	`$this->assertSame('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', clean_param('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', PARAM_TEXT));`	566	`$this->assertSame('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', clean_param('<span lang="en" class="multilang">aa</span><span lang="xy" class="multilang">bb</span>', PARAM_TEXT));`
567	`$this->assertSame('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', PARAM_TEXT));`	567	`$this->assertSame('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', clean_param('xx<lang lang="en">aa'."\n".'</lang><lang lang="yy">pp</lang>', PARAM_TEXT));`
Línea 616...	Línea 616...
616		616
617	`/**`	617	`/**`
618	`* @covers \core\param`	618	`* @covers \core\param`
619	`* @covers \clean_param`	619	`* @covers \clean_param`
620	`*/`	620	`*/`
621	`public function test_clean_param_url() {`	621	`public function test_clean_param_url(): void {`
622	`// Test PARAM_URL and PARAM_LOCALURL a bit.`	622	`// Test PARAM_URL and PARAM_LOCALURL a bit.`
623	`// Valid URLs.`	623	`// Valid URLs.`
624	`$this->assertSame('http://google.com/', clean_param('http://google.com/', PARAM_URL));`	624	`$this->assertSame('http://google.com/', clean_param('http://google.com/', PARAM_URL));`
625	`$this->assertSame('http://some.very.long.and.silly.domain/with/a/path/', clean_param('http://some.very.long.and.silly.domain/with/a/path/', PARAM_URL));`	625	`$this->assertSame('http://some.very.long.and.silly.domain/with/a/path/', clean_param('http://some.very.long.and.silly.domain/with/a/path/', PARAM_URL));`
Línea 646...	Línea 646...
646		646
647	`/**`	647	`/**`
648	`* @covers \core\param`	648	`* @covers \core\param`
649	`* @covers \clean_param`	649	`* @covers \clean_param`
650	`*/`	650	`*/`
651	`public function test_clean_param_localurl() {`	651	`public function test_clean_param_localurl(): void {`
Línea 652...	Línea 652...
652	`global $CFG;`	652	`global $CFG;`
Línea 653...	Línea 653...
653		653
Línea 693...	Línea 693...
693		693
694	`/**`	694	`/**`
695	`* @covers \core\param`	695	`* @covers \core\param`
696	`* @covers \clean_param`	696	`* @covers \clean_param`
697	`*/`	697	`*/`
698	`public function test_clean_param_file() {`	698	`public function test_clean_param_file(): void {`
699	`$this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_FILE));`	699	`$this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_FILE));`
700	$this->assertSame('badfile.txt', clean_param('b\'a<d`\\/fi:l>e.t"x\|t', PARAM_FILE));	700	$this->assertSame('badfile.txt', clean_param('b\'a<d`\\/fi:l>e.t"x\|t', PARAM_FILE));
701	`$this->assertSame('..parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_FILE));`	701	`$this->assertSame('..parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_FILE));`
702	`$this->assertSame('....grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_FILE));`	702	`$this->assertSame('....grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_FILE));`
Línea 729...	Línea 729...
729		729
730	`/**`	730	`/**`
731	`* @covers \core\param`	731	`* @covers \core\param`
732	`* @covers \clean_param`	732	`* @covers \clean_param`
733	`*/`	733	`*/`
734	`public function test_clean_param_path() {`	734	`public function test_clean_param_path(): void {`
735	`$this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_PATH));`	735	`$this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_PATH));`
736	$this->assertSame('bad/file.txt', clean_param('b\'a<d`\\/fi:l>e.t"x\|t', PARAM_PATH));	736	$this->assertSame('bad/file.txt', clean_param('b\'a<d`\\/fi:l>e.t"x\|t', PARAM_PATH));
737	`$this->assertSame('/parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_PATH));`	737	`$this->assertSame('/parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_PATH));`
738	`$this->assertSame('/grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_PATH));`	738	`$this->assertSame('/grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_PATH));`
Línea 754...	Línea 754...
754		754
755	`/**`	755	`/**`
756	`* @covers \core\param`	756	`* @covers \core\param`
757	`* @covers \clean_param`	757	`* @covers \clean_param`
758	`*/`	758	`*/`
759	`public function test_clean_param_safepath() {`	759	`public function test_clean_param_safepath(): void {`
760	`$this->assertSame('folder/file', clean_param('folder/file', PARAM_SAFEPATH));`	760	`$this->assertSame('folder/file', clean_param('folder/file', PARAM_SAFEPATH));`
761	`$this->assertSame('folder//file', clean_param('folder/../file', PARAM_SAFEPATH));`	761	`$this->assertSame('folder//file', clean_param('folder/../file', PARAM_SAFEPATH));`
762	`$this->assertSame('', clean_param(null, PARAM_SAFEPATH));`	762	`$this->assertSame('', clean_param(null, PARAM_SAFEPATH));`
Línea 763...	Línea 763...
763	`}`	763	`}`
764		764
765	`/**`	765	`/**`
766	`* @covers \core\param`	766	`* @covers \core\param`
767	`* @covers \clean_param`	767	`* @covers \clean_param`
768	`*/`	768	`*/`
769	`public function test_clean_param_username() {`	769	`public function test_clean_param_username(): void {`
Línea 770...	Línea 770...
770	`global $CFG;`	770	`global $CFG;`
771	`$currentstatus = $CFG->extendedusernamechars;`	771	`$currentstatus = $CFG->extendedusernamechars;`
Línea 803...	Línea 803...
803		803
804	`/**`	804	`/**`
805	`* @covers \core\param`	805	`* @covers \core\param`
806	`* @covers \clean_param`	806	`* @covers \clean_param`
807	`*/`	807	`*/`
808	`public function test_clean_param_stringid() {`	808	`public function test_clean_param_stringid(): void {`
809	`// Test string identifiers validation.`	809	`// Test string identifiers validation.`
810	`// Valid strings.`	810	`// Valid strings.`
811	`$this->assertSame('validstring', clean_param('validstring', PARAM_STRINGID));`	811	`$this->assertSame('validstring', clean_param('validstring', PARAM_STRINGID));`
812	`$this->assertSame('mod/foobar:valid_capability', clean_param('mod/foobar:valid_capability', PARAM_STRINGID));`	812	`$this->assertSame('mod/foobar:valid_capability', clean_param('mod/foobar:valid_capability', PARAM_STRINGID));`
Línea 824...	Línea 824...
824		824
825	`/**`	825	`/**`
826	`* @covers \core\param`	826	`* @covers \core\param`
827	`* @covers \clean_param`	827	`* @covers \clean_param`
828	`*/`	828	`*/`
829	`public function test_clean_param_timezone() {`	829	`public function test_clean_param_timezone(): void {`
830	`// Test timezone validation.`	830	`// Test timezone validation.`
831	`$testvalues = array (`	831	`$testvalues = array (`
832	`'America/Jamaica' => 'America/Jamaica',`	832	`'America/Jamaica' => 'America/Jamaica',`
833	`'America/Argentina/Cordoba' => 'America/Argentina/Cordoba',`	833	`'America/Argentina/Cordoba' => 'America/Argentina/Cordoba',`
Línea 858...	Línea 858...
858	`'13.5' => '',`	858	`'13.5' => '',`
859	`'+13.5' => '',`	859	`'+13.5' => '',`
860	`'-13.5' => '',`	860	`'-13.5' => '',`
861	`'0.2' => '',`	861	`'0.2' => '',`
862	`'' => '',`	862	`'' => '',`
863	`null => '',`	-
864	`);`	863	`);`
Línea 865...	Línea 864...
865		864
866	`foreach ($testvalues as $testvalue => $expectedvalue) {`	865	`foreach ($testvalues as $testvalue => $expectedvalue) {`
867	`$actualvalue = clean_param($testvalue, PARAM_TIMEZONE);`	866	`$actualvalue = clean_param($testvalue, PARAM_TIMEZONE);`
868	`$this->assertEquals($expectedvalue, $actualvalue);`	867	`$this->assertEquals($expectedvalue, $actualvalue);`
-		868	`}`
-		869
-		870	`// Test for null.`
869	`}`	871	`$this->assertEquals('', clean_param(null, PARAM_TIMEZONE));`
Línea 870...	Línea 872...
870	`}`	872	`}`
871		873
872	`/**`	874	`/**`
873	`* @covers \core\param`	875	`* @covers \core\param`
874	`* @covers \clean_param`	876	`* @covers \clean_param`
875	`*/`	877	`*/`
876	`public function test_clean_param_null_argument() {`	878	`public function test_clean_param_null_argument(): void {`
877	`$this->assertEquals(0, clean_param(null, PARAM_INT));`	879	`$this->assertEquals(0, clean_param(null, PARAM_INT));`
878	`$this->assertEquals(0, clean_param(null, PARAM_FLOAT));`	880	`$this->assertEquals(0, clean_param(null, PARAM_FLOAT));`
879	`$this->assertEquals(0, clean_param(null, PARAM_LOCALISEDFLOAT));`	881	`$this->assertEquals(0, clean_param(null, PARAM_LOCALISEDFLOAT));`
Línea 891...	Línea 893...
891	`$this->assertEquals('', clean_param(null, PARAM_LANG));`	893	`$this->assertEquals('', clean_param(null, PARAM_LANG));`
892	`$this->assertEquals('', clean_param(null, PARAM_THEME));`	894	`$this->assertEquals('', clean_param(null, PARAM_THEME));`
893	`$this->assertEquals('', clean_param(null, PARAM_EMAIL));`	895	`$this->assertEquals('', clean_param(null, PARAM_EMAIL));`
894	`}`	896	`}`
Línea 895...	Línea 897...
895		897
896	`public function test_validate_param() {`	898	`public function test_validate_param(): void {`
897	`try {`	899	`try {`
898	`$param = validate_param('11a', PARAM_INT);`	900	`$param = validate_param('11a', PARAM_INT);`
899	`$this->fail('invalid_parameter_exception expected');`	901	`$this->fail('invalid_parameter_exception expected');`
900	`} catch (\moodle_exception $ex) {`	902	`} catch (\moodle_exception $ex) {`
Línea 973...	Línea 975...
973	`} catch (\moodle_exception $ex) {`	975	`} catch (\moodle_exception $ex) {`
974	`$this->assertInstanceOf('invalid_parameter_exception', $ex);`	976	`$this->assertInstanceOf('invalid_parameter_exception', $ex);`
975	`}`	977	`}`
976	`}`	978	`}`
Línea 977...	Línea 979...
977		979
978	`public function test_shorten_text_no_tags_already_short_enough() {`	980	`public function test_shorten_text_no_tags_already_short_enough(): void {`
979	`// ......12345678901234567890123456.`	981	`// ......12345678901234567890123456.`
980	`$text = "short text already no tags";`	982	`$text = "short text already no tags";`
981	`$this->assertSame($text, shorten_text($text));`	983	`$this->assertSame($text, shorten_text($text));`
Línea 982...	Línea 984...
982	`}`	984	`}`
983		985
984	`public function test_shorten_text_with_tags_already_short_enough() {`	986	`public function test_shorten_text_with_tags_already_short_enough(): void {`
985	`// .........123456...7890....12345678.......901234567.`	987	`// .........123456...7890....12345678.......901234567.`
986	`$text = "<p>short <b>text</b> already</p><p>with tags</p>";`	988	`$text = "<p>short <b>text</b> already</p><p>with tags</p>";`
Línea 987...	Línea 989...
987	`$this->assertSame($text, shorten_text($text));`	989	`$this->assertSame($text, shorten_text($text));`
988	`}`	990	`}`
989		991
990	`public function test_shorten_text_no_tags_needs_shortening() {`	992	`public function test_shorten_text_no_tags_needs_shortening(): void {`
991	`// Default truncation is after 30 chars, but allowing 3 for the final '...'.`	993	`// Default truncation is after 30 chars, but allowing 3 for the final '...'.`
992	`// ......12345678901234567890123456789023456789012345678901234.`	994	`// ......12345678901234567890123456789023456789012345678901234.`
Línea 993...	Línea 995...
993	`$text = "long text without any tags blah de blah blah blah what";`	995	`$text = "long text without any tags blah de blah blah blah what";`
994	`$this->assertSame('long text without any tags ...', shorten_text($text));`	996	`$this->assertSame('long text without any tags ...', shorten_text($text));`
995	`}`	997	`}`
996		998
997	`public function test_shorten_text_with_tags_needs_shortening() {`	999	`public function test_shorten_text_with_tags_needs_shortening(): void {`
998	`// .......................................123456789012345678901234567890...`	1000	`// .......................................123456789012345678901234567890...`
999	`$text = "<div class='frog'><p><blockquote>Long text with tags that will ".`	1001	`$text = "<div class='frog'><p><blockquote>Long text with tags that will ".`
Línea 1000...	Línea 1002...
1000	`"be chopped off but <b>should be added back again</b></blockquote></p></div>";`	1002	`"be chopped off but <b>should be added back again</b></blockquote></p></div>";`
1001	`$this->assertEquals("<div class='frog'><p><blockquote>Long text with " .`	1003	`$this->assertEquals("<div class='frog'><p><blockquote>Long text with " .`
1002	`"tags that ...</blockquote></p></div>", shorten_text($text));`	1004	`"tags that ...</blockquote></p></div>", shorten_text($text));`
1003	`}`	1005	`}`
1004		1006
1005	`public function test_shorten_text_with_tags_and_html_comment() {`	1007	`public function test_shorten_text_with_tags_and_html_comment(): void {`
1006	`$text = "<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with ".`	1008	`$text = "<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with ".`
Línea 1007...	Línea 1009...
1007	`"tags that will<!--<![endif]--> ".`	1009	`"tags that will<!--<![endif]--> ".`
1008	`"be chopped off but <b>should be added back again</b></blockquote></p></div>";`	1010	`"be chopped off but <b>should be added back again</b></blockquote></p></div>";`
1009	`$this->assertEquals("<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with " .`	1011	`$this->assertEquals("<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with " .`
1010	`"tags that ...<!--<![endif]--></blockquote></p></div>", shorten_text($text));`	1012	`"tags that ...<!--<![endif]--></blockquote></p></div>", shorten_text($text));`
1011	`}`	1013	`}`
1012		1014
1013	`public function test_shorten_text_with_entities() {`	1015	`public function test_shorten_text_with_entities(): void {`
1014	`// Remember to allow 3 chars for the final '...'.`	1016	`// Remember to allow 3 chars for the final '...'.`
Línea 1015...	Línea 1017...
1015	`// ......123456789012345678901234567_____890...`	1017	`// ......123456789012345678901234567_____890...`
1016	`$text = "some text which shouldn't   break there";`	1018	`$text = "some text which shouldn't   break there";`
1017	`$this->assertSame("some text which shouldn't   ...", shorten_text($text, 31));`	1019	`$this->assertSame("some text which shouldn't   ...", shorten_text($text, 31));`
1018	`$this->assertSame("some text which shouldn't  ...", shorten_text($text, 30));`	1020	`$this->assertSame("some text which shouldn't  ...", shorten_text($text, 30));`
1019	`$this->assertSame("some text which shouldn't ...", shorten_text($text, 29));`	1021	`$this->assertSame("some text which shouldn't ...", shorten_text($text, 29));`
1020	`}`	1022	`}`
Línea 1029...	Línea 1031...
1029	`shorten_text($text, 42));`	1031	`shorten_text($text, 42));`
1030	`$this->assertSame("<h3>standard 'break-out' sub groups in TGs?</h3> ...",`	1032	`$this->assertSame("<h3>standard 'break-out' sub groups in TGs?</h3> ...",`
1031	`shorten_text($text, 43));`	1033	`shorten_text($text, 43));`
1032	`}`	1034	`}`
Línea 1033...	Línea 1035...
1033		1035
1034	`public function test_shorten_text_no_spaces() {`	1036	`public function test_shorten_text_no_spaces(): void {`
1035	`// ..........123456789.`	1037	`// ..........123456789.`
1036	`$text = "<h1>123456789</h1>"; // A string with no convenient breaks.`	1038	`$text = "<h1>123456789</h1>"; // A string with no convenient breaks.`
1037	`$this->assertSame("<h1>12345...</h1>", shorten_text($text, 8));`	1039	`$this->assertSame("<h1>12345...</h1>", shorten_text($text, 8));`
Línea 1038...	Línea 1040...
1038	`}`	1040	`}`
1039		1041
1040	`public function test_shorten_text_utf8_european() {`	1042	`public function test_shorten_text_utf8_european(): void {`
1041	`// Text without tags.`	1043	`// Text without tags.`
1042	`// ......123456789012345678901234567.`	1044	`// ......123456789012345678901234567.`
1043	`$text = "Žluťoučký koníček přeskočil";`	1045	`$text = "Žluťoučký koníček přeskočil";`
Línea 1062...	Línea 1064...
1062	`$this->assertSame("<p>Žluťoučký koníček <b>přeskočil</b> pot...</p>", shorten_text($text, 34, true));`	1064	`$this->assertSame("<p>Žluťoučký koníček <b>přeskočil</b> pot...</p>", shorten_text($text, 34, true));`
1063	`// And in the middle of one tag.`	1065	`// And in the middle of one tag.`
1064	`$this->assertSame("<p>Žluťoučký koníček <b>přeskočil...</b></p>", shorten_text($text, 30, true));`	1066	`$this->assertSame("<p>Žluťoučký koníček <b>přeskočil...</b></p>", shorten_text($text, 30, true));`
1065	`}`	1067	`}`
Línea 1066...	Línea 1068...
1066		1068
1067	`public function test_shorten_text_utf8_oriental() {`	1069	`public function test_shorten_text_utf8_oriental(): void {`
1068	`// Japanese`	1070	`// Japanese`
1069	`// text without tags`	1071	`// text without tags`
1070	`// ......123456789012345678901234.`	1072	`// ......123456789012345678901234.`
1071	`$text = '言語設定言語設定abcdefghijkl';`	1073	`$text = '言語設定言語設定abcdefghijkl';`
Línea 1084...	Línea 1086...
1084	`$this->assertSame("简体中文简体...", shorten_text($text, 9, false));`	1086	`$this->assertSame("简体中文简体...", shorten_text($text, 9, false));`
1085	`$this->assertSame("简体中文简体中文ab...", shorten_text($text, 13, true));`	1087	`$this->assertSame("简体中文简体中文ab...", shorten_text($text, 13, true));`
1086	`$this->assertSame("简体中文简体中文...", shorten_text($text, 13, false));`	1088	`$this->assertSame("简体中文简体中文...", shorten_text($text, 13, false));`
1087	`}`	1089	`}`
Línea 1088...	Línea 1090...
1088		1090
1089	`public function test_shorten_text_multilang() {`	1091	`public function test_shorten_text_multilang(): void {`
1090	`// This is not necessaryily specific to multilang. The issue is really`	1092	`// This is not necessaryily specific to multilang. The issue is really`
1091	`// tags with attributes, where before we were generating invalid HTML`	1093	`// tags with attributes, where before we were generating invalid HTML`
1092	`// output like shorten_text('<span id="x" class="y">A</span> B', 1)`	1094	`// output like shorten_text('<span id="x" class="y">A</span> B', 1)`
1093	`// returning '<span id="x" ...</span>'. It is just that multilang`	1095	`// returning '<span id="x" ...</span>'. It is just that multilang`
Línea 1192...	Línea 1194...
1192	`* @param string $filename`	1194	`* @param string $filename`
1193	`* @param int $length`	1195	`* @param int $length`
1194	`* @param string $expected`	1196	`* @param string $expected`
1195	`* @param boolean $includehash`	1197	`* @param boolean $includehash`
1196	`*/`	1198	`*/`
1197	`public function test_shorten_filename($filename, $length, $expected, $includehash) {`	1199	`public function test_shorten_filename($filename, $length, $expected, $includehash): void {`
1198	`if (null === $length) {`	1200	`if (null === $length) {`
1199	`$length = MAX_FILENAME_SIZE;`	1201	`$length = MAX_FILENAME_SIZE;`
1200	`}`	1202	`}`
Línea 1201...	Línea 1203...
1201		1203
Línea 1323...	Línea 1325...
1323	`* @param array $filenames`	1325	`* @param array $filenames`
1324	`* @param int $length`	1326	`* @param int $length`
1325	`* @param string $expected`	1327	`* @param string $expected`
1326	`* @param boolean $includehash`	1328	`* @param boolean $includehash`
1327	`*/`	1329	`*/`
1328	`public function test_shorten_filenames($filenames, $length, $expected, $includehash) {`	1330	`public function test_shorten_filenames($filenames, $length, $expected, $includehash): void {`
1329	`if (null === $length) {`	1331	`if (null === $length) {`
1330	`$length = MAX_FILENAME_SIZE;`	1332	`$length = MAX_FILENAME_SIZE;`
1331	`}`	1333	`}`
Línea 1332...	Línea 1334...
1332		1334

Proyectos de Subversion Moodle

(root)/lib/tests/moodlelib_test.php – Rev 1 → 11