PageRenderTime 102ms CodeModel.GetById 34ms RepoModel.GetById 0ms app.codeStats 1ms

/lib/tests/moodlelib_test.php

https://github.com/dcai/moodle
PHP | 4690 lines | 3410 code | 542 blank | 738 comment | 18 complexity | 7f786953036f6286f8245824fb854600 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, MIT, GPL-3.0, Apache-2.0 
    

  1. <?php
    2. 

  2. // This file is part of Moodle - http://moodle.org/
    3. 

  3. //
    4. 

  4. // Moodle is free software: you can redistribute it and/or modify
    5. 

  5. // it under the terms of the GNU General Public License as published by
    6. 

  6. // the Free Software Foundation, either version 3 of the License, or
    7. 

  7. // (at your option) any later version.
    8. 

  8. //
    9. 

  9. // Moodle is distributed in the hope that it will be useful,
    10. 

  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11. 

  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12. 

  12. // GNU General Public License for more details.
    13. 

  13. //
    14. 

  14. // You should have received a copy of the GNU General Public License
    15. 

  15. // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
    16. 

  16. 

  17. /**
    18. 

  18.  * Unit tests for (some of) ../moodlelib.php.
    19. 

  19.  *
    20. 

  20.  * @package    core
    21. 

  21.  * @category   phpunit
    22. 

  22.  * @copyright  &copy; 2006 The Open University
    23. 

  23.  * @author     T.J.Hunt@open.ac.uk
    24. 

  24.  * @author     nicolas@moodle.com
    25. 

  25.  */
    26. 

  26. 

  27. defined('MOODLE_INTERNAL') || die();
    28. 

  28. 

  29. class core_moodlelib_testcase extends advanced_testcase {
    30. 

  30. 

  31.     public static $includecoverage = array('lib/moodlelib.php');
    32. 

  32. 

  33.     /**
    34. 

  34.      * Define a local decimal separator.
    35. 

  35.      *
    36. 

  36.      * It is not possible to directly change the result of get_string in
    37. 

  37.      * a unit test. Instead, we create a language pack for language 'xx' in
    38. 

  38.      * dataroot and make langconfig.php with the string we need to change.
    39. 

  39.      * The default example separator used here is 'X'; on PHP 5.3 and before this
    40. 

  40.      * must be a single byte character due to PHP bug/limitation in
    41. 

  41.      * number_format, so you can't use UTF-8 characters.
    42. 

  42.      *
    43. 

  43.      * @param string $decsep Separator character. Defaults to `'X'`.
    44. 

  44.      */
    45. 

  45.     protected function define_local_decimal_separator(string $decsep = 'X') {
    46. 

  46.         global $SESSION, $CFG;
    47. 

  47. 

  48.         $SESSION->lang = 'xx';
    49. 

  49.         $langconfig = "<?php\n\$string['decsep'] = '$decsep';";
    50. 

  50.         $langfolder = $CFG->dataroot . '/lang/xx';
    51. 

  51.         check_dir_exists($langfolder);
    52. 

  52.         file_put_contents($langfolder . '/langconfig.php', $langconfig);
    53. 

  53. 

  54.         // Ensure the new value is picked up and not taken from the cache.
    55. 

  55.         $stringmanager = get_string_manager();
    56. 

  56.         $stringmanager->reset_caches(true);
    57. 

  57.     }
    58. 

  58. 

  59.     public function test_cleanremoteaddr() {
    60. 

  60.         // IPv4.
    61. 

  61.         $this->assertNull(cleanremoteaddr('1023.121.234.1'));
    62. 

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

  63. 

  64.         // IPv6.
    65. 

  65.         $this->assertNull(cleanremoteaddr('0:0:0:0:0:0:0:0:0'));
    66. 

  66.         $this->assertNull(cleanremoteaddr('0:0:0:0:0:0:0:abh'));
    67. 

  67.         $this->assertNull(cleanremoteaddr('0:0:0:::0:0:1'));
    68. 

  68.         $this->assertSame('::', cleanremoteaddr('0:0:0:0:0:0:0:0', true));
    69. 

  69.         $this->assertSame('::1:1', cleanremoteaddr('0:0:0:0:0:0:1:1', true));
    70. 

  70.         $this->assertSame('abcd:ef::', cleanremoteaddr('abcd:00ef:0:0:0:0:0:0', true));
    71. 

  71.         $this->assertSame('1::1', cleanremoteaddr('1:0:0:0:0:0:0:1', true));
    72. 

  72.         $this->assertSame('0:0:0:0:0:0:10:1', cleanremoteaddr('::10:1', false));
    73. 

  73.         $this->assertSame('1:1:0:0:0:0:0:0', cleanremoteaddr('01:1::', false));
    74. 

  74.         $this->assertSame('10:0:0:0:0:0:0:10', cleanremoteaddr('10::10', false));
    75. 

  75.         $this->assertSame('::ffff:c0a8:11', cleanremoteaddr('::ffff:192.168.1.1', true));
    76. 

  76.     }
    77. 

  77. 

  78.     public function test_address_in_subnet() {
    79. 

  79.         // 1: xxx.xxx.xxx.xxx/nn or xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/nnn (number of bits in net mask).
    80. 

  80.         $this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.1/32'));
    81. 

  81.         $this->assertFalse(address_in_subnet('123.121.23.1', '123.121.23.0/32'));
    82. 

  82.         $this->assertTrue(address_in_subnet('10.10.10.100',  '123.121.23.45/0'));
    83. 

  83.         $this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.0/24'));
    84. 

  84.         $this->assertFalse(address_in_subnet('123.121.34.1', '123.121.234.0/24'));
    85. 

  85.         $this->assertTrue(address_in_subnet('123.121.234.1', '123.121.234.0/30'));
    86. 

  86.         $this->assertFalse(address_in_subnet('123.121.23.8', '123.121.23.0/30'));
    87. 

  87.         $this->assertTrue(address_in_subnet('baba:baba::baba', 'baba:baba::baba/128'));
    88. 

  88.         $this->assertFalse(address_in_subnet('bab:baba::baba', 'bab:baba::cece/128'));
    89. 

  89.         $this->assertTrue(address_in_subnet('baba:baba::baba', 'cece:cece::cece/0'));
    90. 

  90.         $this->assertTrue(address_in_subnet('baba:baba::baba', 'baba:baba::baba/128'));
    91. 

  91.         $this->assertTrue(address_in_subnet('baba:baba::00ba', 'baba:baba::/120'));
    92. 

  92.         $this->assertFalse(address_in_subnet('baba:baba::aba', 'baba:baba::/120'));
    93. 

  93.         $this->assertTrue(address_in_subnet('baba::baba:00ba', 'baba::baba:0/112'));
    94. 

  94.         $this->assertFalse(address_in_subnet('baba::aba:00ba', 'baba::baba:0/112'));
    95. 

  95.         $this->assertFalse(address_in_subnet('aba::baba:0000', 'baba::baba:0/112'));
    96. 

  96. 

  97.         // Fixed input.
    98. 

  98.         $this->assertTrue(address_in_subnet('123.121.23.1   ', ' 123.121.23.0 / 24'));
    99. 

  99.         $this->assertTrue(address_in_subnet('::ffff:10.1.1.1', ' 0:0:0:000:0:ffff:a1:10 / 126'));
    100. 

  100. 

  101.         // Incorrect input.
    102. 

  102.         $this->assertFalse(address_in_subnet('123.121.234.1', '123.121.234.1/-2'));
    103. 

  103.         $this->assertFalse(address_in_subnet('123.121.234.1', '123.121.234.1/64'));
    104. 

  104.         $this->assertFalse(address_in_subnet('123.121.234.x', '123.121.234.1/24'));
    105. 

  105.         $this->assertFalse(address_in_subnet('123.121.234.0', '123.121.234.xx/24'));
    106. 

  106.         $this->assertFalse(address_in_subnet('123.121.234.1', '123.121.234.1/xx0'));
    107. 

  107.         $this->assertFalse(address_in_subnet('::1', '::aa:0/xx0'));
    108. 

  108.         $this->assertFalse(address_in_subnet('::1', '::aa:0/-5'));
    109. 

  109.         $this->assertFalse(address_in_subnet('::1', '::aa:0/130'));
    110. 

  110.         $this->assertFalse(address_in_subnet('x:1', '::aa:0/130'));
    111. 

  111.         $this->assertFalse(address_in_subnet('::1', '::ax:0/130'));
    112. 

  112. 

  113.         // 2: xxx.xxx.xxx.xxx-yyy or  xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx::xxxx-yyyy (a range of IP addresses in the last group).
    114. 

  114.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121.234.12-14'));
    115. 

  115.         $this->assertTrue(address_in_subnet('123.121.234.13', '123.121.234.12-14'));
    116. 

  116.         $this->assertTrue(address_in_subnet('123.121.234.14', '123.121.234.12-14'));
    117. 

  117.         $this->assertFalse(address_in_subnet('123.121.234.1', '123.121.234.12-14'));
    118. 

  118.         $this->assertFalse(address_in_subnet('123.121.234.20', '123.121.234.12-14'));
    119. 

  119.         $this->assertFalse(address_in_subnet('123.121.23.12', '123.121.234.12-14'));
    120. 

  120.         $this->assertFalse(address_in_subnet('123.12.234.12', '123.121.234.12-14'));
    121. 

  121.         $this->assertTrue(address_in_subnet('baba:baba::baba', 'baba:baba::baba-babe'));
    122. 

  122.         $this->assertTrue(address_in_subnet('baba:baba::babc', 'baba:baba::baba-babe'));
    123. 

  123.         $this->assertTrue(address_in_subnet('baba:baba::babe', 'baba:baba::baba-babe'));
    124. 

  124.         $this->assertFalse(address_in_subnet('bab:baba::bab0', 'bab:baba::baba-babe'));
    125. 

  125.         $this->assertFalse(address_in_subnet('bab:baba::babf', 'bab:baba::baba-babe'));
    126. 

  126.         $this->assertFalse(address_in_subnet('bab:baba::bfbe', 'bab:baba::baba-babe'));
    127. 

  127.         $this->assertFalse(address_in_subnet('bfb:baba::babe', 'bab:baba::baba-babe'));
    128. 

  128. 

  129.         // Fixed input.
    130. 

  130.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121.234.12 - 14 '));
    131. 

  131.         $this->assertTrue(address_in_subnet('bab:baba::babe', 'bab:baba::baba - babe  '));
    132. 

  132. 

  133.         // Incorrect input.
    134. 

  134.         $this->assertFalse(address_in_subnet('123.121.234.12', '123.121.234.12-234.14'));
    135. 

  135.         $this->assertFalse(address_in_subnet('123.121.234.12', '123.121.234.12-256'));
    136. 

  136.         $this->assertFalse(address_in_subnet('123.121.234.12', '123.121.234.12--256'));
    137. 

  137. 

  138.         // 3: xxx.xxx or xxx.xxx. or xxx:xxx:xxxx or xxx:xxx:xxxx. (incomplete address, a bit non-technical ;-).
    139. 

  139.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121.234.12'));
    140. 

  140.         $this->assertFalse(address_in_subnet('123.121.23.12', '123.121.23.13'));
    141. 

  141.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121.234.'));
    142. 

  142.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121.234'));
    143. 

  143.         $this->assertTrue(address_in_subnet('123.121.234.12', '123.121'));
    144. 

  144.         $this->assertTrue(address_in_subnet('123.121.234.12', '123'));
    145. 

  145.         $this->assertFalse(address_in_subnet('123.121.234.1', '12.121.234.'));
    146. 

  146.         $this->assertFalse(address_in_subnet('123.121.234.1', '12.121.234'));
    147. 

  147.         $this->assertTrue(address_in_subnet('baba:baba::bab', 'baba:baba::bab'));
    148. 

  148.         $this->assertFalse(address_in_subnet('baba:baba::ba', 'baba:baba::bc'));
    149. 

  149.         $this->assertTrue(address_in_subnet('baba:baba::bab', 'baba:baba'));
    150. 

  150.         $this->assertTrue(address_in_subnet('baba:baba::bab', 'baba:'));
    151. 

  151.         $this->assertFalse(address_in_subnet('bab:baba::bab', 'baba:'));
    152. 

  152. 

  153.         // Multiple subnets.
    154. 

  154.         $this->assertTrue(address_in_subnet('123.121.234.12', '::1/64, 124., 123.121.234.10-30'));
    155. 

  155.         $this->assertTrue(address_in_subnet('124.121.234.12', '::1/64, 124., 123.121.234.10-30'));
    156. 

  156.         $this->assertTrue(address_in_subnet('::2',            '::1/64, 124., 123.121.234.10-30'));
    157. 

  157.         $this->assertFalse(address_in_subnet('12.121.234.12', '::1/64, 124., 123.121.234.10-30'));
    158. 

  158. 

  159.         // Other incorrect input.
    160. 

  160.         $this->assertFalse(address_in_subnet('123.123.123.123', ''));
    161. 

  161.     }
    162. 

  162. 

  163.     public function test_fix_utf8() {
    164. 

  164.         // Make sure valid data including other types is not changed.
    165. 

  165.         $this->assertSame(null, fix_utf8(null));
    166. 

  166.         $this->assertSame(1, fix_utf8(1));
    167. 

  167.         $this->assertSame(1.1, fix_utf8(1.1));
    168. 

  168.         $this->assertSame(true, fix_utf8(true));
    169. 

  169.         $this->assertSame('', fix_utf8(''));
    170. 

  170.         $this->assertSame('abc', fix_utf8('abc'));
    171. 

  171.         $array = array('do', 're', 'mi');
    172. 

  172.         $this->assertSame($array, fix_utf8($array));
    173. 

  173.         $object = new stdClass();
    174. 

  174.         $object->a = 'aa';
    175. 

  175.         $object->b = 'bb';
    176. 

  176.         $this->assertEquals($object, fix_utf8($object));
    177. 

  177. 

  178.         // valid utf8 string
    179. 

  179.         $this->assertSame("žlutý koníček přeskočil potůček \n\t\r", fix_utf8("žlutý koníček přeskočil potůček \n\t\r\0"));
    180. 

  180. 

  181.         // Invalid utf8 string.
    182. 

  182.         $this->assertSame('aš', fix_utf8('a'.chr(130).'š'), 'This fails with buggy iconv() when mbstring extenstion is not available as fallback.');
    183. 

  183.     }
    184. 

  184. 

  185.     public function test_optional_param() {
    186. 

  186.         global $CFG;
    187. 

  187. 

  188.         $_POST['username'] = 'post_user';
    189. 

  189.         $_GET['username'] = 'get_user';
    190. 

  190.         $this->assertSame($_POST['username'], optional_param('username', 'default_user', PARAM_RAW));
    191. 

  191. 

  192.         unset($_POST['username']);
    193. 

  193.         $this->assertSame($_GET['username'], optional_param('username', 'default_user', PARAM_RAW));
    194. 

  194. 

  195.         unset($_GET['username']);
    196. 

  196.         $this->assertSame('default_user', optional_param('username', 'default_user', PARAM_RAW));
    197. 

  197. 

  198.         // Make sure exception is triggered when some params are missing, hide error notices here - new in 2.2.
    199. 

  199.         $_POST['username'] = 'post_user';
    200. 

  200.         try {
    201. 

  201.             optional_param('username', 'default_user', null);
    202. 

  202.             $this->fail('coding_exception expected');
    203. 

  203.         } catch (moodle_exception $ex) {
    204. 

  204.             $this->assertInstanceOf('coding_exception', $ex);
    205. 

  205.         }
    206. 

  206.         try {
    207. 

  207.             @optional_param('username', 'default_user');
    208. 

  208.             $this->fail('coding_exception expected');
    209. 

  209.         } catch (moodle_exception $ex) {
    210. 

  210.             $this->assertInstanceOf('coding_exception', $ex);
    211. 

  211.         } catch (Error $error) {
    212. 

  212.             // PHP 7.1 throws Error even earlier.
    213. 

  213.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    214. 

  214.         }
    215. 

  215.         try {
    216. 

  216.             @optional_param('username');
    217. 

  217.             $this->fail('coding_exception expected');
    218. 

  218.         } catch (moodle_exception $ex) {
    219. 

  219.             $this->assertInstanceOf('coding_exception', $ex);
    220. 

  220.         } catch (Error $error) {
    221. 

  221.             // PHP 7.1 throws Error even earlier.
    222. 

  222.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    223. 

  223.         }
    224. 

  224.         try {
    225. 

  225.             optional_param('', 'default_user', PARAM_RAW);
    226. 

  226.             $this->fail('coding_exception expected');
    227. 

  227.         } catch (moodle_exception $ex) {
    228. 

  228.             $this->assertInstanceOf('coding_exception', $ex);
    229. 

  229.         }
    230. 

  230. 

  231.         // Make sure warning is displayed if array submitted - TODO: throw exception in Moodle 2.3.
    232. 

  232.         $_POST['username'] = array('a'=>'a');
    233. 

  233.         $this->assertSame($_POST['username'], optional_param('username', 'default_user', PARAM_RAW));
    234. 

  234.         $this->assertDebuggingCalled();
    235. 

  235.     }
    236. 

  236. 

  237.     public function test_optional_param_array() {
    238. 

  238.         global $CFG;
    239. 

  239. 

  240.         $_POST['username'] = array('a'=>'post_user');
    241. 

  241.         $_GET['username'] = array('a'=>'get_user');
    242. 

  242.         $this->assertSame($_POST['username'], optional_param_array('username', array('a'=>'default_user'), PARAM_RAW));
    243. 

  243. 

  244.         unset($_POST['username']);
    245. 

  245.         $this->assertSame($_GET['username'], optional_param_array('username', array('a'=>'default_user'), PARAM_RAW));
    246. 

  246. 

  247.         unset($_GET['username']);
    248. 

  248.         $this->assertSame(array('a'=>'default_user'), optional_param_array('username', array('a'=>'default_user'), PARAM_RAW));
    249. 

  249. 

  250.         // Make sure exception is triggered when some params are missing, hide error notices here - new in 2.2.
    251. 

  251.         $_POST['username'] = array('a'=>'post_user');
    252. 

  252.         try {
    253. 

  253.             optional_param_array('username', array('a'=>'default_user'), null);
    254. 

  254.             $this->fail('coding_exception expected');
    255. 

  255.         } catch (moodle_exception $ex) {
    256. 

  256.             $this->assertInstanceOf('coding_exception', $ex);
    257. 

  257.         }
    258. 

  258.         try {
    259. 

  259.             @optional_param_array('username', array('a'=>'default_user'));
    260. 

  260.             $this->fail('coding_exception expected');
    261. 

  261.         } catch (moodle_exception $ex) {
    262. 

  262.             $this->assertInstanceOf('coding_exception', $ex);
    263. 

  263.         } catch (Error $error) {
    264. 

  264.             // PHP 7.1 throws Error even earlier.
    265. 

  265.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    266. 

  266.         }
    267. 

  267.         try {
    268. 

  268.             @optional_param_array('username');
    269. 

  269.             $this->fail('coding_exception expected');
    270. 

  270.         } catch (moodle_exception $ex) {
    271. 

  271.             $this->assertInstanceOf('coding_exception', $ex);
    272. 

  272.         } catch (Error $error) {
    273. 

  273.             // PHP 7.1 throws Error even earlier.
    274. 

  274.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    275. 

  275.         }
    276. 

  276.         try {
    277. 

  277.             optional_param_array('', array('a'=>'default_user'), PARAM_RAW);
    278. 

  278.             $this->fail('coding_exception expected');
    279. 

  279.         } catch (moodle_exception $ex) {
    280. 

  280.             $this->assertInstanceOf('coding_exception', $ex);
    281. 

  281.         }
    282. 

  282. 

  283.         // Do not allow nested arrays.
    284. 

  284.         try {
    285. 

  285.             $_POST['username'] = array('a'=>array('b'=>'post_user'));
    286. 

  286.             optional_param_array('username', array('a'=>'default_user'), PARAM_RAW);
    287. 

  287.             $this->fail('coding_exception expected');
    288. 

  288.         } catch (coding_exception $ex) {
    289. 

  289.             $this->assertTrue(true);
    290. 

  290.         }
    291. 

  291. 

  292.         // Do not allow non-arrays.
    293. 

  293.         $_POST['username'] = 'post_user';
    294. 

  294.         $this->assertSame(array('a'=>'default_user'), optional_param_array('username', array('a'=>'default_user'), PARAM_RAW));
    295. 

  295.         $this->assertDebuggingCalled();
    296. 

  296. 

  297.         // Make sure array keys are sanitised.
    298. 

  298.         $_POST['username'] = array('abc123_;-/*-+ '=>'arrggh', 'a1_-'=>'post_user');
    299. 

  299.         $this->assertSame(array('a1_-'=>'post_user'), optional_param_array('username', array(), PARAM_RAW));
    300. 

  300.         $this->assertDebuggingCalled();
    301. 

  301.     }
    302. 

  302. 

  303.     public function test_required_param() {
    304. 

  304.         $_POST['username'] = 'post_user';
    305. 

  305.         $_GET['username'] = 'get_user';
    306. 

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

  307. 

  308.         unset($_POST['username']);
    309. 

  309.         $this->assertSame('get_user', required_param('username', PARAM_RAW));
    310. 

  310. 

  311.         unset($_GET['username']);
    312. 

  312.         try {
    313. 

  313.             $this->assertSame('default_user', required_param('username', PARAM_RAW));
    314. 

  314.             $this->fail('moodle_exception expected');
    315. 

  315.         } catch (moodle_exception $ex) {
    316. 

  316.             $this->assertInstanceOf('moodle_exception', $ex);
    317. 

  317.         }
    318. 

  318. 

  319.         // Make sure exception is triggered when some params are missing, hide error notices here - new in 2.2.
    320. 

  320.         $_POST['username'] = 'post_user';
    321. 

  321.         try {
    322. 

  322.             @required_param('username');
    323. 

  323.             $this->fail('coding_exception expected');
    324. 

  324.         } catch (moodle_exception $ex) {
    325. 

  325.             $this->assertInstanceOf('coding_exception', $ex);
    326. 

  326.         } catch (Error $error) {
    327. 

  327.             // PHP 7.1 throws Error even earlier.
    328. 

  328.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    329. 

  329.         }
    330. 

  330.         try {
    331. 

  331.             required_param('username', '');
    332. 

  332.             $this->fail('coding_exception expected');
    333. 

  333.         } catch (moodle_exception $ex) {
    334. 

  334.             $this->assertInstanceOf('coding_exception', $ex);
    335. 

  335.         }
    336. 

  336.         try {
    337. 

  337.             required_param('', PARAM_RAW);
    338. 

  338.             $this->fail('coding_exception expected');
    339. 

  339.         } catch (moodle_exception $ex) {
    340. 

  340.             $this->assertInstanceOf('coding_exception', $ex);
    341. 

  341.         }
    342. 

  342. 

  343.         // Make sure warning is displayed if array submitted - TODO: throw exception in Moodle 2.3.
    344. 

  344.         $_POST['username'] = array('a'=>'a');
    345. 

  345.         $this->assertSame($_POST['username'], required_param('username', PARAM_RAW));
    346. 

  346.         $this->assertDebuggingCalled();
    347. 

  347.     }
    348. 

  348. 

  349.     public function test_required_param_array() {
    350. 

  350.         global $CFG;
    351. 

  351. 

  352.         $_POST['username'] = array('a'=>'post_user');
    353. 

  353.         $_GET['username'] = array('a'=>'get_user');
    354. 

  354.         $this->assertSame($_POST['username'], required_param_array('username', PARAM_RAW));
    355. 

  355. 

  356.         unset($_POST['username']);
    357. 

  357.         $this->assertSame($_GET['username'], required_param_array('username', PARAM_RAW));
    358. 

  358. 

  359.         // Make sure exception is triggered when some params are missing, hide error notices here - new in 2.2.
    360. 

  360.         $_POST['username'] = array('a'=>'post_user');
    361. 

  361.         try {
    362. 

  362.             required_param_array('username', null);
    363. 

  363.             $this->fail('coding_exception expected');
    364. 

  364.         } catch (moodle_exception $ex) {
    365. 

  365.             $this->assertInstanceOf('coding_exception', $ex);
    366. 

  366.         }
    367. 

  367.         try {
    368. 

  368.             @required_param_array('username');
    369. 

  369.             $this->fail('coding_exception expected');
    370. 

  370.         } catch (moodle_exception $ex) {
    371. 

  371.             $this->assertInstanceOf('coding_exception', $ex);
    372. 

  372.         } catch (Error $error) {
    373. 

  373.             // PHP 7.1 throws Error.
    374. 

  374.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    375. 

  375.         }
    376. 

  376.         try {
    377. 

  377.             required_param_array('', PARAM_RAW);
    378. 

  378.             $this->fail('coding_exception expected');
    379. 

  379.         } catch (moodle_exception $ex) {
    380. 

  380.             $this->assertInstanceOf('coding_exception', $ex);
    381. 

  381.         }
    382. 

  382. 

  383.         // Do not allow nested arrays.
    384. 

  384.         try {
    385. 

  385.             $_POST['username'] = array('a'=>array('b'=>'post_user'));
    386. 

  386.             required_param_array('username', PARAM_RAW);
    387. 

  387.             $this->fail('coding_exception expected');
    388. 

  388.         } catch (moodle_exception $ex) {
    389. 

  389.             $this->assertInstanceOf('coding_exception', $ex);
    390. 

  390.         }
    391. 

  391. 

  392.         // Do not allow non-arrays.
    393. 

  393.         try {
    394. 

  394.             $_POST['username'] = 'post_user';
    395. 

  395.             required_param_array('username', PARAM_RAW);
    396. 

  396.             $this->fail('moodle_exception expected');
    397. 

  397.         } catch (moodle_exception $ex) {
    398. 

  398.             $this->assertInstanceOf('moodle_exception', $ex);
    399. 

  399.         }
    400. 

  400. 

  401.         // Make sure array keys are sanitised.
    402. 

  402.         $_POST['username'] = array('abc123_;-/*-+ '=>'arrggh', 'a1_-'=>'post_user');
    403. 

  403.         $this->assertSame(array('a1_-'=>'post_user'), required_param_array('username', PARAM_RAW));
    404. 

  404.         $this->assertDebuggingCalled();
    405. 

  405.     }
    406. 

  406. 

  407.     public function test_clean_param() {
    408. 

  408.         // Forbid objects and arrays.
    409. 

  409.         try {
    410. 

  410.             clean_param(array('x', 'y'), PARAM_RAW);
    411. 

  411.             $this->fail('coding_exception expected');
    412. 

  412.         } catch (moodle_exception $ex) {
    413. 

  413.             $this->assertInstanceOf('coding_exception', $ex);
    414. 

  414.         }
    415. 

  415.         try {
    416. 

  416.             $param = new stdClass();
    417. 

  417.             $param->id = 1;
    418. 

  418.             clean_param($param, PARAM_RAW);
    419. 

  419.             $this->fail('coding_exception expected');
    420. 

  420.         } catch (moodle_exception $ex) {
    421. 

  421.             $this->assertInstanceOf('coding_exception', $ex);
    422. 

  422.         }
    423. 

  423. 

  424.         // Require correct type.
    425. 

  425.         try {
    426. 

  426.             clean_param('x', 'xxxxxx');
    427. 

  427.             $this->fail('moodle_exception expected');
    428. 

  428.         } catch (moodle_exception $ex) {
    429. 

  429.             $this->assertInstanceOf('moodle_exception', $ex);
    430. 

  430.         }
    431. 

  431.         try {
    432. 

  432.             @clean_param('x');
    433. 

  433.             $this->fail('moodle_exception expected');
    434. 

  434.         } catch (moodle_exception $ex) {
    435. 

  435.             $this->assertInstanceOf('moodle_exception', $ex);
    436. 

  436.         } catch (Error $error) {
    437. 

  437.             // PHP 7.1 throws Error even earlier.
    438. 

  438.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    439. 

  439.         }
    440. 

  440.     }
    441. 

  441. 

  442.     public function test_clean_param_array() {
    443. 

  443.         $this->assertSame(array(), clean_param_array(null, PARAM_RAW));
    444. 

  444.         $this->assertSame(array('a', 'b'), clean_param_array(array('a', 'b'), PARAM_RAW));
    445. 

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

  446. 

  447.         // Require correct type.
    448. 

  448.         try {
    449. 

  449.             clean_param_array(array('x'), 'xxxxxx');
    450. 

  450.             $this->fail('moodle_exception expected');
    451. 

  451.         } catch (moodle_exception $ex) {
    452. 

  452.             $this->assertInstanceOf('moodle_exception', $ex);
    453. 

  453.         }
    454. 

  454.         try {
    455. 

  455.             @clean_param_array(array('x'));
    456. 

  456.             $this->fail('moodle_exception expected');
    457. 

  457.         } catch (moodle_exception $ex) {
    458. 

  458.             $this->assertInstanceOf('moodle_exception', $ex);
    459. 

  459.         } catch (Error $error) {
    460. 

  460.             // PHP 7.1 throws Error even earlier.
    461. 

  461.             $this->assertRegExp('/Too few arguments to function/', $error->getMessage());
    462. 

  462.         }
    463. 

  463. 

  464.         try {
    465. 

  465.             clean_param_array(array('x', array('y')), PARAM_RAW);
    466. 

  466.             $this->fail('coding_exception expected');
    467. 

  467.         } catch (moodle_exception $ex) {
    468. 

  468.             $this->assertInstanceOf('coding_exception', $ex);
    469. 

  469.         }
    470. 

  470. 

  471.         // Test recursive.
    472. 

  472.     }
    473. 

  473. 

  474.     public function test_clean_param_raw() {
    475. 

  475.         $this->assertSame(
    476. 

  476.             '#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)',
    477. 

  477.             clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_RAW));
    478. 

  478.     }
    479. 

  479. 

  480.     public function test_clean_param_trim() {
    481. 

  481.         $this->assertSame('Frog toad', clean_param("   Frog toad   \r\n  ", PARAM_RAW_TRIMMED));
    482. 

  482.     }
    483. 

  483. 

  484.     public function test_clean_param_clean() {
    485. 

  485.         // PARAM_CLEAN is an ugly hack, do not use in new code (skodak),
    486. 

  486.         // instead use more specific type, or submit sothing that can be verified properly.
    487. 

  487.         $this->assertSame('xx', clean_param('xx<script>', PARAM_CLEAN));
    488. 

  488.     }
    489. 

  489. 

  490.     public function test_clean_param_alpha() {
    491. 

  491.         $this->assertSame('DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHA));
    492. 

  492.     }
    493. 

  493. 

  494.     public function test_clean_param_alphanum() {
    495. 

  495.         $this->assertSame('978942897DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHANUM));
    496. 

  496.     }
    497. 

  497. 

  498.     public function test_clean_param_alphaext() {
    499. 

  499.         $this->assertSame('DSFMOSDJ', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_ALPHAEXT));
    500. 

  500.     }
    501. 

  501. 

  502.     public function test_clean_param_sequence() {
    503. 

  503.         $this->assertSame(',9789,42897', clean_param('#()*#,9789\'".,<42897></?$(*DSFMO#$*)(SDJ)($*)', PARAM_SEQUENCE));
    504. 

  504.     }
    505. 

  505. 

  506.     public function test_clean_param_component() {
    507. 

  507.         // Please note the cleaning of component names is very strict, no guessing here.
    508. 

  508.         $this->assertSame('mod_forum', clean_param('mod_forum', PARAM_COMPONENT));
    509. 

  509.         $this->assertSame('block_online_users', clean_param('block_online_users', PARAM_COMPONENT));
    510. 

  510.         $this->assertSame('block_blond_online_users', clean_param('block_blond_online_users', PARAM_COMPONENT));
    511. 

  511.         $this->assertSame('mod_something2', clean_param('mod_something2', PARAM_COMPONENT));
    512. 

  512.         $this->assertSame('forum', clean_param('forum', PARAM_COMPONENT));
    513. 

  513.         $this->assertSame('user', clean_param('user', PARAM_COMPONENT));
    514. 

  514.         $this->assertSame('rating', clean_param('rating', PARAM_COMPONENT));
    515. 

  515.         $this->assertSame('feedback360', clean_param('feedback360', PARAM_COMPONENT));
    516. 

  516.         $this->assertSame('mod_feedback360', clean_param('mod_feedback360', PARAM_COMPONENT));
    517. 

  517.         $this->assertSame('', clean_param('mod_2something', PARAM_COMPONENT));
    518. 

  518.         $this->assertSame('', clean_param('2mod_something', PARAM_COMPONENT));
    519. 

  519.         $this->assertSame('', clean_param('mod_something_xx', PARAM_COMPONENT));
    520. 

  520.         $this->assertSame('', clean_param('auth_something__xx', PARAM_COMPONENT));
    521. 

  521.         $this->assertSame('', clean_param('mod_Something', PARAM_COMPONENT));
    522. 

  522.         $this->assertSame('', clean_param('mod_somethíng', PARAM_COMPONENT));
    523. 

  523.         $this->assertSame('', clean_param('mod__something', PARAM_COMPONENT));
    524. 

  524.         $this->assertSame('', clean_param('auth_xx-yy', PARAM_COMPONENT));
    525. 

  525.         $this->assertSame('', clean_param('_auth_xx', PARAM_COMPONENT));
    526. 

  526.         $this->assertSame('a2uth_xx', clean_param('a2uth_xx', PARAM_COMPONENT));
    527. 

  527.         $this->assertSame('', clean_param('auth_xx_', PARAM_COMPONENT));
    528. 

  528.         $this->assertSame('', clean_param('auth_xx.old', PARAM_COMPONENT));
    529. 

  529.         $this->assertSame('', clean_param('_user', PARAM_COMPONENT));
    530. 

  530.         $this->assertSame('', clean_param('2rating', PARAM_COMPONENT));
    531. 

  531.         $this->assertSame('', clean_param('user_', PARAM_COMPONENT));
    532. 

  532.     }
    533. 

  533. 

  534.     public function test_clean_param_localisedfloat() {
    535. 

  535. 

  536.         $this->assertSame(0.5, clean_param('0.5', PARAM_LOCALISEDFLOAT));
    537. 

  537.         $this->assertSame(false, clean_param('0X5', PARAM_LOCALISEDFLOAT));
    538. 

  538.         $this->assertSame(0.5, clean_param('.5', PARAM_LOCALISEDFLOAT));
    539. 

  539.         $this->assertSame(false, clean_param('X5', PARAM_LOCALISEDFLOAT));
    540. 

  540.         $this->assertSame(10.5, clean_param('10.5', PARAM_LOCALISEDFLOAT));
    541. 

  541.         $this->assertSame(false, clean_param('10X5', PARAM_LOCALISEDFLOAT));
    542. 

  542.         $this->assertSame(1000.5, clean_param('1 000.5', PARAM_LOCALISEDFLOAT));
    543. 

  543.         $this->assertSame(false, clean_param('1 000X5', PARAM_LOCALISEDFLOAT));
    544. 

  544.         $this->assertSame(false, clean_param('1.000.5', PARAM_LOCALISEDFLOAT));
    545. 

  545.         $this->assertSame(false, clean_param('1X000X5', PARAM_LOCALISEDFLOAT));
    546. 

  546.         $this->assertSame(false, clean_param('nan', PARAM_LOCALISEDFLOAT));
    547. 

  547.         $this->assertSame(false, clean_param('10.6blah', PARAM_LOCALISEDFLOAT));
    548. 

  548. 

  549.         // Tests with a localised decimal separator.
    550. 

  550.         $this->define_local_decimal_separator();
    551. 

  551. 

  552.         $this->assertSame(0.5, clean_param('0.5', PARAM_LOCALISEDFLOAT));
    553. 

  553.         $this->assertSame(0.5, clean_param('0X5', PARAM_LOCALISEDFLOAT));
    554. 

  554.         $this->assertSame(0.5, clean_param('.5', PARAM_LOCALISEDFLOAT));
    555. 

  555.         $this->assertSame(0.5, clean_param('X5', PARAM_LOCALISEDFLOAT));
    556. 

  556.         $this->assertSame(10.5, clean_param('10.5', PARAM_LOCALISEDFLOAT));
    557. 

  557.         $this->assertSame(10.5, clean_param('10X5', PARAM_LOCALISEDFLOAT));
    558. 

  558.         $this->assertSame(1000.5, clean_param('1 000.5', PARAM_LOCALISEDFLOAT));
    559. 

  559.         $this->assertSame(1000.5, clean_param('1 000X5', PARAM_LOCALISEDFLOAT));
    560. 

  560.         $this->assertSame(false, clean_param('1.000.5', PARAM_LOCALISEDFLOAT));
    561. 

  561.         $this->assertSame(false, clean_param('1X000X5', PARAM_LOCALISEDFLOAT));
    562. 

  562.         $this->assertSame(false, clean_param('nan', PARAM_LOCALISEDFLOAT));
    563. 

  563.         $this->assertSame(false, clean_param('10X6blah', PARAM_LOCALISEDFLOAT));
    564. 

  564.     }
    565. 

  565. 

  566.     public function test_is_valid_plugin_name() {
    567. 

  567.         $this->assertTrue(is_valid_plugin_name('forum'));
    568. 

  568.         $this->assertTrue(is_valid_plugin_name('forum2'));
    569. 

  569.         $this->assertTrue(is_valid_plugin_name('feedback360'));
    570. 

  570.         $this->assertTrue(is_valid_plugin_name('online_users'));
    571. 

  571.         $this->assertTrue(is_valid_plugin_name('blond_online_users'));
    572. 

  572.         $this->assertFalse(is_valid_plugin_name('online__users'));
    573. 

  573.         $this->assertFalse(is_valid_plugin_name('forum '));
    574. 

  574.         $this->assertFalse(is_valid_plugin_name('forum.old'));
    575. 

  575.         $this->assertFalse(is_valid_plugin_name('xx-yy'));
    576. 

  576.         $this->assertFalse(is_valid_plugin_name('2xx'));
    577. 

  577.         $this->assertFalse(is_valid_plugin_name('Xx'));
    578. 

  578.         $this->assertFalse(is_valid_plugin_name('_xx'));
    579. 

  579.         $this->assertFalse(is_valid_plugin_name('xx_'));
    580. 

  580.     }
    581. 

  581. 

  582.     public function test_clean_param_plugin() {
    583. 

  583.         // Please note the cleaning of plugin names is very strict, no guessing here.
    584. 

  584.         $this->assertSame('forum', clean_param('forum', PARAM_PLUGIN));
    585. 

  585.         $this->assertSame('forum2', clean_param('forum2', PARAM_PLUGIN));
    586. 

  586.         $this->assertSame('feedback360', clean_param('feedback360', PARAM_PLUGIN));
    587. 

  587.         $this->assertSame('online_users', clean_param('online_users', PARAM_PLUGIN));
    588. 

  588.         $this->assertSame('blond_online_users', clean_param('blond_online_users', PARAM_PLUGIN));
    589. 

  589.         $this->assertSame('', clean_param('online__users', PARAM_PLUGIN));
    590. 

  590.         $this->assertSame('', clean_param('forum ', PARAM_PLUGIN));
    591. 

  591.         $this->assertSame('', clean_param('forum.old', PARAM_PLUGIN));
    592. 

  592.         $this->assertSame('', clean_param('xx-yy', PARAM_PLUGIN));
    593. 

  593.         $this->assertSame('', clean_param('2xx', PARAM_PLUGIN));
    594. 

  594.         $this->assertSame('', clean_param('Xx', PARAM_PLUGIN));
    595. 

  595.         $this->assertSame('', clean_param('_xx', PARAM_PLUGIN));
    596. 

  596.         $this->assertSame('', clean_param('xx_', PARAM_PLUGIN));
    597. 

  597.     }
    598. 

  598. 

  599.     public function test_clean_param_area() {
    600. 

  600.         // Please note the cleaning of area names is very strict, no guessing here.
    601. 

  601.         $this->assertSame('something', clean_param('something', PARAM_AREA));
    602. 

  602.         $this->assertSame('something2', clean_param('something2', PARAM_AREA));
    603. 

  603.         $this->assertSame('some_thing', clean_param('some_thing', PARAM_AREA));
    604. 

  604.         $this->assertSame('some_thing_xx', clean_param('some_thing_xx', PARAM_AREA));
    605. 

  605.         $this->assertSame('feedback360', clean_param('feedback360', PARAM_AREA));
    606. 

  606.         $this->assertSame('', clean_param('_something', PARAM_AREA));
    607. 

  607.         $this->assertSame('', clean_param('something_', PARAM_AREA));
    608. 

  608.         $this->assertSame('', clean_param('2something', PARAM_AREA));
    609. 

  609.         $this->assertSame('', clean_param('Something', PARAM_AREA));
    610. 

  610.         $this->assertSame('', clean_param('some-thing', PARAM_AREA));
    611. 

  611.         $this->assertSame('', clean_param('somethííng', PARAM_AREA));
    612. 

  612.         $this->assertSame('', clean_param('something.x', PARAM_AREA));
    613. 

  613.     }
    614. 

  614. 

  615.     public function test_clean_param_text() {
    616. 

  616.         $this->assertSame(PARAM_TEXT, PARAM_MULTILANG);
    617. 

  617.         // Standard.
    618. 

  618.         $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));
    619. 

  619.         $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));
    620. 

  620.         $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));
    621. 

  621.         // Malformed.
    622. 

  622.         $this->assertSame('<span lang="en" class="multilang">aa</span>', clean_param('<span lang="en" class="multilang">aa</span>', PARAM_TEXT));
    623. 

  623.         $this->assertSame('aa', clean_param('<span lang="en" class="nothing" class="multilang">aa</span>', PARAM_TEXT));
    624. 

  624.         $this->assertSame('aa', clean_param('<lang lang="en" class="multilang">aa</lang>', PARAM_TEXT));
    625. 

  625.         $this->assertSame('aa', clean_param('<lang lang="en!!">aa</lang>', PARAM_TEXT));
    626. 

  626.         $this->assertSame('aa', clean_param('<span lang="en==" class="multilang">aa</span>', PARAM_TEXT));
    627. 

  627.         $this->assertSame('abc', clean_param('a<em>b</em>c', PARAM_TEXT));
    628. 

  628.         $this->assertSame('a>c>', clean_param('a><xx >c>', PARAM_TEXT)); // Standard strip_tags() behaviour.
    629. 

  629.         $this->assertSame('a', clean_param('a<b', PARAM_TEXT));
    630. 

  630.         $this->assertSame('a>b', clean_param('a>b', PARAM_TEXT));
    631. 

  631.         $this->assertSame('<lang lang="en">a>a</lang>', clean_param('<lang lang="en">a>a</lang>', PARAM_TEXT)); // Standard strip_tags() behaviour.
    632. 

  632.         $this->assertSame('a', clean_param('<lang lang="en">a<a</lang>', PARAM_TEXT));
    633. 

  633.         $this->assertSame('<lang lang="en">aa</lang>', clean_param('<lang lang="en">a<br>a</lang>', PARAM_TEXT));
    634. 

  634.     }
    635. 

  635. 

  636.     public function test_clean_param_url() {
    637. 

  637.         // Test PARAM_URL and PARAM_LOCALURL a bit.
    638. 

  638.         // Valid URLs.
    639. 

  639.         $this->assertSame('http://google.com/', clean_param('http://google.com/', PARAM_URL));
    640. 

  640.         $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));
    641. 

  641.         $this->assertSame('http://localhost/', clean_param('http://localhost/', PARAM_URL));
    642. 

  642.         $this->assertSame('http://0.255.1.1/numericip.php', clean_param('http://0.255.1.1/numericip.php', PARAM_URL));
    643. 

  643.         $this->assertSame('https://google.com/', clean_param('https://google.com/', PARAM_URL));
    644. 

  644.         $this->assertSame('https://some.very.long.and.silly.domain/with/a/path/', clean_param('https://some.very.long.and.silly.domain/with/a/path/', PARAM_URL));
    645. 

  645.         $this->assertSame('https://localhost/', clean_param('https://localhost/', PARAM_URL));
    646. 

  646.         $this->assertSame('https://0.255.1.1/numericip.php', clean_param('https://0.255.1.1/numericip.php', PARAM_URL));
    647. 

  647.         $this->assertSame('ftp://ftp.debian.org/debian/', clean_param('ftp://ftp.debian.org/debian/', PARAM_URL));
    648. 

  648.         $this->assertSame('/just/a/path', clean_param('/just/a/path', PARAM_URL));
    649. 

  649.         // Invalid URLs.
    650. 

  650.         $this->assertSame('', clean_param('funny:thing', PARAM_URL));
    651. 

  651.         $this->assertSame('', clean_param('http://example.ee/sdsf"f', PARAM_URL));
    652. 

  652.         $this->assertSame('', clean_param('javascript://comment%0Aalert(1)', PARAM_URL));
    653. 

  653.         $this->assertSame('', clean_param('rtmp://example.com/livestream', PARAM_URL));
    654. 

  654.         $this->assertSame('', clean_param('rtmp://example.com/live&foo', PARAM_URL));
    655. 

  655.         $this->assertSame('', clean_param('rtmp://example.com/fms&mp4:path/to/file.mp4', PARAM_URL));
    656. 

  656.         $this->assertSame('', clean_param('mailto:support@moodle.org', PARAM_URL));
    657. 

  657.         $this->assertSame('', clean_param('mailto:support@moodle.org?subject=Hello%20Moodle', PARAM_URL));
    658. 

  658.         $this->assertSame('', clean_param('mailto:support@moodle.org?subject=Hello%20Moodle&cc=feedback@moodle.org', PARAM_URL));
    659. 

  659.     }
    660. 

  660. 

  661.     public function test_clean_param_localurl() {
    662. 

  662.         global $CFG;
    663. 

  663. 

  664.         $this->resetAfterTest();
    665. 

  665. 

  666.         // External, invalid.
    667. 

  667.         $this->assertSame('', clean_param('funny:thing', PARAM_LOCALURL));
    668. 

  668.         $this->assertSame('', clean_param('http://google.com/', PARAM_LOCALURL));
    669. 

  669.         $this->assertSame('', clean_param('https://google.com/?test=true', PARAM_LOCALURL));
    670. 

  670.         $this->assertSame('', clean_param('http://some.very.long.and.silly.domain/with/a/path/', PARAM_LOCALURL));
    671. 

  671. 

  672.         // Local absolute.
    673. 

  673.         $this->assertSame(clean_param($CFG->wwwroot, PARAM_LOCALURL), $CFG->wwwroot);
    674. 

  674.         $this->assertSame($CFG->wwwroot . '/with/something?else=true',
    675. 

  675.             clean_param($CFG->wwwroot . '/with/something?else=true', PARAM_LOCALURL));
    676. 

  676. 

  677.         // Local relative.
    678. 

  678.         $this->assertSame('/just/a/path', clean_param('/just/a/path', PARAM_LOCALURL));
    679. 

  679.         $this->assertSame('course/view.php?id=3', clean_param('course/view.php?id=3', PARAM_LOCALURL));
    680. 

  680. 

  681.         // Local absolute HTTPS in a non HTTPS site.
    682. 

  682.         $CFG->wwwroot = str_replace('https:', 'http:', $CFG->wwwroot); // Need to simulate non-https site.
    683. 

  683.         $httpsroot = str_replace('http:', 'https:', $CFG->wwwroot);
    684. 

  684.         $this->assertSame('', clean_param($httpsroot, PARAM_LOCALURL));
    685. 

  685.         $this->assertSame('', clean_param($httpsroot . '/with/something?else=true', PARAM_LOCALURL));
    686. 

  686. 

  687.         // Local absolute HTTPS in a HTTPS site.
    688. 

  688.         $CFG->wwwroot = str_replace('http:', 'https:', $CFG->wwwroot);
    689. 

  689.         $httpsroot = $CFG->wwwroot;
    690. 

  690.         $this->assertSame($httpsroot, clean_param($httpsroot, PARAM_LOCALURL));
    691. 

  691.         $this->assertSame($httpsroot . '/with/something?else=true',
    692. 

  692.             clean_param($httpsroot . '/with/something?else=true', PARAM_LOCALURL));
    693. 

  693. 

  694.         // Test open redirects are not possible.
    695. 

  695.         $CFG->wwwroot = 'http://www.example.com';
    696. 

  696.         $this->assertSame('', clean_param('http://www.example.com.evil.net/hack.php', PARAM_LOCALURL));
    697. 

  697.         $CFG->wwwroot = 'https://www.example.com';
    698. 

  698.         $this->assertSame('', clean_param('https://www.example.com.evil.net/hack.php', PARAM_LOCALURL));
    699. 

  699.     }
    700. 

  700. 

  701.     public function test_clean_param_file() {
    702. 

  702.         $this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_FILE));
    703. 

  703.         $this->assertSame('badfile.txt', clean_param('b\'a<d`\\/fi:l>e.t"x|t', PARAM_FILE));
    704. 

  704.         $this->assertSame('..parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_FILE));
    705. 

  705.         $this->assertSame('....grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_FILE));
    706. 

  706.         $this->assertSame('..winparentdirfile.txt', clean_param('..\winparentdirfile.txt', PARAM_FILE));
    707. 

  707.         $this->assertSame('....wingrandparentdir.txt', clean_param('..\..\wingrandparentdir.txt', PARAM_FILE));
    708. 

  708.         $this->assertSame('myfile.a.b.txt', clean_param('myfile.a.b.txt', PARAM_FILE));
    709. 

  709.         $this->assertSame('myfile..a..b.txt', clean_param('myfile..a..b.txt', PARAM_FILE));
    710. 

  710.         $this->assertSame('myfile.a..b...txt', clean_param('myfile.a..b...txt', PARAM_FILE));
    711. 

  711.         $this->assertSame('myfile.a.txt', clean_param('myfile.a.txt', PARAM_FILE));
    712. 

  712.         $this->assertSame('myfile...txt', clean_param('myfile...txt', PARAM_FILE));
    713. 

  713.         $this->assertSame('...jpg', clean_param('...jpg', PARAM_FILE));
    714. 

  714.         $this->assertSame('.a.b.', clean_param('.a.b.', PARAM_FILE));
    715. 

  715.         $this->assertSame('', clean_param('.', PARAM_FILE));
    716. 

  716.         $this->assertSame('', clean_param('..', PARAM_FILE));
    717. 

  717.         $this->assertSame('...', clean_param('...', PARAM_FILE));
    718. 

  718.         $this->assertSame('. . . .', clean_param('. . . .', PARAM_FILE));
    719. 

  719.         $this->assertSame('dontrtrim.me. .. .. . ', clean_param('dontrtrim.me. .. .. . ', PARAM_FILE));
    720. 

  720.         $this->assertSame(' . .dontltrim.me', clean_param(' . .dontltrim.me', PARAM_FILE));
    721. 

  721.         $this->assertSame('here is a tab.txt', clean_param("here is a tab\t.txt", PARAM_FILE));
    722. 

  722.         $this->assertSame('here is a linebreak.txt', clean_param("here is a line\r\nbreak.txt", PARAM_FILE));
    723. 

  723. 

  724.         // The following behaviours have been maintained although they seem a little odd.
    725. 

  725.         $this->assertSame('funnything', clean_param('funny:thing', PARAM_FILE));
    726. 

  726.         $this->assertSame('.currentdirfile.txt', clean_param('./currentdirfile.txt', PARAM_FILE));
    727. 

  727.         $this->assertSame('ctempwindowsfile.txt', clean_param('c:\temp\windowsfile.txt', PARAM_FILE));
    728. 

  728.         $this->assertSame('homeuserlinuxfile.txt', clean_param('/home/user/linuxfile.txt', PARAM_FILE));
    729. 

  729.         $this->assertSame('~myfile.txt', clean_param('~/myfile.txt', PARAM_FILE));
    730. 

  730.     }
    731. 

  731. 

  732.     public function test_clean_param_path() {
    733. 

  733.         $this->assertSame('correctfile.txt', clean_param('correctfile.txt', PARAM_PATH));
    734. 

  734.         $this->assertSame('bad/file.txt', clean_param('b\'a<d`\\/fi:l>e.t"x|t', PARAM_PATH));
    735. 

  735.         $this->assertSame('/parentdirfile.txt', clean_param('../parentdirfile.txt', PARAM_PATH));
    736. 

  736.         $this->assertSame('/grandparentdirfile.txt', clean_param('../../grandparentdirfile.txt', PARAM_PATH));
    737. 

  737.         $this->assertSame('/winparentdirfile.txt', clean_param('..\winparentdirfile.txt', PARAM_PATH));
    738. 

  738.         $this->assertSame('/wingrandparentdir.txt', clean_param('..\..\wingrandparentdir.txt', PARAM_PATH));
    739. 

  739.         $this->assertSame('funnything', clean_param('funny:thing', PARAM_PATH));
    740. 

  740.         $this->assertSame('./here', clean_param('./././here', PARAM_PATH));
    741. 

  741.         $this->assertSame('./currentdirfile.txt', clean_param('./currentdirfile.txt', PARAM_PATH));
    742. 

  742.         $this->assertSame('c/temp/windowsfile.txt', clean_param('c:\temp\windowsfile.txt', PARAM_PATH));
    743. 

  743.         $this->assertSame('/home/user/linuxfile.txt', clean_param('/home/user/linuxfile.txt', PARAM_PATH));
    744. 

  744.         $this->assertSame('/home../user ./.linuxfile.txt', clean_param('/home../user ./.linuxfile.txt', PARAM_PATH));
    745. 

  745.         $this->assertSame('~/myfile.txt', clean_param('~/myfile.txt', PARAM_PATH));
    746. 

  746.         $this->assertSame('~/myfile.txt', clean_param('~/../myfile.txt', PARAM_PATH));
    747. 

  747.         $this->assertSame('/..b../.../myfile.txt', clean_param('/..b../.../myfile.txt', PARAM_PATH));
    748. 

  748.         $this->assertSame('..b../.../myfile.txt', clean_param('..b../.../myfile.txt', PARAM_PATH));
    749. 

  749.         $this->assertSame('/super/slashes/', clean_param('/super//slashes///', PARAM_PATH));
    750. 

  750.     }
    751. 

  751. 

  752.     public function test_clean_param_username() {
    753. 

  753.         global $CFG;
    754. 

  754.         $currentstatus =  $CFG->extendedusernamechars;
    755. 

  755. 

  756.         // Run tests with extended character == false;.
    757. 

  757.         $CFG->extendedusernamechars = false;
    758. 

  758.         $this->assertSame('johndoe123', clean_param('johndoe123', PARAM_USERNAME) );
    759. 

  759.         $this->assertSame('john.doe', clean_param('john.doe', PARAM_USERNAME));
    760. 

  760.         $this->assertSame('john-doe', clean_param('john-doe', PARAM_USERNAME));
    761. 

  761.         $this->assertSame('john-doe', clean_param('john- doe', PARAM_USERNAME));
    762. 

  762.         $this->assertSame('john_doe', clean_param('john_doe', PARAM_USERNAME));
    763. 

  763.         $this->assertSame('john@doe', clean_param('john@doe', PARAM_USERNAME));
    764. 

  764.         $this->assertSame('johndoe', clean_param('john~doe', PARAM_USERNAME));
    765. 

  765.         $this->assertSame('johndoe', clean_param('john´doe', PARAM_USERNAME));
    766. 

  766.         $this->assertSame(clean_param('john# $%&()+_^', PARAM_USERNAME), 'john_');
    767. 

  767.         $this->assertSame(clean_param(' john# $%&()+_^ ', PARAM_USERNAME), 'john_');
    768. 

  768.         $this->assertSame(clean_param('john#$%&() ', PARAM_USERNAME), 'john');
    769. 

  769.         $this->assertSame('johnd', clean_param('JOHNdóé ', PARAM_USERNAME));
    770. 

  770.         $this->assertSame(clean_param('john.,:;-_/|\ñÑ[]A_X-,D {} ~!@#$%^&*()_+ ?><[] ščřžžý ?ýáž?žý??šdoe ', PARAM_USERNAME), 'john.-_a_x-d@_doe');
    771. 

  771. 

  772.         // Test success condition, if extendedusernamechars == ENABLE;.
    773. 

  773.         $CFG->extendedusernamechars = true;
    774. 

  774.         $this->assertSame('john_doe', clean_param('john_doe', PARAM_USERNAME));
    775. 

  775.         $this->assertSame('john@doe', clean_param('john@doe', PARAM_USERNAME));
    776. 

  776.         $this->assertSame(clean_param('john# $%&()+_^', PARAM_USERNAME), 'john# $%&()+_^');
    777. 

  777.         $this->assertSame(clean_param(' john# $%&()+_^ ', PARAM_USERNAME), 'john# $%&()+_^');
    778. 

  778.         $this->assertSame('john~doe', clean_param('john~doe', PARAM_USERNAME));
    779. 

  779.         $this->assertSame('john´doe', clean_param('joHN´doe', PARAM_USERNAME));
    780. 

  780.         $this->assertSame('johndoe', clean_param('johnDOE', PARAM_USERNAME));
    781. 

  781.         $this->assertSame('johndóé', clean_param('johndóé ', PARAM_USERNAME));
    782. 

  782. 

  783.         $CFG->extendedusernamechars = $currentstatus;
    784. 

  784.     }
    785. 

  785. 

  786.     public function test_clean_param_stringid() {
    787. 

  787.         // Test string identifiers validation.
    788. 

  788.         // Valid strings.
    789. 

  789.         $this->assertSame('validstring', clean_param('validstring', PARAM_STRINGID));
    790. 

  790.         $this->assertSame('mod/foobar:valid_capability', clean_param('mod/foobar:valid_capability', PARAM_STRINGID));
    791. 

  791.         $this->assertSame('CZ', clean_param('CZ', PARAM_STRINGID));
    792. 

  792.         $this->assertSame('application/vnd.ms-powerpoint', clean_param('application/vnd.ms-powerpoint', PARAM_STRINGID));
    793. 

  793.         $this->assertSame('grade2', clean_param('grade2', PARAM_STRINGID));
    794. 

  794.         // Invalid strings.
    795. 

  795.         $this->assertSame('', clean_param('trailing ', PARAM_STRINGID));
    796. 

  796.         $this->assertSame('', clean_param('space bar', PARAM_STRINGID));
    797. 

  797.         $this->assertSame('', clean_param('0numeric', PARAM_STRINGID));
    798. 

  798.         $this->assertSame('', clean_param('*', PARAM_STRINGID));
    799. 

  799.         $this->assertSame('', clean_param(' ', PARAM_STRINGID));
    800. 

  800.     }
    801. 

  801. 

  802.     public function test_clean_param_timezone() {
    803. 

  803.         // Test timezone validation.
    804. 

  804.         $testvalues = array (
    805. 

  805.             'America/Jamaica'                => 'America/Jamaica',
    806. 

  806.             'America/Argentina/Cordoba'      => 'America/Argentina/Cordoba',
    807. 

  807.             'America/Port-au-Prince'         => 'America/Port-au-Prince',
    808. 

  808.             'America/Argentina/Buenos_Aires' => 'America/Argentina/Buenos_Aires',
    809. 

  809.             'PST8PDT'                        => 'PST8PDT',
    810. 

  810.             'Wrong.Value'                    => '',
    811. 

  811.             'Wrong/.Value'                   => '',
    812. 

  812.             'Wrong(Value)'                   => '',
    813. 

  813.             '0'                              => '0',
    814. 

  814.             '0.0'                            => '0.0',
    815. 

  815.             '0.5'                            => '0.5',
    816. 

  816.             '9.0'                            => '9.0',
    817. 

  817.             '-9.0'                           => '-9.0',
    818. 

  818.             '+9.0'                           => '+9.0',
    819. 

  819.             '9.5'                            => '9.5',
    820. 

  820.             '-9.5'                           => '-9.5',
    821. 

  821.             '+9.5'                           => '+9.5',
    822. 

  822.             '12.0'                           => '12.0',
    823. 

  823.             '-12.0'                          => '-12.0',
    824. 

  824.             '+12.0'                          => '+12.0',
    825. 

  825.             '12.5'                           => '12.5',
    826. 

  826.             '-12.5'                          => '-12.5',
    827. 

  827.             '+12.5'                          => '+12.5',
    828. 

  828.             '13.0'                           => '13.0',
    829. 

  829.             '-13.0'                          => '-13.0',
    830. 

  830.             '+13.0'                          => '+13.0',
    831. 

  831.             '13.5'                           => '',
    832. 

  832.             '+13.5'                          => '',
    833. 

  833.             '-13.5'                          => '',
    834. 

  834.             '0.2'                            => '');
    835. 

  835. 

  836.         foreach ($testvalues as $testvalue => $expectedvalue) {
    837. 

  837.             $actualvalue = clean_param($testvalue, PARAM_TIMEZONE);
    838. 

  838.             $this->assertEquals($expectedvalue, $actualvalue);
    839. 

  839.         }
    840. 

  840.     }
    841. 

  841. 

  842.     public function test_validate_param() {
    843. 

  843.         try {
    844. 

  844.             $param = validate_param('11a', PARAM_INT);
    845. 

  845.             $this->fail('invalid_parameter_exception expected');
    846. 

  846.         } catch (moodle_exception $ex) {
    847. 

  847.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    848. 

  848.         }
    849. 

  849. 

  850.         $param = validate_param('11', PARAM_INT);
    851. 

  851.         $this->assertSame(11, $param);
    852. 

  852. 

  853.         try {
    854. 

  854.             $param = validate_param(null, PARAM_INT, false);
    855. 

  855.             $this->fail('invalid_parameter_exception expected');
    856. 

  856.         } catch (moodle_exception $ex) {
    857. 

  857.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    858. 

  858.         }
    859. 

  859. 

  860.         $param = validate_param(null, PARAM_INT, true);
    861. 

  861.         $this->assertSame(null, $param);
    862. 

  862. 

  863.         try {
    864. 

  864.             $param = validate_param(array(), PARAM_INT);
    865. 

  865.             $this->fail('invalid_parameter_exception expected');
    866. 

  866.         } catch (moodle_exception $ex) {
    867. 

  867.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    868. 

  868.         }
    869. 

  869.         try {
    870. 

  870.             $param = validate_param(new stdClass, PARAM_INT);
    871. 

  871.             $this->fail('invalid_parameter_exception expected');
    872. 

  872.         } catch (moodle_exception $ex) {
    873. 

  873.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    874. 

  874.         }
    875. 

  875. 

  876.         $param = validate_param('1.0', PARAM_FLOAT);
    877. 

  877.         $this->assertSame(1.0, $param);
    878. 

  878. 

  879.         // Make sure valid floats do not cause exception.
    880. 

  880.         validate_param(1.0, PARAM_FLOAT);
    881. 

  881.         validate_param(10, PARAM_FLOAT);
    882. 

  882.         validate_param('0', PARAM_FLOAT);
    883. 

  883.         validate_param('119813454.545464564564546564545646556564465465456465465465645645465645645645', PARAM_FLOAT);
    884. 

  884.         validate_param('011.1', PARAM_FLOAT);
    885. 

  885.         validate_param('11', PARAM_FLOAT);
    886. 

  886.         validate_param('+.1', PARAM_FLOAT);
    887. 

  887.         validate_param('-.1', PARAM_FLOAT);
    888. 

  888.         validate_param('1e10', PARAM_FLOAT);
    889. 

  889.         validate_param('.1e+10', PARAM_FLOAT);
    890. 

  890.         validate_param('1E-1', PARAM_FLOAT);
    891. 

  891. 

  892.         try {
    893. 

  893.             $param = validate_param('1,2', PARAM_FLOAT);
    894. 

  894.             $this->fail('invalid_parameter_exception expected');
    895. 

  895.         } catch (moodle_exception $ex) {
    896. 

  896.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    897. 

  897.         }
    898. 

  898.         try {
    899. 

  899.             $param = validate_param('', PARAM_FLOAT);
    900. 

  900.             $this->fail('invalid_parameter_exception expected');
    901. 

  901.         } catch (moodle_exception $ex) {
    902. 

  902.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    903. 

  903.         }
    904. 

  904.         try {
    905. 

  905.             $param = validate_param('.', PARAM_FLOAT);
    906. 

  906.             $this->fail('invalid_parameter_exception expected');
    907. 

  907.         } catch (moodle_exception $ex) {
    908. 

  908.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    909. 

  909.         }
    910. 

  910.         try {
    911. 

  911.             $param = validate_param('e10', PARAM_FLOAT);
    912. 

  912.             $this->fail('invalid_parameter_exception expected');
    913. 

  913.         } catch (moodle_exception $ex) {
    914. 

  914.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    915. 

  915.         }
    916. 

  916.         try {
    917. 

  917.             $param = validate_param('abc', PARAM_FLOAT);
    918. 

  918.             $this->fail('invalid_parameter_exception expected');
    919. 

  919.         } catch (moodle_exception $ex) {
    920. 

  920.             $this->assertInstanceOf('invalid_parameter_exception', $ex);
    921. 

  921.         }
    922. 

  922.     }
    923. 

  923. 

  924.     public function test_shorten_text_no_tags_already_short_enough() {
    925. 

  925.         // ......12345678901234567890123456.
    926. 

  926.         $text = "short text already no tags";
    927. 

  927.         $this->assertSame($text, shorten_text($text));
    928. 

  928.     }
    929. 

  929. 

  930.     public function test_shorten_text_with_tags_already_short_enough() {
    931. 

  931.         // .........123456...7890....12345678.......901234567.
    932. 

  932.         $text = "<p>short <b>text</b> already</p><p>with tags</p>";
    933. 

  933.         $this->assertSame($text, shorten_text($text));
    934. 

  934.     }
    935. 

  935. 

  936.     public function test_shorten_text_no_tags_needs_shortening() {
    937. 

  937.         // Default truncation is after 30 chars, but allowing 3 for the final '...'.
    938. 

  938.         // ......12345678901234567890123456789023456789012345678901234.
    939. 

  939.         $text = "long text without any tags blah de blah blah blah what";
    940. 

  940.         $this->assertSame('long text without any tags ...', shorten_text($text));
    941. 

  941.     }
    942. 

  942. 

  943.     public function test_shorten_text_with_tags_needs_shortening() {
    944. 

  944.         // .......................................123456789012345678901234567890...
    945. 

  945.         $text = "<div class='frog'><p><blockquote>Long text with tags that will ".
    946. 

  946.             "be chopped off but <b>should be added back again</b></blockquote></p></div>";
    947. 

  947.         $this->assertEquals("<div class='frog'><p><blockquote>Long text with " .
    948. 

  948.             "tags that ...</blockquote></p></div>", shorten_text($text));
    949. 

  949.     }
    950. 

  950. 

  951.     public function test_shorten_text_with_tags_and_html_comment() {
    952. 

  952.         $text = "<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with ".
    953. 

  953.             "tags that will<!--<![endif]--> ".
    954. 

  954.             "be chopped off but <b>should be added back again</b></blockquote></p></div>";
    955. 

  955.         $this->assertEquals("<div class='frog'><p><blockquote><!--[if !IE]><!-->Long text with " .
    956. 

  956.             "tags that ...<!--<![endif]--></blockquote></p></div>", shorten_text($text));
    957. 

  957.     }
    958. 

  958. 

  959.     public function test_shorten_text_with_entities() {
    960. 

  960.         // Remember to allow 3 chars for the final '...'.
    961. 

  961.         // ......123456789012345678901234567_____890...
    962. 

  962.         $text = "some text which shouldn't &nbsp; break there";
    963. 

  963.         $this->assertSame("some text which shouldn't &nbsp; ...", shorten_text($text, 31));
    964. 

  964.         $this->assertSame("some text which shouldn't &nbsp;...", shorten_text($text, 30));
    965. 

  965.         $this->assertSame("some text which shouldn't ...", shorten_text($text, 29));
    966. 

  966.     }
    967. 

  967. 

  968.     public function test_shorten_text_known_tricky_case() {
    969. 

  969.         // This case caused a bug up to 1.9.5
    970. 

  970.         // ..........123456789012345678901234567890123456789.....0_____1___2___...
    971. 

  971.         $text = "<h3>standard 'break-out' sub groups in TGs?</h3>&nbsp;&lt;&lt;There are several";
    972. 

  972.         $this->assertSame("<h3>standard 'break-out' sub groups in ...</h3>",
    973. 

  973.             shorten_text($text, 41));
    974. 

  974.         $this->assertSame("<h3>standard 'break-out' sub groups in TGs?...</h3>",
    975. 

  975.             shorten_text($text, 42));
    976. 

  976.         $this->assertSame("<h3>standard 'break-out' sub groups in TGs?</h3>&nbsp;...",
    977. 

  977.             shorten_text($text, 43));
    978. 

  978.     }
    979. 

  979. 

  980.     public function test_shorten_text_no_spaces() {
    981. 

  981.         // ..........123456789.
    982. 

  982.         $text = "<h1>123456789</h1>"; // A string with no convenient breaks.
    983. 

  983.         $this->assertSame("<h1>12345...</h1>", shorten_text($text, 8));
    984. 

  984.     }
    985. 

  985. 

  986.     public function test_shorten_text_utf8_european() {
    987. 

  987.         // Text without tags.
    988. 

  988.         // ......123456789012345678901234567.
    989. 

  989.         $text = "Žluťoučký koníček přeskočil";
    990. 

  990.         $this->assertSame($text, shorten_text($text)); // 30 chars by default.
    991. 

  991.         $this->assertSame("Žluťoučký koníče...", shorten_text($text, 19, true));
    992. 

  992.         $this->assertSame("Žluťoučký ...", shorten_text($text, 19, false));
    993. 

  993.         // And try it with 2-less (that are, in bytes, the middle of a sequence).
    994. 

  994.         $this->assertSame("Žluťoučký koní...", shorten_text($text, 17, true));
    995. 

  995.         $this->assertSame("Žluťoučký ...", shorten_text($text, 17, false));
    996. 

  996. 

  997.         // .........123456789012345678...901234567....89012345.
    998. 

  998.         $text = "<p>Žluťoučký koníček <b>přeskočil</b> potůček</p>";
    999. 

  999.         $this->assertSame($text, shorten_text($text, 60));
    1000. 

  1000.         $this->assertSame("<p>Žluťoučký koníček ...</p>", shorten_text($text, 21));
    1001. 

  1001.         $this->assertSame("<p>Žluťoučký koníče...</p>", shorten_text($text, 19, true));
    1002. 

  1002.         $this->assertSame("<p>Žluťoučký ...</p>", shorten_text($text, 19, false));
    1003. 

  1003.         // And try it with 2 fewer (that are, in bytes, the middle of a sequence).
    1004. 

  1004.         $this->assertSame("<p>Žluťoučký koní...</p>", shorten_text($text, 17, true));
    1005. 

  1005.         $this->assertSame("<p>Žluťoučký ...</p>", shorten_text($text, 17, false));
    1006. 

  1006.         // And try over one tag (start/end), it does proper text len.
    1007. 

  1007.         $this->assertSame("<p>Žluťoučký koníček <b>př...</b></p>", shorten_text($text, 23, true));
    1008. 

  1008.         $this->assertSame("<p>Žluťoučký koníček <b>přeskočil</b> pot...</p>", shorten_text($text, 34, true));
    1009. 

  1009.         // And in the middle of one tag.
    1010. 

  1010.         $this->assertSame("<p>Žluťoučký koníček <b>přeskočil...</b></p>", shorten_text($text, 30, true));
    1011. 

  1011.     }
    1012. 

  1012. 

  1013.     public function test_shorten_text_utf8_oriental() {
    1014. 

  1014.         // Japanese
    1015. 

  1015.         // text without tags
    1016. 

  1016.         // ......123456789012345678901234.
    1017. 

  1017.         $text = '言語設定言語設定abcdefghijkl';
    1018. 

  1018.         $this->assertSame($text, shorten_text($text)); // 30 chars by default.
    1019. 

  1019.         $this->assertSame("言語設定言語...", shorten_text($text, 9, true));
    1020. 

  1020.         $this->assertSame("言語設定言語...", shorten_text($text, 9, false));
    1021. 

  1021.         $this->assertSame("言語設定言語設定ab...", shorten_text($text, 13, true));
    1022. 

  1022.         $this->assertSame("言語設定言語設定...", shorten_text($text, 13, false));
    1023. 

  1023. 

  1024.         // Chinese
    1025. 

  1025.         // text without tags
    1026. 

  1026.         // ......123456789012345678901234.
    1027. 

  1027.         $text = '简体中文简体中文abcdefghijkl';
    1028. 

  1028.         $this->assertSame($text, shorten_text($text)); // 30 chars by default.
    1029. 

  1029.         $this->assertSame("简体中文简体...", shorten_text($text, 9, true));
    1030. 

  1030.         $this->assertSame("简体中文简体...", shorten_text($text, 9, false));
    1031. 

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

  1032.         $this->assertSame("简体中文简体中文...", shorten_text($text, 13, false));
    1033. 

  1033.     }
    1034. 

  1034. 

  1035.     public function test_shorten_text_multilang() {
    1036. 

  1036.         // This is not necessaryily specific to multilang. The issue is really
    1037. 

  1037.         // tags with attributes, where before we were generating invalid HTML
    1038. 

  1038.         // output like shorten_text('<span id="x" class="y">A</span> B', 1)
    1039. 

  1039.         // returning '<span id="x" ...</span>'. It is just that multilang
    1040. 

  1040.         // requires the sort of HTML that is quite likely to trigger this.
    1041. 

  1041.         // ........................................1...
    1042. 

  1042.         $text = '<span lang="en" class="multilang">A</span>' .
    1043. 

  1043.                 '<span lang="fr" class="multilang">B</span>';
    1044. 

  1044.         $this->assertSame('<span lang="en" class="multilang">...</span>',
    1045. 

  1045.                 shorten_text($text, 1));
    1046. 

  1046.     }
    1047. 

  1047. 

  1048.     /**
    1049. 

  1049.      * Provider for long filenames and its expected result, with and without hash.
    1050. 

  1050.      *
    1051. 

  1051.      * @return array of ($filename, $length, $expected, $includehash)
    1052. 

  1052.      */
    1053. 

  1053.     public function shorten_filename_provider() {
    1054. 

  1054.         $filename = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium totam rem';
    1055. 

  1055.         $shortfilename = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque';
    1056. 

  1056. 

  1057.         return [
    1058. 

  1058.             'More than 100 characters' => [
    1059. 

  1059.                 $filename,
    1060. 

  1060.                 null,
    1061. 

  1061.                 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium tot',
    1062. 

  1062.                 false,
    1063. 

  1063.             ],
    1064. 

  1064.             'More than 100 characters with hash' => [
    1065. 

  1065.                 $filename,
    1066. 

  1066.                 null,
    1067. 

  1067.                 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque l - 3bec1da8b8',
    1068. 

  1068.                 true,
    1069. 

  1069.             ],
    1070. 

  1070.             'More than 100 characters with extension' => [
    1071. 

  1071.                 "{$filename}.zip",
    1072. 

  1072.                 null,
    1073. 

  1073.                 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium tot.zip',
    1074. 

  1074.                 false,
    1075. 

  1075.             ],
    1076. 

  1076.             'More than 100 characters with extension and hash' => [
    1077. 

  1077.                 "{$filename}.zip",
    1078. 

  1078.                 null,
    1079. 

  1079.                 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque l - 3bec1da8b8.zip',
    1080. 

  1080.                 true,
    1081. 

  1081.             ],
    1082. 

  1082.             'Limit filename to 50 chars' => [
    1083. 

  1083.                 $filename,
    1084. 

  1084.                 50,
    1085. 

  1085.                 'sed ut perspiciatis unde omnis iste natus error si',
    1086. 

  1086.                 false,
    1087. 

  1087.             ],
    1088. 

  1088.             'Limit filename to 50 chars with hash' => [
    1089. 

  1089.                 $filename,
    1090. 

  1090.                 50,
    1091. 

  1091.                 'sed ut perspiciatis unde omnis iste n - 3bec1da8b8',
    1092. 

  1092.                 true,
    1093. 

  1093.             ],
    1094. 

  1094.             'Limit filename to 50 chars with extension' => [
    1095. 

  1095.                 "{$filename}.zip",
    1096. 

  1096.                 50,
    1097. 

  1097.                 'sed ut perspiciatis unde omnis iste natus error si.zip',
    1098. 

  1098.                 false,
    1099. 

  1099.             ],
    1100. 

  1100.             'Limit filename to 50 chars with extension and hash' => [
    1101. 

  1101.                 "{$filename}.zip",
    1102. 

  1102.                 50,
    1103. 

  1103.                 'sed ut perspiciatis unde omnis iste n - 3bec1da8b8.zip',
    1104. 

  1104.                 true,
    1105. 

  1105.             ],
    1106. 

  1106.             'Test filename that contains less than 100 characters' => [
    1107. 

  1107.                 $shortfilename,
    1108. 

  1108.                 null,
    1109. 

  1109.                 $shortfilename,
    1110. 

  1110.                 false,
    1111. 

  1111.             ],
    1112. 

  1112.             'Test filename that contains less than 100 characters and hash' => [
    1113. 

  1113.                 $shortfilename,
    1114. 

  1114.                 null,
    1115. 

  1115.                 $shortfilename,
    1116. 

  1116.                 true,
    1117. 

  1117.             ],
    1118. 

  1118.             'Test filename that contains less than 100 characters with extension' => [
    1119. 

  1119.                 "{$shortfilename}.zip",
    1120. 

  1120.                 null,
    1121. 

  1121.                 "{$shortfilename}.zip",
    1122. 

  1122.                 false,
    1123. 

  1123.             ],
    1124. 

  1124.             'Test filename that contains less than 100 characters with extension and hash' => [
    1125. 

  1125.                 "{$shortfilename}.zip",
    1126. 

  1126.                 null,
    1127. 

  1127.                 "{$shortfilename}.zip",
    1128. 

  1128.                 true,
    1129. 

  1129.             ],
    1130. 

  1130.         ];
    1131. 

  1131.     }
    1132. 

  1132. 

  1133.     /**
    1134. 

  1134.      * Test the {@link shorten_filename()} method.
    1135. 

  1135.      *
    1136. 

  1136.      * @dataProvider shorten_filename_provider
    1137. 

  1137.      *
    1138. 

  1138.      * @param string $filename
    1139. 

  1139.      * @param int $length
    1140. 

  1140.      * @param string $expected
    1141. 

  1141.      * @param boolean $includehash
    1142. 

  1142.      */
    1143. 

  1143.     public function test_shorten_filename($filename, $length, $expected, $includehash) {
    1144. 

  1144.         if (null === $length) {
    1145. 

  1145.             $length = MAX_FILENAME_SIZE;
    1146. 

  1146.         }
    1147. 

  1147. 

  1148.         $this->assertSame($expected, shorten_filename($filename, $length, $includehash));
    1149. 

  1149.     }
    1150. 

  1150. 

  1151.     /**
    1152. 

  1152.      * Provider for long filenames and its expected result, with and without hash.
    1153. 

  1153.      *
    1154. 

  1154.      * @return array of ($filename, $length, $expected, $includehash)
    1155. 

  1155.      */
    1156. 

  1156.     public function shorten_filenames_provider() {
    1157. 

  1157.         $shortfilename = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque';
    1158. 

  1158.         $longfilename = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium totam rem';
    1159. 

  1159.         $extfilename = $longfilename.'.zip';
    1160. 

  1160.         $expected = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium tot';
    1161. 

  1161.         $expectedwithhash = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque l - 3bec1da8b8';
    1162. 

  1162.         $expectedext = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium tot.zip';
    1163. 

  1163.         $expectedextwithhash = 'sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque l - 3bec1da8b8.zip';
    1164. 

  1164.         $expected50 = 'sed ut perspiciatis unde omnis iste natus error si';
    1165. 

  1165.         $expected50withhash = 'sed ut perspiciatis unde omnis iste n - 3bec1da8b8';
    1166. 

  1166.         $expected50ext = 'sed ut perspiciatis unde omnis iste natus error si.zip';
    1167. 

  1167.         $expected50extwithhash = 'sed ut perspiciatis unde omnis iste n - 3bec1da8b8.zip';
    1168. 

  1168.         $expected50short = 'sed ut perspiciatis unde omnis iste n - 5fb6543490';
    1169. 

  1169. 

  1170.         return [
    1171. 

  1171.             'Empty array without hash' => [
    1172. 

  1172.                 [],
    1173. 

  1173.                 null,
    1174. 

  1174.                 [],
    1175. 

  1175.                 false,
    1176. 

  1176.             ],
    1177. 

  1177.             'Empty array with hash' => [
    1178. 

  1178.                 [],
    1179. 

  1179.                 null,
    1180. 

  1180.                 [],
    1181. 

  1181.                 true,
    1182. 

  1182.             ],
    1183. 

  1183.             'Array with less than 100 characters' => [
    1184. 

  1184.                 [$shortfilename, $shortfilename, $shortfilename],
    1185. 

  1185.                 null,
    1186. 

  1186.                 [$shortfilename, $shortfilename, $shortfilename],
    1187. 

  1187.                 false,
    1188. 

  1188.             ],
    1189. 

  1189.             'Array with more than 100 characters without hash' => [
    1190. 

  1190.                 [$longfilename, $longfilename, $longfilename],
    1191. 

  1191.                 null,
    1192. 

  1192.                 [$expected, $expected, $expected],
    1193. 

  1193.                 false,
    1194. 

  1194.             ],
    1195. 

  1195.             'Array with more than 100 characters with hash' => [
    1196. 

  1196.                 [$longfilename, $longfilename, $longfilename],
    1197. 

  1197.                 null,
    1198. 

  1198.                 [$expectedwithhash, $expectedwithhash, $expectedwithhash],
    1199. 

  1199.                 true,
    1200. 

  1200.             ],
    1201. 

  1201.             'Array with more than 100 characters with extension' => [
    1202. 

  1202.                 [$extfilename, $extfilename, $extfilename],
    1203. 

  1203.                 null,
    1204. 

  1204.                 [$expectedext, $expectedext, $expectedext],
    1205. 

  1205.                 false,
    1206. 

  1206.             ],
    1207. 

  1207.             'Array with more than 100 characters with extension and hash' => [
    1208. 

  1208.                 [$extfilename, $extfilename, $extfilename],
    1209. 

  1209.                 null,
    1210. 

  1210.                 [$expectedextwithhash, $expectedextwithhash, $expectedextwithhash],
    1211. 

  1211.                 true,
    1212. 

  1212.             ],
    1213. 

  1213.             'Array with more than 100 characters mix (short, long, with extension) without hash' => [
    1214. 

  1214.                 [$shortfilename, $longfilename, $extfilename],
    1215. 

  1215.                 null,
    1216. 

  1216.                 [$shortfilename, $expected, $expectedext],
    1217. 

  1217.                 false,
    1218. 

  1218.             ],
    1219. 

  1219.             'Array with more than 100 characters mix (short, long, with extension) with hash' => [
    1220. 

  1220.                 [$shortfilename, $longfilename, $extfilename],
    1221. 

  1221.                 null,
    1222. 

  1222.                 [$shortfilename, $expectedwithhash, $expectedextwithhash],
    1223. 

  1223.                 true,
    1224. 

  1224.             ],
    1225. 

  1225.             'Array with less than 50 characters without hash' => [
    1226. 

  1226.                 [$longfilename, $longfilename, $longfilename],
    1227. 

  1227.                 50,
    1228. 

  1228.                 [$expected50, $expected50, $expected50],
    1229. 

  1229.                 false,
    1230. 

  1230.             ],
    1231. 

  1231.             'Array with less than 50 characters with hash' => [
    1232. 

  1232.                 [$longfilename, $longfilename, $longfilename],
    1233. 

  1233.                 50,
    1234. 

  1234.                 [$expected50withhash, $expected50withhash, $expected50withhash],
    1235. 

  1235.                 true,
    1236. 

  1236.             ],
    1237. 

  1237.             'Array with less than 50 characters with extension' => [
    1238. 

  1238.                 [$extfilename, $extfilename, $extfilename],
    1239. 

  1239.                 50,
    1240. 

  1240.                 [$expected50ext, $expected50ext, $expected50ext],
    1241. 

  1241.                 false,
    1242. 

  1242.             ],
    1243. 

  1243.             'Array with less than 50 characters with extension and hash' => [
    1244. 

  1244.                 [$extfilename, $extfilename, $extfilename],
    1245. 

  1245.                 50,
    1246. 

  1246.                 [$expected50extwithhash, $expected50extwithhash, $expected50extwithhash],
    1247. 

  1247.                 true,
    1248. 

  1248.             ],
    1249. 

  1249.             'Array with less than 50 characters mix (short, long, with extension) without hash' => [
    1250. 

  1250.                 [$shortfilename, $longfilename, $extfilename],
    1251. 

  1251.                 50,
    1252. 

  1252.                 [$expected50, $expected50, $expected50ext],
    1253. 

  1253.                 false,
    1254. 

  1254.             ],
    1255. 

  1255.             'Array with less than 50 characters mix (short, long, with extension) with hash' => [
    1256. 

  1256.                 [$shortfilename, $longfilename, $extfilename],
    1257. 

  1257.                 50,
    1258. 

  1258.                 [$expected50short, $expected50withhash, $expected50extwithhash],
    1259. 

  1259.                 true,
    1260. 

  1260.             ],
    1261. 

  1261.         ];
    1262. 

  1262.     }
    1263. 

  1263. 

  1264.     /**
    1265. 

  1265.      * Test the {@link shorten_filenames()} method.
    1266. 

  1266.      *
    1267. 

  1267.      * @dataProvider shorten_filenames_provider
    1268. 

  1268.      *
    1269. 

  1269.      * @param string $filenames
    1270. 

  1270.      * @param int $length
    1271. 

  1271.      * @param string $expected
    1272. 

  1272.      * @param boolean $includehash
    1273. 

  1273.      */
    1274. 

  1274.     public function test_shorten_filenames($filenames, $length, $expected, $includehash) {
    1275. 

  1275.         if (null === $length) {
    1276. 

  1276.             $length = MAX_FILENAME_SIZE;
    1277. 

  1277.         }
    1278. 

  1278. 

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

  1280.     }
    1281. 

  1281. 

  1282.     public function test_usergetdate() {
    1283. 

  1283.         global $USER, $CFG, $DB;
    1284. 

  1284.         $this->resetAfterTest();
    1285. 

  1285. 

  1286.         $this->setAdminUser();
    1287. 

  1287. 

  1288.         $USER->timezone = 2;// Set the timezone to a known state.
    1289. 

  1289. 

  1290.         $ts = 1261540267; // The time this function was created.
    1291. 

  1291. 

  1292.         $arr = usergetdate($ts, 1); // Specify the timezone as an argument.
    1293. 

  1293.         $arr = array_values($arr);
    1294. 

  1294. 

  1295.         list($seconds, $minutes, $hours, $mday, $wday, $mon, $year, $yday, $weekday, $month) = $arr;
    1296. 

  1296.         $this->assertSame(7, $seconds);
    1297. 

  1297.         $this->assertSame(51, $minutes);
    1298. 

  1298.         $this->assertSame(4, $hours);
    1299. 

  1299.         $this->assertSame(23, $mday);
    1300. 

  1300.         $this->assertSame(3, $wday);
    1301. 

  1301.         $this->assertSame(12, $mon);
    1302. 

  1302.         $this->assertSame(2009, $year);
    1303. 

  1303.         $this->assertSame(356, $yday);
    1304. 

  1304.         $this->assertSame('Wednesday', $weekday);
    1305. 

  1305.         $this->assertSame('December', $month);
    1306. 

  1306.         $arr = usergetdate($ts); // Gets the timezone from the $USER object.
    1307. 

  1307.         $arr = array_values($arr);
    1308. 

  1308. 

  1309.         list($seconds, $minutes, $hours, $mday, $wday, $mon, $year, $yday, $weekday, $month) = $arr;
    1310. 

  1310.         $this->assertSame(7, $seconds);
    1311. 

  1311.         $this->assertSame(51, $minutes);
    1312. 

  1312.         $this->assertSame(5, $hours);
    1313. 

  1313.         $this->assertSame(23, $mday);
    1314. 

  1314.         $this->assertSame(3, $wday);
    1315. 

  1315.         $this->assertSame(12, $mon);
    1316. 

  1316.         $this->assertSame(2009, $year);
    1317. 

  1317.         $this->assertSame(356, $yday);
    1318. 

  1318.         $this->assertSame('Wednesday', $weekday);
    1319. 

  1319.         $this->assertSame('December', $month);
    1320. 

  1320.     }
    1321. 

  1321. 

  1322.     public function test_mark_user_preferences_changed() {
    1323. 

  1323.         $this->resetAfterTest();
    1324. 

  1324.         $otheruser = $this->getDataGenerator()->create_user();
    1325. 

  1325.         $otheruserid = $otheruser->id;
    1326. 

  1326. 

  1327.         set_cache_flag('userpreferenceschanged', $otheruserid, null);
    1328. 

  1328.         mark_user_preferences_changed($otheruserid);
    1329. 

  1329. 

  1330.         $this->assertEquals(get_cache_flag('userpreferenceschanged', $otheruserid, time()-10), 1);
    1331. 

  1331.         set_cache_flag('userpreferenceschanged', $otheruserid, null);
    1332. 

  1332.     }
    1333. 

  1333. 

  1334.     public function test_check_user_preferences_loaded() {
    1335. 

  1335.         global $DB;
    1336. 

  1336.         $this->resetAfterTest();
    1337. 

  1337. 

  1338.         $otheruser = $this->getDataGenerator()->create_user();
    1339. 

  1339.         $otheruserid = $otheruser->id;
    1340. 

  1340. 

  1341.         $DB->delete_records('user_preferences', array('userid'=>$otheruserid));
    1342. 

  1342.         set_cache_flag('userpreferenceschanged', $otheruserid, null);
    1343. 

  1343. 

  1344.         $user = new stdClass();
    1345. 

  1345.         $user->id = $otheruserid;
    1346. 

  1346. 

  1347.         // Load.
    1348. 

  1348.         check_user_preferences_loaded($user);
    1349. 

  1349.         $this->assertTrue(isset($user->preference));
    1350. 

  1350.         $this->assertTrue(is_array($user->preference));
    1351. 

  1351.         $this->assertArrayHasKey('_lastloaded', $user->preference);
    1352. 

  1352.         $this->assertCount(1, $user->preference);
    1353. 

  1353. 

  1354.         // Add preference via direct call.
    1355. 

  1355.         $DB->insert_record('user_preferences', array('name'=>'xxx', 'value'=>'yyy', 'userid'=>$user->id));
    1356. 

  1356. 

  1357.         // No cache reload yet.
    1358. 

  1358.         check_user_preferences_loaded($user);
    1359. 

  1359.         $this->assertCount(1, $user->preference);
    1360. 

  1360. 

  1361.         // Forced reloading of cache.
    1362. 

  1362.         unset($user->preference);
    1363. 

  1363.         check_user_preferences_loaded($user);
    1364. 

  1364.         $this->assertCount(2, $user->preference);
    1365. 

  1365.         $this->assertSame('yyy', $user->preference['xxx']);
    1366. 

  1366. 

  1367.         // Add preference via direct call.
    1368. 

  1368.         $DB->insert_record('user_preferences', array('name'=>'aaa', 'value'=>'bbb', 'userid'=>$user->id));
    1369. 

  1369. 

  1370.         // Test timeouts and modifications from different session.
    1371. 

  1371.         set_cache_flag('userpreferenceschanged', $user->id, 1, time() + 1000);
    1372. 

  1372.         $user->preference['_lastloaded'] = $user->preference['_lastloaded'] - 20;
    1373. 

  1373.         check_user_preferences_loaded($user);
    1374. 

  1374.         $this->assertCount(2, $user->preference);
    1375. 

  1375.         check_user_preferences_loaded($user, 10);
    1376. 

  1376.         $this->assertCount(3, $user->preference);
    1377. 

  1377.         $this->assertSame('bbb', $user->preference['aaa']);
    1378. 

  1378.         set_cache_flag('userpreferenceschanged', $user->id, null);
    1379. 

  1379.     }
    1380. 

  1380. 

  1381.     public function test_set_user_preference() {
    1382. 

  1382.         global $DB, $USER;
    1383. 

  1383.         $this->resetAfterTest();
    1384. 

  1384. 

  1385.         $this->setAdminUser();
    1386. 

  1386. 

  1387.         $otheruser = $this->getDataGenerator()->create_user();
    1388. 

  1388.         $otheruserid = $otheruser->id;
    1389. 

  1389. 

  1390.         $DB->delete_records('user_preferences', array('userid'=>$otheruserid));
    1391. 

  1391.         set_cache_flag('userpreferenceschanged', $otheruserid, null);
    1392. 

  1392. 

  1393.         $user = new stdClass();
    1394. 

  1394.         $user->id = $otheruserid;
    1395. 

  1395. 

  1396.         set_user_preference('aaa', 'bbb', $otheruserid);
    1397. 

  1397.         $this->assertSame('bbb', $DB->get_field('user_preferences', 'value', array('userid'=>$otheruserid, 'name'=>'aaa')));
    1398. 

  1398.         $this->assertSame('bbb', get_user_preferences('aaa', null, $otheruserid));
    1399. 

  1399. 

  1400.         set_user_preference('xxx', 'yyy', $user);
    1401. 

  1401.         $this->assertSame('yyy', $DB->get_field('user_preferences', 'value', array('userid'=>$otheruserid, 'name'=>'xxx')));
    1402. 

  1402.         $this->assertSame('yyy', get_user_preferences('xxx', null, $otheruserid));
    1403. 

  1403.         $this->assertTrue(is_array($user->preference));
    1404. 

  1404.         $this->assertSame('bbb', $user->preference['aaa']);
    1405. 

  1405.         $this->assertSame('yyy', $user->preference['xxx']);
    1406. 

  1406. 

  1407.         set_user_preference('xxx', null, $user);
    1408. 

  1408.         $this->assertFalse($DB->get_field('user_preferences', 'value', array('userid'=>$otheruserid, 'name'=>'xxx')));
    1409. 

  1409.         $this->assertNull(get_user_preferences('xxx', null, $otheruserid));
    1410. 

  1410. 

  1411.         set_user_preference('ooo', true, $user);
    1412. 

  1412.         $prefs = get_user_preferences(null, null, $otheruserid);
    1413. 

  1413.         $this->assertSame($user->preference['aaa'], $prefs['aaa']);
    1414. 

  1414.         $this->assertSame($user->preference['ooo'], $prefs['ooo']);
    1415. 

  1415.         $this->assertSame('1', $prefs['ooo']);
    1416. 

  1416. 

  1417.         set_user_preference('null', 0, $user);
    1418. 

  1418.         $this->assertSame('0', get_user_preferences('null', null, $otheruserid));
    1419. 

  1419. 

  1420.         $this->assertSame('lala', get_user_preferences('undefined', 'lala', $otheruserid));
    1421. 

  1421. 

  1422.         $DB->delete_records('user_preferences', array('userid'=>$otheruserid));
    1423. 

  1423.         set_cache_flag('userpreferenceschanged', $otheruserid, null);
    1424. 

  1424. 

  1425.         // Test $USER default.
    1426. 

  1426.         set_user_preference('_test_user_preferences_pref', 'ok');
    1427. 

  1427.         $this->assertSame('ok', $USER->preference['_test_user_preferences_pref']);
    1428. 

  1428.         unset_user_preference('_test_user_preferences_pref');
    1429. 

  1429.         $this->assertTrue(!isset($USER->preference['_test_user_preferences_pref']));
    1430. 

  1430. 

  1431.         // Test 1333 char values (no need for unicode, there are already tests for that in DB tests).
    1432. 

  1432.         $longvalue = str_repeat('a', 1333);
    1433. 

  1433.         set_user_preference('_test_long_user_preference', $longvalue);
    1434. 

  1434.         $this->assertEquals($longvalue, get_user_preferences('_test_long_user_preference'));
    1435. 

  1435.         $this->assertEquals($longvalue,
    1436. 

  1436.             $DB->get_field('user_preferences', 'value', array('userid' => $USER->id, 'name' => '_test_long_user_preference')));
    1437. 

  1437. 

  1438.         // Test > 1333 char values, coding_exception expected.
    1439. 

  1439.         $longvalue = str_repeat('a', 1334);
    1440. 

  1440.         try {
    1441. 

  1441.             set_user_preference('_test_long_user_preference', $longvalue);
    1442. 

  1442.             $this->fail('Exception expected - longer than 1333 chars not allowed as preference value');
    1443. 

  1443.         } catch (moodle_exception $ex) {
    1444. 

  1444.             $this->assertInstanceOf('coding_exception', $ex);
    1445. 

  1445.         }
    1446. 

  1446. 

  1447.         // Test invalid params.
    1448. 

  1448.         try {
    1449. 

  1449.             set_user_preference('_test_user_preferences_pref', array());
    1450. 

  1450.             $this->fail('Exception expected - array not valid preference value');
    1451. 

  1451.         } catch (moodle_exception $ex) {
    1452. 

  1452.             $this->assertInstanceOf('coding_exception', $ex);
    1453. 

  1453.         }
    1454. 

  1454.         try {
    1455. 

  1455.             set_user_preference('_test_user_preferences_pref', new stdClass);
    1456. 

  1456.             $this->fail('Exception expected - class not valid preference value');
    1457. 

  1457.         } catch (moodle_exception $ex) {
    1458. 

  1458.             $this->assertInstanceOf('coding_exception', $ex);
    1459. 

  1459.         }
    1460. 

  1460.         try {
    1461. 

  1461.             set_user_preference('_test_user_preferences_pref', 1, array('xx' => 1));
    1462. 

  1462.             $this->fail('Exception expected - user instance expected');
    1463. 

  1463.         } catch (moodle_exception $ex) {
    1464. 

  1464.             $this->assertInstanceOf('coding_exception', $ex);
    1465. 

  1465.         }
    1466. 

  1466.         try {
    1467. 

  1467.             set_user_preference('_test_user_preferences_pref', 1, 'abc');
    1468. 

  1468.             $this->fail('Exception expected - user instance expected');
    1469. 

  1469.         } catch (moodle_exception $ex) {
    1470. 

  1470.             $this->assertInstanceOf('coding_exception', $ex);
    1471. 

  1471.         }
    1472. 

  1472.         try {
    1473. 

  1473.             set_user_preference('', 1);
    1474. 

  1474.             $this->fail('Exception expected - invalid name accepted');
    1475. 

  1475.         } catch (moodle_exception $ex) {
    1476. 

  1476.             $this->assertInstanceOf('coding_exception', $ex);
    1477. 

  1477.         }
    1478. 

  1478.         try {
    1479. 

  1479.             set_user_preference('1', 1);
    1480. 

  1480.             $this->fail('Exception expected - invalid name accepted');
    1481. 

  1481.         } catch (moodle_exception $ex) {
    1482. 

  1482.             $this->assertInstanceOf('coding_exception', $ex);
    1483. 

  1483.         }
    1484. 

  1484.     }
    1485. 

  1485. 

  1486.     public function test_set_user_preference_for_current_user() {
    1487. 

  1487.         global $USER;
    1488. 

  1488.         $this->resetAfterTest();
    1489. 

  1489.         $this->setAdminUser();
    1490. 

  1490. 

  1491.         set_user_preference('test_pref', 2);
    1492. 

  1492.         set_user_preference('test_pref', 1, $USER->id);
    1493. 

  1493.         $this->assertEquals(1, get_user_preferences('test_pref'));
    1494. 

  1494.     }
    1495. 

  1495. 

  1496.     public function test_unset_user_preference_for_current_user() {
    1497. 

  1497.         global $USER;
    1498. 

  1498.         $this->resetAfterTest();
    1499. 

  1499.         $this->setAdminUser();
    1500. 

  1500. 

  1501.         set_user_preference('test_pref', 1);
    1502. 

  1502.         unset_user_preference('test_pref', $USER->id);
    1503. 

  1503.         $this->assertNull(get_user_preferences('test_pref'));
    1504. 

  1504.     }
    1505. 

  1505. 

  1506.     /**
    1507. 

  1507.      * Test essential features implementation of {@link get_extra_user_fields()} as the admin user with all capabilities.
    1508. 

  1508.      */
    1509. 

  1509.     public function test_get_extra_user_fields_essentials() {
    1510. 

  1510.         global $CFG, $USER, $DB;
    1511. 

  1511.         $this->resetAfterTest();
    1512. 

  1512. 

  1513.         $this->setAdminUser();
    1514. 

  1514.         $context = context_system::instance();
    1515. 

  1515. 

  1516.         // No fields.
    1517. 

  1517.         $CFG->showuseridentity = '';
    1518. 

  1518.         $this->assertEquals(array(), get_extra_user_fields($context));
    1519. 

  1519. 

  1520.         // One field.
    1521. 

  1521.         $CFG->showuseridentity = 'frog';
    1522. 

  1522.         $this->assertEquals(array('frog'), get_extra_user_fields($context));
    1523. 

  1523. 

  1524.         // Two fields.
    1525. 

  1525.         $CFG->showuseridentity = 'frog,zombie';
    1526. 

  1526.         $this->assertEquals(array('frog', 'zombie'), get_extra_user_fields($context));
    1527. 

  1527. 

  1528.         // No fields, except.
    1529. 

  1529.         $CFG->showuseridentity = '';
    1530. 

  1530.         $this->assertEquals(array(), get_extra_user_fields($context, array('frog')));
    1531. 

  1531. 

  1532.         // One field.
    1533. 

  1533.         $CFG->showuseridentity = 'frog';
    1534. 

  1534.         $this->assertEquals(array(), get_extra_user_fields($context, array('frog')));
    1535. 

  1535. 

  1536.         // Two fields.
    1537. 

  1537.         $CFG->showuseridentity = 'frog,zombie';
    1538. 

  1538.         $this->assertEquals(array('zombie'), get_extra_user_fields($context, array('frog')));
    1539. 

  1539.     }
    1540. 

  1540. 

  1541.     /**
    1542. 

  1542.      * Prepare environment for couple of tests related to permission checks in {@link get_extra_user_fields()}.
    1543. 

  1543.      *
    1544. 

  1544.      * @return stdClass
    1545. 

  1545.      */
    1546. 

  1546.     protected function environment_for_get_extra_user_fields_tests() {
    1547. 

  1547.         global $CFG, $DB;
    1548. 

  1548. 

  1549.         $CFG->showuseridentity = 'idnumber,country,city';
    1550. 

  1550.         $CFG->hiddenuserfields = 'country,city';
    1551. 

  1551. 

  1552.         $env = new stdClass();
    1553. 

  1553. 

  1554.         $env->course = $this->getDataGenerator()->create_course();
    1555. 

  1555.         $env->coursecontext = context_course::instance($env->course->id);
    1556. 

  1556. 

  1557.         $env->teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
    1558. 

  1558.         $env->studentrole = $DB->get_record('role', array('shortname' => 'student'));
    1559. 

  1559.         $env->managerrole = $DB->get_record('role', array('shortname' => 'manager'));
    1560. 

  1560. 

  1561.         $env->student = $this->getDataGenerator()->create_user();
    1562. 

  1562.         $env->teacher = $this->getDataGenerator()->create_user();
    1563. 

  1563.         $env->manager = $this->getDataGenerator()->create_user();
    1564. 

  1564. 

  1565.         role_assign($env->studentrole->id, $env->student->id, $env->coursecontext->id);
    1566. 

  1566.         role_assign($env->teacherrole->id, $env->teacher->id, $env->coursecontext->id);
    1567. 

  1567.         role_assign($env->managerrole->id, $env->manager->id, SYSCONTEXTID);
    1568. 

  1568. 

  1569.         return $env;
    1570. 

  1570.     }
    1571. 

  1571. 

  1572.     /**
    1573. 

  1573.      * No identity fields shown to student user (no permission to view identity fields).
    1574. 

  1574.      */
    1575. 

  1575.     public function test_get_extra_user_fields_no_access() {
    1576. 

  1576. 

  1577.         $this->resetAfterTest();
    1578. 

  1578.         $env = $this->environment_for_get_extra_user_fields_tests();
    1579. 

  1579.         $this->setUser($env->student);
    1580. 

  1580. 

  1581.         $this->assertEquals(array(), get_extra_user_fields($env->coursecontext));
    1582. 

  1582.         $this->assertEquals(array(), get_extra_user_fields(context_system::instance()));
    1583. 

  1583.     }
    1584. 

  1584. 

  1585.     /**
    1586. 

  1586.      * Teacher can see students' identity fields only within the course.
    1587. 

  1587.      */
    1588. 

  1588.     public function test_get_extra_user_fields_course_only_access() {
    1589. 

  1589. 

  1590.         $this->resetAfterTest();
    1591. 

  1591.         $env = $this->environment_for_get_extra_user_fields_tests();
    1592. 

  1592.         $this->setUser($env->teacher);
    1593. 

  1593. 

  1594.         $this->assertEquals(array('idnumber', 'country', 'city'), get_extra_user_fields($env->coursecontext));
    1595. 

  1595.         $this->assertEquals(array(), get_extra_user_fields(context_system::instance()));
    1596. 

  1596.     }
    1597. 

  1597. 

  1598.     /**
    1599. 

  1599.      * Teacher can be prevented from seeing students' identity fields even within the course.
    1600. 

  1600.      */
    1601. 

  1601.     public function test_get_extra_user_fields_course_prevented_access() {
    1602. 

  1602. 

  1603.         $this->resetAfterTest();
    1604. 

  1604.         $env = $this->environment_for_get_extra_user_fields_tests();
    1605. 

  1605.         $this->setUser($env->teacher);
    1606. 

  1606. 

  1607.         assign_capability('moodle/course:viewhiddenuserfields', CAP_PREVENT, $env->teacherrole->id, $env->coursecontext->id);
    1608. 

  1608.         $this->assertEquals(array('idnumber'), get_extra_user_fields($env->coursecontext));
    1609. 

  1609.     }
    1610. 

  1610. 

  1611.     /**
    1612. 

  1612.      * Manager can see students' identity fields anywhere.
    1613. 

  1613.      */
    1614. 

  1614.     public function test_get_extra_user_fields_anywhere_access() {
    1615. 

  1615. 

  1616.         $this->resetAfterTest();
    1617. 

  1617.         $env = $this->environment_for_get_extra_user_fields_tests();
    1618. 

  1618.         $this->setUser($env->manager);
    1619. 

  1619. 

  1620.         $this->assertEquals(array('idnumber', 'country', 'city'), get_extra_user_fields($env->coursecontext));
    1621. 

  1621.         $this->assertEquals(array('idnumber', 'country', 'city'), get_extra_user_fields(context_system::instance()));
    1622. 

  1622.     }
    1623. 

  1623. 

  1624.     /**
    1625. 

  1625.      * Manager can be prevented from seeing hidden fields outside the course.
    1626. 

  1626.      */
    1627. 

  1627.     public function test_get_extra_user_fields_schismatic_access() {
    1628. 

  1628. 

  1629.         $this->resetAfterTest();
    1630. 

  1630.         $env = $this->environment_for_get_extra_user_fields_tests();
    1631. 

  1631.         $this->setUser($env->manager);
    1632. 

  1632. 

  1633.         assign_capability('moodle/user:viewhiddendetails', CAP_PREVENT, $env->managerrole->id, SYSCONTEXTID, true);
    1634. 

  1634.         $this->assertEquals(array('idnumber'), get_extra_user_fields(context_system::instance()));
    1635. 

  1635.         // Note that inside the course, the manager can still see the hidden identifiers as this is currently
    1636. 

  1636.         // controlled by a separate capability for legacy reasons.
    1637. 

  1637.         $this->assertEquals(array('idnumber', 'country', 'city'), get_extra_user_fields($env->coursecontext));
    1638. 

  1638.     }
    1639. 

  1639. 

  1640.     /**
    1641. 

  1641.      * Two capabilities must be currently set to prevent manager from seeing hidden fields.
    1642. 

  1642.      */
    1643. 

  1643.     public function test_get_extra_user_fields_hard_to_prevent_access() {
    1644. 

  1644. 

  1645.         $this->resetAfterTest();
    1646. 

  1646.         $env = $this->environment_for_get_extra_user_fields_tests();
    1647. 

  1647.         $this->setUser($env->manager);
    1648. 

  1648. 

  1649.         assign_capability('moodle/user:viewhiddendetails', CAP_PREVENT, $env->managerrole->id, SYSCONTEXTID, true);
    1650. 

  1650.         assign_capability('moodle/course:viewhiddenuserfields', CAP_PREVENT, $env->managerrole->id, SYSCONTEXTID, true);
    1651. 

  1651. 

  1652.         $this->assertEquals(array('idnumber'), get_extra_user_fields(context_system::instance()));
    1653. 

  1653.         $this->assertEquals(array('idnumber'), get_extra_user_fields($env->coursecontext));
    1654. 

  1654.     }
    1655. 

  1655. 

  1656.     public function test_get_extra_user_fields_sql() {
    1657. 

  1657.         global $CFG, $USER, $DB;
    1658. 

  1658.         $this->resetAfterTest();
    1659. 

  1659. 

  1660.         $this->setAdminUser();
    1661. 

  1661. 

  1662.         $context = context_system::instance();
    1663. 

  1663. 

  1664.         // No fields.
    1665. 

  1665.         $CFG->showuseridentity = '';
    1666. 

  1666.         $this->assertSame('', get_extra_user_fields_sql($context));
    1667. 

  1667. 

  1668.         // One field.
    1669. 

  1669.         $CFG->showuseridentity = 'frog';
    1670. 

  1670.         $this->assertSame(', frog', get_extra_user_fields_sql($context));
    1671. 

  1671. 

  1672.         // Two fields with table prefix.
    1673. 

  1673.         $CFG->showuseridentity = 'frog,zombie';
    1674. 

  1674.         $this->assertSame(', u1.frog, u1.zombie', get_extra_user_fields_sql($context, 'u1'));
    1675. 

  1675. 

  1676.         // Two fields with field prefix.
    1677. 

  1677.         $CFG->showuseridentity = 'frog,zombie';
    1678. 

  1678.         $this->assertSame(', frog AS u_frog, zombie AS u_zombie',
    1679. 

  1679.             get_extra_user_fields_sql($context, '', 'u_'));
    1680. 

  1680. 

  1681.         // One field excluded.
    1682. 

  1682.         $CFG->showuseridentity = 'frog';
    1683. 

  1683.         $this->assertSame('', get_extra_user_fields_sql($context, '', '', array('frog')));
    1684. 

  1684. 

  1685.         // Two fields, one excluded, table+field prefix.
    1686. 

  1686.         $CFG->showuseridentity = 'frog,zombie';
    1687. 

  1687.         $this->assertEquals(', u1.zombie AS u_zombie',
    1688. 

  1688.             get_extra_user_fields_sql($context, 'u1', 'u_', array('frog')));
    1689. 

  1689.     }
    1690. 

  1690. 

  1691.     /**
    1692. 

  1692.      * Test some critical TZ/DST.
    1693. 

  1693.      *
    1694. 

  1694.      * This method tests some special TZ/DST combinations that were fixed
    1695. 

  1695.      * by MDL-38999. The tests are done by comparing the results of the
    1696. 

  1696.      * output using Moodle TZ/DST support and PHP native one.
    1697. 

  1697.      *
    1698. 

  1698.      * Note: If you don't trust PHP TZ/DST support, can verify the
    1699. 

  1699.      * harcoded expectations below with:
    1700. 

  1700.      * http://www.tools4noobs.com/online_tools/unix_timestamp_to_datetime/
    1701. 

  1701.      */
    1702. 

  1702.     public function test_some_moodle_special_dst() {
    1703. 

  1703.         $stamp = 1365386400; // 2013/04/08 02:00:00 GMT/UTC.
    1704. 

  1704. 

  1705.         // In Europe/Tallinn it was 2013/04/08 05:00:00.
    1706. 

  1706.         $expectation = '2013/04/08 05:00:00';
    1707. 

  1707.         $phpdt = DateTime::createFromFormat('U', $stamp, new DateTimeZone('UTC'));
    1708. 

  1708.         $phpdt->setTimezone(new DateTimeZone('Europe/Tallinn'));
    1709. 

  1709.         $phpres = $phpdt->format('Y/m/d H:i:s'); // PHP result.
    1710. 

  1710.         $moodleres = userdate($stamp, '%Y/%m/%d %H:%M:%S', 'Europe/Tallinn', false); // Moodle result.
    1711. 

  1711.         $this->assertSame($expectation, $phpres);
    1712. 

  1712.         $this->assertSame($expectation, $moodleres);
    1713. 

  1713. 

  1714.         // In St. Johns it was 2013/04/07 23:30:00.
    1715. 

  1715.         $expectation = '2013/04/07 23:30:00';
    1716. 

  1716.         $phpdt = DateTime::createFromFormat('U', $stamp, new DateTimeZone('UTC'));
    1717. 

  1717.         $phpdt->setTimezone(new DateTimeZone('America/St_Johns'));
    1718. 

  1718.         $phpres = $phpdt->format('Y/m/d H:i:s'); // PHP result.
    1719. 

  1719.         $moodleres = userdate($stamp, '%Y/%m/%d %H:%M:%S', 'America/St_Johns', false); // Moodle result.
    1720. 

  1720.         $this->assertSame($expectation, $phpres);
    1721. 

  1721.         $this->assertSame($expectation, $moodleres);
    1722. 

  1722. 

  1723.         $stamp = 1383876000; // 2013/11/08 02:00:00 GMT/UTC.
    1724. 

  1724. 

  1725.         // In Europe/Tallinn it was 2013/11/08 04:00:00.
    1726. 

  1726.         $expectation = '2013/11/08 04:00:00';
    1727. 

  1727.         $phpdt = DateTime::createFromFormat('U', $stamp, new DateTimeZone('UTC'));
    1728. 

  1728.         $phpdt->setTimezone(new DateTimeZone('Europe/Tallinn'));
    1729. 

  1729.         $phpres = $phpdt->format('Y/m/d H:i:s'); // PHP result.
    1730. 

  1730.         $moodleres = userdate($stamp, '%Y/%m/%d %H:%M:%S', 'Europe/Tallinn', false); // Moodle result.
    1731. 

  1731.         $this->assertSame($expectation, $phpres);
    1732. 

  1732.         $this->assertSame($expectation, $moodleres);
    1733. 

  1733. 

  1734.         // In St. Johns it was 2013/11/07 22:30:00.
    1735. 

  1735.         $expectation = '2013/11/07 22:30:00';
    1736. 

  1736.         $phpdt = DateTime::createFromFormat('U', $stamp, new DateTimeZone('UTC'));
    1737. 

  1737.         $phpdt->setTimezone(new DateTimeZone('America/St_Johns'));
    1738. 

  1738.         $phpres = $phpdt->format('Y/m/d H:i:s'); // PHP result.
    1739. 

  1739.         $moodleres = userdate($stamp, '%Y/%m/%d %H:%M:%S', 'America/St_Johns', false); // Moodle result.
    1740. 

  1740.         $this->assertSame($expectation, $phpres);
    1741. 

  1741.         $this->assertSame($expectation, $moodleres);
    1742. 

  1742.     }
    1743. 

  1743. 

  1744.     public function test_userdate() {
    1745. 

  1745.         global $USER, $CFG, $DB;
    1746. 

  1746.         $this->resetAfterTest();
    1747. 

  1747. 

  1748.         $this->setAdminUser();
    1749. 

  1749. 

  1750.         $testvalues = array(
    1751. 

  1751.             array(
    1752. 

  1752.                 'time' => '1309514400',
    1753. 

  1753.                 'usertimezone' => 'America/Moncton',
    1754. 

  1754.                 'timezone' => '0.0', // No dst offset.
    1755. 

  1755.                 'expectedoutput' => 'Friday, 1 July 2011, 10:00 AM',
    1756. 

  1756.                 'expectedoutputhtml' => '<time datetime="2011-07-01T07:00:00-03:00">Friday, 1 July 2011, 10:00 AM</time>'
    1757. 

  1757.             ),
    1758. 

  1758.             array(
    1759. 

  1759.                 'time' => '1309514400',
    1760. 

  1760.                 'usertimezone' => 'America/Moncton',
    1761. 

  1761.                 'timezone' => '99', // Dst offset and timezone offset.
    1762. 

  1762.                 'expectedoutput' => 'Friday, 1 July 2011, 7:00 AM',
    1763. 

  1763.                 'expectedoutputhtml' => '<time datetime="2011-07-01T07:00:00-03:00">Friday, 1 July 2011, 7:00 AM</time>'
    1764. 

  1764.             ),
    1765. 

  1765.             array(
    1766. 

  1766.                 'time' => '1309514400',
    1767. 

  1767.                 'usertimezone' => 'America/Moncton',
    1768. 

  1768.                 'timezone' => 'America/Moncton', // Dst offset and timezone offset.
    1769. 

  1769.                 'expectedoutput' => 'Friday, 1 July 2011, 7:00 AM',
    1770. 

  1770.                 'expectedoutputhtml' => '<time datetime="2011-07-01t07:00:00-03:00">Friday, 1 July 2011, 7:00 AM</time>'
    1771. 

  1771.             ),
    1772. 

  1772.             array(
    1773. 

  1773.                 'time' => '1293876000 ',
    1774. 

  1774.                 'usertimezone' => 'America/Moncton',
    1775. 

  1775.                 'timezone' => '0.0', // No dst offset.
    1776. 

  1776.                 'expectedoutput' => 'Saturday, 1 January 2011, 10:00 AM',
    1777. 

  1777.                 'expectedoutputhtml' => '<time datetime="2011-01-01T06:00:00-04:00">Saturday, 1 January 2011, 10:00 AM</time>'
    1778. 

  1778.             ),
    1779. 

  1779.             array(
    1780. 

  1780.                 'time' => '1293876000 ',
    1781. 

  1781.                 'usertimezone' => 'America/Moncton',
    1782. 

  1782.                 'timezone' => '99', // No dst offset in jan, so just timezone offset.
    1783. 

  1783.                 'expectedoutput' => 'Saturday, 1 January 2011, 6:00 AM',
    1784. 

  1784.                 'expectedoutputhtml' => '<time datetime="2011-01-01T06:00:00-04:00">Saturday, 1 January 2011, 6:00 AM</time>'
    1785. 

  1785.             ),
    1786. 

  1786.             array(
    1787. 

  1787.                 'time' => '1293876000 ',
    1788. 

  1788.                 'usertimezone' => 'America/Moncton',
    1789. 

  1789.                 'timezone' => 'America/Moncton', // No dst offset in jan.
    1790. 

  1790.                 'expectedoutput' => 'Saturday, 1 January 2011, 6:00 AM',
    1791. 

  1791.                 'expectedoutputhtml' => '<time datetime="2011-01-01T06:00:00-04:00">Saturday, 1 January 2011, 6:00 AM</time>'
    1792. 

  1792.             ),
    1793. 

  1793.             array(
    1794. 

  1794.                 'time' => '1293876000 ',
    1795. 

  1795.                 'usertimezone' => '2',
    1796. 

  1796.                 'timezone' => '99', // Take user timezone.
    1797. 

  1797.                 'expectedoutput' => 'Saturday, 1 January 2011, 12:00 PM',
    1798. 

  1798.                 'expectedoutputhtml' => '<time datetime="2011-01-01T12:00:00+02:00">Saturday, 1 January 2011, 12:00 PM</time>'
    1799. 

  1799.             ),
    1800. 

  1800.             array(
    1801. 

  1801.                 'time' => '1293876000 ',
    1802. 

  1802.                 'usertimezone' => '-2',
    1803. 

  1803.                 'timezone' => '99', // Take user timezone.
    1804. 

  1804.                 'expectedoutput' => 'Saturday, 1 January 2011, 8:00 AM',
    1805. 

  1805.                 'expectedoutputhtml' => '<time datetime="2011-01-01T08:00:00-02:00">Saturday, 1 January 2011, 8:00 AM</time>'
    1806. 

  1806.             ),
    1807. 

  1807.             array(
    1808. 

  1808.                 'time' => '1293876000 ',
    1809. 

  1809.                 'usertimezone' => '-10',
    1810. 

  1810.                 'timezone' => '2', // Take this timezone.
    1811. 

  1811.                 'expectedoutput' => 'Saturday, 1 January 2011, 12:00 PM',
    1812. 

  1812.                 'expectedoutputhtml' => '<time datetime="2011-01-01T00:00:00-10:00">Saturday, 1 January 2011, 12:00 PM</time>'
    1813. 

  1813.             ),
    1814. 

  1814.             array(
    1815. 

  1815.                 'time' => '1293876000 ',
    1816. 

  1816.                 'usertimezone' => '-10',
    1817. 

  1817.                 'timezone' => '-2', // Take this timezone.
    1818. 

  1818.                 'expectedoutput' => 'Saturday, 1 January 2011, 8:00 AM',
    1819. 

  1819.                 'expectedoutputhtml' => '<time datetime="2011-01-01T00:00:00-10:00">Saturday, 1 January 2011, 8:00 AM</time>'
    1820. 

  1820.             ),
    1821. 

  1821.             array(
    1822. 

  1822.                 'time' => '1293876000 ',
    1823. 

  1823.                 'usertimezone' => '-10',
    1824. 

  1824.                 'timezone' => 'random/time', // This should show server time.
    1825. 

  1825.                 'expectedoutput' => 'Saturday, 1 January 2011, 6:00 PM',
    1826. 

  1826.                 'expectedoutputhtml' => '<time datetime="2011-01-01T00:00:00-10:00">Saturday, 1 January 2011, 6:00 PM</time>'
    1827. 

  1827.             ),
    1828. 

  1828.             array(
    1829. 

  1829.                 'time' => '1293876000 ',
    1830. 

  1830.                 'usertimezone' => '20', // Fallback to server time zone.
    1831. 

  1831.                 'timezone' => '99',     // This should show user time.
    1832. 

  1832.                 'expectedoutput' => 'Saturday, 1 January 2011, 6:00 PM',
    1833. 

  1833.                 'expectedoutputhtml' => '<time datetime="2011-01-01T18:00:00+08:00">Saturday, 1 January 2011, 6:00 PM</time>'
    1834. 

  1834.             ),
    1835. 

  1835.         );
    1836. 

  1836. 

  1837.         // Set default timezone to Australia/Perth, else time calculated
    1838. 

  1838.         // will not match expected values.
    1839. 

  1839.         $this->setTimezone(99, 'Australia/Perth');
    1840. 

  1840. 

  1841.         foreach ($testvalues as $vals) {
    1842. 

  1842.             $USER->timezone = $vals['usertimezone'];
    1843. 

  1843.             $actualoutput = userdate($vals['time'], '%A, %d %B %Y, %I:%M %p', $vals['timezone']);
    1844. 

  1844.             $actualoutputhtml = userdate_htmltime($vals['time'], '%A, %d %B %Y, %I:%M %p', $vals['timezone']);
    1845. 

  1845. 

  1846.             // On different systems case of AM PM changes so compare case insensitive.
    1847. 

  1847.             $vals['expectedoutput'] = core_text::strtolower($vals['expectedoutput']);
    1848. 

  1848.             $vals['expectedoutputhtml'] = core_text::strtolower($vals['expectedoutputhtml']);
    1849. 

  1849.             $actualoutput = core_text::strtolower($actualoutput);
    1850. 

  1850.             $actualoutputhtml = core_text::strtolower($actualoutputhtml);
    1851. 

  1851. 

  1852.             $this->assertSame($vals['expectedoutput'], $actualoutput,
    1853. 

  1853.                 "Expected: {$vals['expectedoutput']} => Actual: {$actualoutput} \ndata: " . var_export($vals, true));
    1854. 

  1854.             $this->assertSame($vals['expectedoutputhtml'], $actualoutputhtml,
    1855. 

  1855.                 "Expected: {$vals['expectedoutputhtml']} => Actual: {$actualoutputhtml} \ndata: " . var_export($vals, true));
    1856. 

  1856.         }
    1857. 

  1857.     }
    1858. 

  1858. 

  1859.     /**
    1860. 

  1860.      * Make sure the DST changes happen at the right time in Moodle.
    1861. 

  1861.      */
    1862. 

  1862.     public function test_dst_changes() {
    1863. 

  1863.         // DST switching in Prague.
    1864. 

  1864.         // From 2AM to 3AM in 1989.
    1865. 

  1865.         $date = new DateTime('1989-03-26T01:59:00+01:00');
    1866. 

  1866.         $this->assertSame('Sunday, 26 March 1989, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1867. 

  1867.         $date = new DateTime('1989-03-26T02:01:00+01:00');
    1868. 

  1868.         $this->assertSame('Sunday, 26 March 1989, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1869. 

  1869.         // From 3AM to 2AM in 1989 - not the same as the west Europe.
    1870. 

  1870.         $date = new DateTime('1989-09-24T01:59:00+01:00');
    1871. 

  1871.         $this->assertSame('Sunday, 24 September 1989, 02:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1872. 

  1872.         $date = new DateTime('1989-09-24T02:01:00+01:00');
    1873. 

  1873.         $this->assertSame('Sunday, 24 September 1989, 02:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1874. 

  1874.         // From 2AM to 3AM in 2014.
    1875. 

  1875.         $date = new DateTime('2014-03-30T01:59:00+01:00');
    1876. 

  1876.         $this->assertSame('Sunday, 30 March 2014, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1877. 

  1877.         $date = new DateTime('2014-03-30T02:01:00+01:00');
    1878. 

  1878.         $this->assertSame('Sunday, 30 March 2014, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1879. 

  1879.         // From 3AM to 2AM in 2014.
    1880. 

  1880.         $date = new DateTime('2014-10-26T01:59:00+01:00');
    1881. 

  1881.         $this->assertSame('Sunday, 26 October 2014, 02:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1882. 

  1882.         $date = new DateTime('2014-10-26T02:01:00+01:00');
    1883. 

  1883.         $this->assertSame('Sunday, 26 October 2014, 02:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1884. 

  1884.         // From 2AM to 3AM in 2020.
    1885. 

  1885.         $date = new DateTime('2020-03-29T01:59:00+01:00');
    1886. 

  1886.         $this->assertSame('Sunday, 29 March 2020, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1887. 

  1887.         $date = new DateTime('2020-03-29T02:01:00+01:00');
    1888. 

  1888.         $this->assertSame('Sunday, 29 March 2020, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1889. 

  1889.         // From 3AM to 2AM in 2020.
    1890. 

  1890.         $date = new DateTime('2020-10-25T01:59:00+01:00');
    1891. 

  1891.         $this->assertSame('Sunday, 25 October 2020, 02:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1892. 

  1892.         $date = new DateTime('2020-10-25T02:01:00+01:00');
    1893. 

  1893.         $this->assertSame('Sunday, 25 October 2020, 02:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Europe/Prague'));
    1894. 

  1894. 

  1895.         // DST switching in NZ.
    1896. 

  1896.         // From 3AM to 2AM in 2015.
    1897. 

  1897.         $date = new DateTime('2015-04-05T02:59:00+13:00');
    1898. 

  1898.         $this->assertSame('Sunday, 5 April 2015, 02:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Pacific/Auckland'));
    1899. 

  1899.         $date = new DateTime('2015-04-05T03:01:00+13:00');
    1900. 

  1900.         $this->assertSame('Sunday, 5 April 2015, 02:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Pacific/Auckland'));
    1901. 

  1901.         // From 2AM to 3AM in 2009.
    1902. 

  1902.         $date = new DateTime('2015-09-27T01:59:00+12:00');
    1903. 

  1903.         $this->assertSame('Sunday, 27 September 2015, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Pacific/Auckland'));
    1904. 

  1904.         $date = new DateTime('2015-09-27T02:01:00+12:00');
    1905. 

  1905.         $this->assertSame('Sunday, 27 September 2015, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Pacific/Auckland'));
    1906. 

  1906. 

  1907.         // DST switching in Perth.
    1908. 

  1908.         // From 3AM to 2AM in 2009.
    1909. 

  1909.         $date = new DateTime('2008-03-30T01:59:00+08:00');
    1910. 

  1910.         $this->assertSame('Sunday, 30 March 2008, 02:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Australia/Perth'));
    1911. 

  1911.         $date = new DateTime('2008-03-30T02:01:00+08:00');
    1912. 

  1912.         $this->assertSame('Sunday, 30 March 2008, 02:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Australia/Perth'));
    1913. 

  1913.         // From 2AM to 3AM in 2009.
    1914. 

  1914.         $date = new DateTime('2008-10-26T01:59:00+08:00');
    1915. 

  1915.         $this->assertSame('Sunday, 26 October 2008, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Australia/Perth'));
    1916. 

  1916.         $date = new DateTime('2008-10-26T02:01:00+08:00');
    1917. 

  1917.         $this->assertSame('Sunday, 26 October 2008, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'Australia/Perth'));
    1918. 

  1918. 

  1919.         // DST switching in US.
    1920. 

  1920.         // From 2AM to 3AM in 2014.
    1921. 

  1921.         $date = new DateTime('2014-03-09T01:59:00-05:00');
    1922. 

  1922.         $this->assertSame('Sunday, 9 March 2014, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
    1923. 

  1923.         $date = new DateTime('2014-03-09T02:01:00-05:00');
    1924. 

  1924.         $this->assertSame('Sunday, 9 March 2014, 03:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
    1925. 

  1925.         // From 3AM to 2AM in 2014.
    1926. 

  1926.         $date = new DateTime('2014-11-02T01:59:00-04:00');
    1927. 

  1927.         $this->assertSame('Sunday, 2 November 2014, 01:59', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
    1928. 

  1928.         $date = new DateTime('2014-11-02T02:01:00-04:00');
    1929. 

  1929.         $this->assertSame('Sunday, 2 November 2014, 01:01', userdate($date->getTimestamp(), '%A, %d %B %Y, %H:%M', 'America/New_York'));
    1930. 

  1930.     }
    1931. 

  1931. 

  1932.     public function test_make_timestamp() {
    1933. 

  1933.         global $USER, $CFG, $DB;
    1934. 

  1934.         $this->resetAfterTest();
    1935. 

  1935. 

  1936.         $this->setAdminUser();
    1937. 

  1937. 

  1938.         $testvalues = array(
    1939. 

  1939.             array(
    1940. 

  1940.                 'usertimezone' => 'America/Moncton',
    1941. 

  1941.                 'year' => '2011',
    1942. 

  1942.                 'month' => '7',
    1943. 

  1943.                 'day' => '1',
    1944. 

  1944.                 'hour' => '10',
    1945. 

  1945.                 'minutes' => '00',
    1946. 

  1946.                 'seconds' => '00',
    1947. 

  1947.                 'timezone' => '0.0',
    1948. 

  1948.                 'applydst' => false, // No dst offset.
    1949. 

  1949.                 'expectedoutput' => '1309514400' // 6pm at UTC+0.
    1950. 

  1950.             ),
    1951. 

  1951.             array(
    1952. 

  1952.                 'usertimezone' => 'America/Moncton',
    1953. 

  1953.                 'year' => '2011',
    1954. 

  1954.                 'month' => '7',
    1955. 

  1955.                 'day' => '1',
    1956. 

  1956.                 'hour' => '10',
    1957. 

  1957.                 'minutes' => '00',
    1958. 

  1958.                 'seconds' => '00',
    1959. 

  1959.                 'timezone' => '99',  // User default timezone.
    1960. 

  1960.                 'applydst' => false, // Don't apply dst.
    1961. 

  1961.                 'expectedoutput' => '1309528800'
    1962. 

  1962.             ),
    1963. 

  1963.             array(
    1964. 

  1964.                 'usertimezone' => 'America/Moncton',
    1965. 

  1965.                 'year' => '2011',
    1966. 

  1966.                 'month' => '7',
    1967. 

  1967.                 'day' => '1',
    1968. 

  1968.                 'hour' => '10',
    1969. 

  1969.                 'minutes' => '00',
    1970. 

  1970.                 'seconds' => '00',
    1971. 

  1971.                 'timezone' => '99', // User default timezone.
    1972. 

  1972.                 'applydst' => true, // Apply dst.
    1973. 

  1973.                 'expectedoutput' => '1309525200'
    1974. 

  1974.             ),
    1975. 

  1975.             array(
    1976. 

  1976.                 'usertimezone' => 'America/Moncton',
    1977. 

  1977.                 'year' => '2011',
    1978. 

  1978.                 'month' => '7',
    1979. 

  1979.                 'day' => '1',
    1980. 

  1980.                 'hour' => '10',
    1981. 

  1981.                 'minutes' => '00',
    1982. 

  1982.                 'seconds' => '00',
    1983. 

  1983.                 'timezone' => 'America/Moncton', // String timezone.
    1984. 

  1984.                 'applydst' => true, // Apply dst.
    1985. 

  1985.                 'expectedoutput' => '1309525200'
    1986. 

  1986.             ),
    1987. 

  1987.             array(
    1988. 

  1988.                 'usertimezone' => '2', // No dst applyed.
    1989. 

  1989.                 'year' => '2011',
    1990. 

  1990.                 'month' => '7',
    1991. 

  1991.                 'day' => '1',
    1992. 

  1992.                 'hour' => '10',
    1993. 

  1993.                 'minutes' => '00',
    1994. 

  1994.                 'seconds' => '00',
    1995. 

  1995.                 'timezone' => '99', // Take user timezone.
    1996. 

  1996.                 'applydst' => true, // Apply dst.
    1997. 

  1997.                 'expectedoutput' => '1309507200'
    1998. 

  1998.             ),
    1999. 

  1999.             array(
    2000. 

  2000.                 'usertimezone' => '-2', // No dst applyed.
    2001. 

  2001.                 'year' => '2011',
    2002. 

  2002.                 'month' => '7',
    2003. 

  2003.                 'day' => '1',
    2004. 

  2004.                 'hour' => '10',
    2005. 

  2005.                 'minutes' => '00',
    2006. 

  2006.                 'seconds' => '00',
    2007. 

  2007.                 'timezone' => '99', // Take usertimezone.
    2008. 

  2008.                 'applydst' => true, // Apply dst.
    2009. 

  2009.                 'expectedoutput' => '1309521600'
    2010. 

  2010.             ),
    2011. 

  2011.             array(
    2012. 

  2012.                 'usertimezone' => '-10', // No dst applyed.
    2013. 

  2013.                 'year' => '2011',
    2014. 

  2014.                 'month' => '7',
    2015. 

  2015.                 'day' => '1',
    2016. 

  2016.                 'hour' => '10',
    2017. 

  2017.                 'minutes' => '00',
    2018. 

  2018.                 'seconds' => '00',
    2019. 

  2019.                 'timezone' => '2',  // Take this timezone.
    2020. 

  2020.                 'applydst' => true, // Apply dst.
    2021. 

  2021.                 'expectedoutput' => '1309507200'
    2022. 

  2022.             ),
    2023. 

  2023.             array(
    2024. 

  2024.                 'usertimezone' => '-10', // No dst applyed.
    2025. 

  2025.                 'year' => '2011',
    2026. 

  2026.                 'month' => '7',
    2027. 

  2027.                 'day' => '1',
    2028. 

  2028.                 'hour' => '10',
    2029. 

  2029.                 'minutes' => '00',
    2030. 

  2030.                 'seconds' => '00',
    2031. 

  2031.                 'timezone' => '-2', // Take this timezone.
    2032. 

  2032.                 'applydst' => true, // Apply dst.
    2033. 

  2033.                 'expectedoutput' => '1309521600'
    2034. 

  2034.             ),
    2035. 

  2035.             array(
    2036. 

  2036.                 'usertimezone' => '-10', // No dst applyed.
    2037. 

  2037.                 'year' => '2011',
    2038. 

  2038.                 'month' => '7',
    2039. 

  2039.                 'day' => '1',
    2040. 

  2040.                 'hour' => '10',
    2041. 

  2041.                 'minutes' => '00',
    2042. 

  2042.                 'seconds' => '00',
    2043. 

  2043.                 'timezone' => 'random/time', // This should show server time.
    2044. 

  2044.                 'applydst' => true,          // Apply dst.
    2045. 

  2045.                 'expectedoutput' => '1309485600'
    2046. 

  2046.             ),
    2047. 

  2047.             array(
    2048. 

  2048.                 'usertimezone' => '-14', // Server time.
    2049. 

  2049.                 'year' => '2011',
    2050. 

  2050.                 'month' => '7',
    2051. 

  2051.                 'day' => '1',
    2052. 

  2052.                 'hour' => '10',
    2053. 

  2053.                 'minutes' => '00',
    2054. 

  2054.                 'seconds' => '00',
    2055. 

  2055.                 'timezone' => '99', // Get user time.
    2056. 

  2056.                 'applydst' => true, // Apply dst.
    2057. 

  2057.                 'expectedoutput' => '1309485600'
    2058. 

  2058.             )
    2059. 

  2059.         );
    2060. 

  2060. 

  2061.         // Set default timezone to Australia/Perth, else time calculated
    2062. 

  2062.         // will not match expected values.
    2063. 

  2063.         $this->setTimezone(99, 'Australia/Perth');
    2064. 

  2064. 

  2065.         // Test make_timestamp with all testvals and assert if anything wrong.
    2066. 

  2066.         foreach ($testvalues as $vals) {
    2067. 

  2067.             $USER->timezone = $vals['usertimezone'];
    2068. 

  2068.             $actualoutput = make_timestamp(
    2069. 

  2069.                 $vals['year'],
    2070. 

  2070.                 $vals['month'],
    2071. 

  2071.                 $vals['day'],
    2072. 

  2072.                 $vals['hour'],
    2073. 

  2073.                 $vals['minutes'],
    2074. 

  2074.                 $vals['seconds'],
    2075. 

  2075.                 $vals['timezone'],
    2076. 

  2076.                 $vals['applydst']
    2077. 

  2077.             );
    2078. 

  2078. 

  2079.             // On different systems case of AM PM changes so compare case insensitive.
    2080. 

  2080.             $vals['expectedoutput'] = core_text::strtolower($vals['expectedoutput']);
    2081. 

  2081.             $actualoutput = core_text::strtolower($actualoutput);
    2082. 

  2082. 

  2083.             $this->assertSame($vals['expectedoutput'], $actualoutput,
    2084. 

  2084.                 "Expected: {$vals['expectedoutput']} => Actual: {$actualoutput},
    2085. 

  2085.                 Please check if timezones are updated (Site adminstration -> location -> update timezone)");
    2086. 

  2086.         }
    2087. 

  2087.     }
    2088. 

  2088. 

  2089.     /**
    2090. 

  2090.      * Test get_string and most importantly the implementation of the lang_string
    2091. 

  2091.      * object.
    2092. 

  2092.      */
    2093. 

  2093.     public function test_get_string() {
    2094. 

  2094.         global $COURSE;
    2095. 

  2095. 

  2096.         // Make sure we are using English.
    2097. 

  2097.         $originallang = $COURSE->lang;
    2098. 

  2098.         $COURSE->lang = 'en';
    2099. 

  2099. 

  2100.         $yes = get_string('yes');
    2101. 

  2101.         $yesexpected = 'Yes';
    2102. 

  2102.         $this->assertInternalType('string', $yes);
    2103. 

  2103.         $this->assertSame($yesexpected, $yes);
    2104. 

  2104. 

  2105.         $yes = get_string('yes', 'moodle');
    2106. 

  2106.         $this->assertInternalType('string', $yes);
    2107. 

  2107.         $this->assertSame($yesexpected, $yes);
    2108. 

  2108. 

  2109.         $yes = get_string('yes', 'core');
    2110. 

  2110.         $this->assertInternalType('string', $yes);
    2111. 

  2111.         $this->assertSame($yesexpected, $yes);
    2112. 

  2112. 

  2113.         $yes = get_string('yes', '');
    2114. 

  2114.         $this->assertInternalType('string', $yes);
    2115. 

  2115.         $this->assertSame($yesexpected, $yes);
    2116. 

  2116. 

  2117.         $yes = get_string('yes', null);
    2118. 

  2118.         $this->assertInternalType('string', $yes);
    2119. 

  2119.         $this->assertSame($yesexpected, $yes);
    2120. 

  2120. 

  2121.         $yes = get_string('yes', null, 1);
    2122. 

  2122.         $this->assertInternalType('string', $yes);
    2123. 

  2123.         $this->assertSame($yesexpected, $yes);
    2124. 

  2124. 

  2125.         $days = 1;
    2126. 

  2126.         $numdays = get_string('numdays', 'core', '1');
    2127. 

  2127.         $numdaysexpected = $days.' days';
    2128. 

  2128.         $this->assertInternalType('string', $numdays);
    2129. 

  2129.         $this->assertSame($numdaysexpected, $numdays);
    2130. 

  2130. 

  2131.         $yes = get_string('yes', null, null, true);
    2132. 

  2132.         $this->assertInstanceOf('lang_string', $yes);
    2133. 

  2133.         $this->assertSame($yesexpected, (string)$yes);
    2134. 

  2134. 

  2135.         // Test using a lang_string object as the $a argument for a normal
    2136. 

  2136.         // get_string call (returning string).
    2137. 

  2137.         $test = new lang_string('yes', null, null, true);
    2138. 

  2138.         $testexpected = get_string('numdays', 'core', get_string('yes'));
    2139. 

  2139.         $testresult = get_string('numdays', null, $test);
    2140. 

  2140.         $this->assertInternalType('string', $testresult);
    2141. 

  2141.         $this->assertSame($testexpected, $testresult);
    2142. 

  2142. 

  2143.         // Test using a lang_string object as the $a argument for an object
    2144. 

  2144.         // get_string call (returning lang_string).
    2145. 

  2145.         $test = new lang_string('yes', null, null, true);
    2146. 

  2146.         $testexpected = get_string('numdays', 'core', get_string('yes'));
    2147. 

  2147.         $testresult = get_string('numdays', null, $test, true);
    2148. 

  2148.         $this->assertInstanceOf('lang_string', $testresult);
    2149. 

  2149.         $this->assertSame($testexpected, "$testresult");
    2150. 

  2150. 

  2151.         // Make sure that object properties that can't be converted don't cause
    2152. 

  2152.         // errors.
    2153. 

  2153.         // Level one: This is as deep as current language processing goes.
    2154. 

  2154.         $test = new stdClass;
    2155. 

  2155.         $test->one = 'here';
    2156. 

  2156.         $string = get_string('yes', null, $test, true);
    2157. 

  2157.         $this->assertEquals($yesexpected, $string);
    2158. 

  2158. 

  2159.         // Make sure that object properties that can't be converted don't cause
    2160. 

  2160.         // errors.
    2161. 

  2161.         // Level two: Language processing doesn't currently reach this deep.
    2162. 

  2162.         // only immediate scalar properties are worked with.
    2163. 

  2163.         $test = new stdClass;
    2164. 

  2164.         $test->one = new stdClass;
    2165. 

  2165.         $test->one->two = 'here';
    2166. 

  2166.         $string = get_string('yes', null, $test, true);
    2167. 

  2167.         $this->assertEquals($yesexpected, $string);
    2168. 

  2168. 

  2169.         // Make sure that object properties that can't be converted don't cause
    2170. 

  2170.         // errors.
    2171. 

  2171.         // Level three: It should never ever go this deep, but we're making sure
    2172. 

  2172.         // it doesn't cause any probs anyway.
    2173. 

  2173.         $test = new stdClass;
    2174. 

  2174.         $test->one = new stdClass;
    2175. 

  2175.         $test->one->two = new stdClass;
    2176. 

  2176.         $test->one->two->three = 'here';
    2177. 

  2177.         $string = get_string('yes', null, $test, true);
    2178. 

  2178.         $this->assertEquals($yesexpected, $string);
    2179. 

  2179. 

  2180.         // Make sure that object properties that can't be converted don't cause
    2181. 

  2181.         // errors and check lang_string properties.
    2182. 

  2182.         // Level one: This is as deep as current language processing goes.
    2183. 

  2183.         $test = new stdClass;
    2184. 

  2184.         $test->one = new lang_string('yes');
    2185. 

  2185.         $string = get_string('yes', null, $test, true);
    2186. 

  2186.         $this->assertEquals($yesexpected, $string);
    2187. 

  2187. 

  2188.         // Make sure that object properties that can't be converted don't cause
    2189. 

  2189.         // errors and check lang_string properties.
    2190. 

  2190.         // Level two: Language processing doesn't currently reach this deep.
    2191. 

  2191.         // only immediate scalar properties are worked with.
    2192. 

  2192.         $test = new stdClass;
    2193. 

  2193.         $test->one = new stdClass;
    2194. 

  2194.         $test->one->two = new lang_string('yes');
    2195. 

  2195.         $string = get_string('yes', null, $test, true);
    2196. 

  2196.         $this->assertEquals($yesexpected, $string);
    2197. 

  2197. 

  2198.         // Make sure that object properties that can't be converted don't cause
    2199. 

  2199.         // errors and check lang_string properties.
    2200. 

  2200.         // Level three: It should never ever go this deep, but we're making sure
    2201. 

  2201.         // it doesn't cause any probs anyway.
    2202. 

  2202.         $test = new stdClass;
    2203. 

  2203.         $test->one = new stdClass;
    2204. 

  2204.         $test->one->two = new stdClass;
    2205. 

  2205.         $test->one->two->three = new lang_string('yes');
    2206. 

  2206.         $string = get_string('yes', null, $test, true);
    2207. 

  2207.         $this->assertEquals($yesexpected, $string);
    2208. 

  2208. 

  2209.         // Make sure that array properties that can't be converted don't cause
    2210. 

  2210.         // errors.
    2211. 

  2211.         $test = array();
    2212. 

  2212.         $test['one'] = new stdClass;
    2213. 

  2213.         $test['one']->two = 'here';
    2214. 

  2214.         $string = get_string('yes', null, $test, true);
    2215. 

  2215.         $this->assertEquals($yesexpected, $string);
    2216. 

  2216. 

  2217.         // Same thing but as above except using an object... this is allowed :P.
    2218. 

  2218.         $string = get_string('yes', null, null, true);
    2219. 

  2219.         $object = new stdClass;
    2220. 

  2220.         $object->$string = 'Yes';
    2221. 

  2221.         $this->assertEquals($yesexpected, $string);
    2222. 

  2222.         $this->assertEquals($yesexpected, $object->$string);
    2223. 

  2223. 

  2224.         // Reset the language.
    2225. 

  2225.         $COURSE->lang = $originallang;
    2226. 

  2226.     }
    2227. 

  2227. 

  2228.     /**
    2229. 

  2229.      * @expectedException PHPUnit\Framework\Error\Warning
    2230. 

  2230.      */
    2231. 

  2231.     public function test_get_string_limitation() {
    2232. 

  2232.         // This is one of the limitations to the lang_string class. It can't be
    2233. 

  2233.         // used as a key.
    2234. 

  2234.         $array = array(get_string('yes', null, null, true) => 'yes');
    2235. 

  2235.     }
    2236. 

  2236. 

  2237.     /**
    2238. 

  2238.      * Test localised float formatting.
    2239. 

  2239.      */
    2240. 

  2240.     public function test_format_float() {
    2241. 

  2241. 

  2242.         // Special case for null.
    2243. 

  2243.         $this->assertEquals('', format_float(null));
    2244. 

  2244. 

  2245.         // Default 1 decimal place.
    2246. 

  2246.         $this->assertEquals('5.4', format_float(5.43));
    2247. 

  2247.         $this->assertEquals('5.0', format_float(5.001));
    2248. 

  2248. 

  2249.         // Custom number of decimal places.
    2250. 

  2250.         $this->assertEquals('5.43000', format_float(5.43, 5));
    2251. 

  2251. 

  2252.         // Auto detect the number of decimal places.
    2253. 

  2253.         $this->assertEquals('5.43', format_float(5.43, -1));
    2254. 

  2254.         $this->assertEquals('5.43', format_float(5.43000, -1));
    2255. 

  2255.         $this->assertEquals('5', format_float(5, -1));
    2256. 

  2256.         $this->assertEquals('5', format_float(5.0, -1));
    2257. 

  2257.         $this->assertEquals('0.543', format_float('5.43e-1', -1));
    2258. 

  2258.         $this->assertEquals('0.543', format_float('5.43000e-1', -1));
    2259. 

  2259. 

  2260.         // Option to strip ending zeros after rounding.
    2261. 

  2261.         $this->assertEquals('5.43', format_float(5.43, 5, true, true));
    2262. 

  2262.         $this->assertEquals('5', format_float(5.0001, 3, true, true));
    2263. 

  2263. 

  2264.         // Tests with a localised decimal separator.
    2265. 

  2265.         $this->define_local_decimal_separator();
    2266. 

  2266. 

  2267.         // Localisation on (default).
    2268. 

  2268.         $this->assertEquals('5X43000', format_float(5.43, 5));
    2269. 

  2269.         $this->assertEquals('5X43', format_float(5.43, 5, true, true));
    2270. 

  2270. 

  2271.         // Localisation off.
    2272. 

  2272.         $this->assertEquals('5.43000', format_float(5.43, 5, false));
    2273. 

  2273.         $this->assertEquals('5.43', format_float(5.43, 5, false, true));
    2274. 

  2274. 

  2275.         // Tests with tilde as localised decimal separator.
    2276. 

  2276.         $this->define_local_decimal_separator('~');
    2277. 

  2277. 

  2278.         // Must also work for '~' as decimal separator.
    2279. 

  2279.         $this->assertEquals('5', format_float(5.0001, 3, true, true));
    2280. 

  2280.         $this->assertEquals('5~43000', format_float(5.43, 5));
    2281. 

  2281.         $this->assertEquals('5~43', format_float(5.43, 5, true, true));
    2282. 

  2282.     }
    2283. 

  2283. 

  2284.     /**
    2285. 

  2285.      * Test localised float unformatting.
    2286. 

  2286.      */
    2287. 

  2287.     public function test_unformat_float() {
    2288. 

  2288. 

  2289.         // Tests without the localised decimal separator.
    2290. 

  2290. 

  2291.         // Special case for null, empty or white spaces only strings.
    2292. 

  2292.         $this->assertEquals(null, unformat_float(null));
    2293. 

  2293.         $this->assertEquals(null, unformat_float(''));
    2294. 

  2294.         $this->assertEquals(null, unformat_float('    '));
    2295. 

  2295. 

  2296.         // Regular use.
    2297. 

  2297.         $this->assertEquals(5.4, unformat_float('5.4'));
    2298. 

  2298.         $this->assertEquals(5.4, unformat_float('5.4', true));
    2299. 

  2299. 

  2300.         // No decimal.
    2301. 

  2301.         $this->assertEquals(5.0, unformat_float('5'));
    2302. 

  2302. 

  2303.         // Custom number of decimal.
    2304. 

  2304.         $this->assertEquals(5.43267, unformat_float('5.43267'));
    2305. 

  2305. 

  2306.         // Empty decimal.
    2307. 

  2307.         $this->assertEquals(100.0, unformat_float('100.00'));
    2308. 

  2308. 

  2309.         // With the thousand separator.
    2310. 

  2310.         $this->assertEquals(1000.0, unformat_float('1 000'));
    2311. 

  2311.         $this->assertEquals(1000.32, unformat_float('1 000.32'));
    2312. 

  2312. 

  2313.         // Negative number.
    2314. 

  2314.         $this->assertEquals(-100.0, unformat_float('-100'));
    2315. 

  2315. 

  2316.         // Wrong value.
    2317. 

  2317.         $this->assertEquals(0.0, unformat_float('Wrong value'));
    2318. 

  2318.         // Wrong value in strict mode.
    2319. 

  2319.         $this->assertFalse(unformat_float('Wrong value', true));
    2320. 

  2320. 

  2321.         // Combining options.
    2322. 

  2322.         $this->assertEquals(-1023.862567, unformat_float('   -1 023.862567     '));
    2323. 

  2323. 

  2324.         // Bad decimal separator (should crop the decimal).
    2325. 

  2325.         $this->assertEquals(50.0, unformat_float('50,57'));
    2326. 

  2326.         // Bad decimal separator in strict mode (should return false).
    2327. 

  2327.         $this->assertFalse(unformat_float('50,57', true));
    2328. 

  2328. 

  2329.         // Tests with a localised decimal separator.
    2330. 

  2330.         $this->define_local_decimal_separator();
    2331. 

  2331. 

  2332.         // We repeat the tests above but with the current decimal separator.
    2333. 

  2333. 

  2334.         // Regular use without and with the localised separator.
    2335. 

  2335.         $this->assertEquals (5.4, unformat_float('5.4'));
    2336. 

  2336.         $this->assertEquals (5.4, unformat_float('5X4'));
    2337. 

  2337. 

  2338.         // Custom number of decimal.
    2339. 

  2339.         $this->assertEquals (5.43267, unformat_float('5X43267'));
    2340. 

  2340. 

  2341.         // Empty decimal.
    2342. 

  2342.         $this->assertEquals (100.0, unformat_float('100X00'));
    2343. 

  2343. 

  2344.         // With the thousand separator.
    2345. 

  2345.         $this->assertEquals (1000.32, unformat_float('1 000X32'));
    2346. 

  2346. 

  2347.         // Bad different separator (should crop the decimal).
    2348. 

  2348.         $this->assertEquals (50.0, unformat_float('50Y57'));
    2349. 

  2349.         // Bad different separator in strict mode (should return false).
    2350. 

  2350.         $this->assertFalse (unformat_float('50Y57', true));
    2351. 

  2351. 

  2352.         // Combining options.
    2353. 

  2353.         $this->assertEquals (-1023.862567, unformat_float('   -1 023X862567     '));
    2354. 

  2354.         // Combining options in strict mode.
    2355. 

  2355.         $this->assertEquals (-1023.862567, unformat_float('   -1 023X862567     ', true));
    2356. 

  2356.     }
    2357. 

  2357. 

  2358.     /**
    2359. 

  2359.      * Test deleting of users.
    2360. 

  2360.      */
    2361. 

  2361.     public function test_delete_user() {
    2362. 

  2362.         global $DB, $CFG;
    2363. 

  2363. 

  2364.         $this->resetAfterTest();
    2365. 

  2365. 

  2366.         $guest = $DB->get_record('user', array('id'=>$CFG->siteguest), '*', MUST_EXIST);
    2367. 

  2367.         $admin = $DB->get_record('user', array('id'=>$CFG->siteadmins), '*', MUST_EXIST);
    2368. 

  2368.         $this->assertEquals(0, $DB->count_records('user', array('deleted'=>1)));
    2369. 

  2369. 

  2370.         $user = $this->getDataGenerator()->create_user(array('idnumber'=>'abc'));
    2371. 

  2371.         $user2 = $this->getDataGenerator()->create_user(array('idnumber'=>'xyz'));
    2372. 

  2372.         $usersharedemail1 = $this->getDataGenerator()->create_user(array('email' => 'sharedemail@example.invalid'));
    2373. 

  2373.         $usersharedemail2 = $this->getDataGenerator()->create_user(array('email' => 'sharedemail@example.invalid'));
    2374. 

  2374.         $useremptyemail1 = $this->getDataGenerator()->create_user(array('email' => ''));
    2375. 

  2375.         $useremptyemail2 = $this->getDataGenerator()->create_user(array('email' => ''));
    2376. 

  2376. 

  2377.         // Delete user and capture event.
    2378. 

  2378.         $sink = $this->redirectEvents();
    2379. 

  2379.         $result = delete_user($user);
    2380. 

  2380.         $events = $sink->get_events();
    2381. 

  2381.         $sink->close();
    2382. 

  2382.         $event = array_pop($events);
    2383. 

  2383. 

  2384.         // Test user is deleted in DB.
    2385. 

  2385.         $this->assertTrue($result);
    2386. 

  2386.         $deluser = $DB->get_record('user', array('id'=>$user->id), '*', MUST_EXIST);
    2387. 

  2387.         $this->assertEquals(1, $deluser->deleted);
    2388. 

  2388.         $this->assertEquals(0, $deluser->picture);
    2389. 

  2389.         $this->assertSame('', $deluser->idnumber);
    2390. 

  2390.         $this->assertSame(md5($user->username), $deluser->email);
    2391. 

  2391.         $this->assertRegExp('/^'.preg_quote($user->email, '/').'\.\d*$/', $deluser->username);
    2392. 

  2392. 

  2393.         $this->assertEquals(1, $DB->count_records('user', array('deleted'=>1)));
    2394. 

  2394. 

  2395.         // Test Event.
    2396. 

  2396.         $this->assertInstanceOf('\core\event\user_deleted', $event);
    2397. 

  2397.         $this->assertSame($user->id, $event->objectid);
    2398. 

  2398.         $this->assertSame('user_deleted', $event->get_legacy_eventname());
    2399. 

  2399.         $this->assertEventLegacyData($user, $event);
    2400. 

  2400.         $expectedlogdata = array(SITEID, 'user', 'delete', "view.php?id=$user->id", $user->firstname.' '.$user->lastname);
    2401. 

  2401.         $this->assertEventLegacyLogData($expectedlogdata, $event);
    2402. 

  2402.         $eventdata = $event->get_data();
    2403. 

  2403.         $this->assertSame($eventdata['other']['username'], $user->username);
    2404. 

  2404.         $this->assertSame($eventdata['other']['email'], $user->email);
    2405. 

  2405.         $this->assertSame($eventdata['other']['idnumber'], $user->idnumber);
    2406. 

  2406.         $this->assertSame($eventdata['other']['picture'], $user->picture);
    2407. 

  2407.         $this->assertSame($eventdata['other']['mnethostid'], $user->mnethostid);
    2408. 

  2408.         $this->assertEquals($user, $event->get_record_snapshot('user', $event->objectid));
    2409. 

  2409.         $this->assertEventContextNotUsed($event);
    2410. 

  2410. 

  2411.         // Try invalid params.
    2412. 

  2412.         $record = new stdClass();
    2413. 

  2413.         $record->grrr = 1;
    2414. 

  2414.         try {
    2415. 

  2415.             delete_user($record);
    2416. 

  2416.             $this->fail('Expecting exception for invalid delete_user() $user parameter');
    2417. 

  2417.         } catch (moodle_exception $ex) {
    2418. 

  2418.             $this->assertInstanceOf('coding_exception', $ex);
    2419. 

  2419.         }
    2420. 

  2420.         $record->id = 1;
    2421. 

  2421.         try {
    2422. 

  2422.             delete_user($record);
    2423. 

  2423.             $this->fail('Expecting exception for invalid delete_user() $user parameter');
    2424. 

  2424.         } catch (moodle_exception $ex) {
    2425. 

  2425.             $this->assertInstanceOf('coding_exception', $ex);
    2426. 

  2426.         }
    2427. 

  2427. 

  2428.         $record = new stdClass();
    2429. 

  2429.         $record->id = 666;
    2430. 

  2430.         $record->username = 'xx';
    2431. 

  2431.         $this->assertFalse($DB->record_exists('user', array('id'=>666))); // Any non-existent id is ok.
    2432. 

  2432.         $result = delete_user($record);
    2433. 

  2433.         $this->assertFalse($result);
    2434. 

  2434. 

  2435.         $result = delete_user($guest);
    2436. 

  2436.         $this->assertFalse($result);
    2437. 

  2437. 

  2438.         $result = delete_user($admin);
    2439. 

  2439.         $this->assertFalse($result);
    2440. 

  2440. 

  2441.         // Simultaneously deleting users with identical email addresses.
    2442. 

  2442.         $result1 = delete_user($usersharedemail1);
    2443. 

  2443.         $result2 = delete_user($usersharedemail2);
    2444. 

  2444. 

  2445.         $usersharedemail1after = $DB->get_record('user', array('id' => $usersharedemail1->id));
    2446. 

  2446.         $usersharedemail2after = $DB->get_record('user', array('id' => $usersharedemail2->id));
    2447. 

  2447.         $this->assertTrue($result1);
    2448. 

  2448.         $this->assertTrue($result2);
    2449. 

  2449.         $this->assertStringStartsWith($usersharedemail1->email . '.', $usersharedemail1after->username);
    2450. 

  2450.         $this->assertStringStartsWith($usersharedemail2->email . '.', $usersharedemail2after->username);
    2451. 

  2451. 

  2452.         // Simultaneously deleting users without email addresses.
    2453. 

  2453.         $result1 = delete_user($useremptyemail1);
    2454. 

  2454.         $result2 = delete_user($useremptyemail2);
    2455. 

  2455. 

  2456.         $useremptyemail1after = $DB->get_record('user', array('id' => $useremptyemail1->id));
    2457. 

  2457.         $useremptyemail2after = $DB->get_record('user', array('id' => $useremptyemail2->id));
    2458. 

  2458.         $this->assertTrue($result1);
    2459. 

  2459.         $this->assertTrue($result2);
    2460. 

  2460.         $this->assertStringStartsWith($useremptyemail1->username . '.' . $useremptyemail1->id . '@unknownemail.invalid.',
    2461. 

  2461.             $useremptyemail1after->username);
    2462. 

  2462.         $this->assertStringStartsWith($useremptyemail2->username . '.' . $useremptyemail2->id . '@unknownemail.invalid.',
    2463. 

  2463.             $useremptyemail2after->username);
    2464. 

  2464. 

  2465.         $this->resetDebugging();
    2466. 

  2466.     }
    2467. 

  2467. 

  2468.     /**
    2469. 

  2469.      * Test deletion of user with long username
    2470. 

  2470.      */
    2471. 

  2471.     public function test_delete_user_long_username() {
    2472. 

  2472.         global $DB;
    2473. 

  2473. 

  2474.         $this->resetAfterTest();
    2475. 

  2475. 

  2476.         // For users without an e-mail, one will be created during deletion using {$username}.{$id}@unknownemail.invalid format.
    2477. 

  2477.         $user = $this->getDataGenerator()->create_user([
    2478. 

  2478.             'username' => str_repeat('a', 75),
    2479. 

  2479.             'email' => '',
    2480. 

  2480.         ]);
    2481. 

  2481. 

  2482.         delete_user($user);
    2483. 

  2483. 

  2484.         // The username for the deleted user shouldn't exceed 100 characters.
    2485. 

  2485.         $usernamedeleted = $DB->get_field('user', 'username', ['id' => $user->id]);
    2486. 

  2486.         $this->assertEquals(100, core_text::strlen($usernamedeleted));
    2487. 

  2487. 

  2488.         $timestrlength = core_text::strlen((string) time());
    2489. 

  2489. 

  2490.         // It should start with the user name, and end with the current time.
    2491. 

  2491.         $this->assertStringStartsWith("{$user->username}.{$user->id}@", $usernamedeleted);
    2492. 

  2492.         $this->assertRegExp('/\.\d{' . $timestrlength . '}$/', $usernamedeleted);
    2493. 

  2493.     }
    2494. 

  2494. 

  2495.     /**
    2496. 

  2496.      * Test deletion of user with long email address
    2497. 

  2497.      */
    2498. 

  2498.     public function test_delete_user_long_email() {
    2499. 

  2499.         global $DB;
    2500. 

  2500. 

  2501.         $this->resetAfterTest();
    2502. 

  2502. 

  2503.         // Create user with 90 character email address.
    2504. 

  2504.         $user = $this->getDataGenerator()->create_user([
    2505. 

  2505.             'email' => str_repeat('a', 78) . '@example.com',
    2506. 

  2506.         ]);
    2507. 

  2507. 

  2508.         delete_user($user);
    2509. 

  2509. 

  2510.         // The username for the deleted user shouldn't exceed 100 characters.
    2511. 

  2511.         $usernamedeleted = $DB->get_field('user', 'username', ['id' => $user->id]);
    2512. 

  2512.         $this->assertEquals(100, core_text::strlen($usernamedeleted));
    2513. 

  2513. 

  2514.         $timestrlength = core_text::strlen((string) time());
    2515. 

  2515. 

  2516.         // Max username length is 100 chars. Select up to limit - (length of current time + 1 [period character]) from users email.
    2517. 

  2517.         $expectedemail = core_text::substr($user->email, 0, 100 - ($timestrlength + 1));
    2518. 

  2518.         $this->assertRegExp('/^' . preg_quote($expectedemail) . '\.\d{' . $timestrlength . '}$/', $usernamedeleted);
    2519. 

  2519.     }
    2520. 

  2520. 

  2521.     /**
    2522. 

  2522.      * Test function convert_to_array()
    2523. 

  2523.      */
    2524. 

  2524.     public function test_convert_to_array() {
    2525. 

  2525.         // Check that normal classes are converted to arrays the same way as (array) would do.
    2526. 

  2526.         $obj = new stdClass();
    2527. 

  2527.         $obj->prop1 = 'hello';
    2528. 

  2528.         $obj->prop2 = array('first', 'second', 13);
    2529. 

  2529.         $obj->prop3 = 15;
    2530. 

  2530.         $this->assertEquals(convert_to_array($obj), (array)$obj);
    2531. 

  2531. 

  2532.         // Check that context object (with iterator) is converted to array properly.
    2533. 

  2533.         $obj = context_system::instance();
    2534. 

  2534.         $ar = array(
    2535. 

  2535.             'id'           => $obj->id,
    2536. 

  2536.             'contextlevel' => $obj->contextlevel,
    2537. 

  2537.             'instanceid'   => $obj->instanceid,
    2538. 

  2538.             'path'         => $obj->path,
    2539. 

  2539.             'depth'        => $obj->depth,
    2540. 

  2540.             'locked'       => $obj->locked,
    2541. 

  2541.         );
    2542. 

  2542.         $this->assertEquals(convert_to_array($obj), $ar);
    2543. 

  2543.     }
    2544. 

  2544. 

  2545.     /**
    2546. 

  2546.      * Test the function date_format_string().
    2547. 

  2547.      */
    2548. 

  2548.     public function test_date_format_string() {
    2549. 

  2549.         global $CFG;
    2550. 

  2550. 

  2551.         $this->resetAfterTest();
    2552. 

  2552.         $this->setTimezone(99, 'Australia/Perth');
    2553. 

  2553. 

  2554.         $tests = array(
    2555. 

  2555.             array(
    2556. 

  2556.                 'tz' => 99,
    2557. 

  2557.                 'str' => '%A, %d %B %Y, %I:%M %p',
    2558. 

  2558.                 'expected' => 'Saturday, 01 January 2011, 06:00 PM'
    2559. 

  2559.             ),
    2560. 

  2560.             array(
    2561. 

  2561.                 'tz' => 0,
    2562. 

  2562.                 'str' => '%A, %d %B %Y, %I:%M %p',
    2563. 

  2563.                 'expected' => 'Saturday, 01 January 2011, 10:00 AM'
    2564. 

  2564.             ),
    2565. 

  2565.             array(
    2566. 

  2566.                 // Note: this function expected the timestamp in weird format before,
    2567. 

  2567.                 // since 2.9 it uses UTC.
    2568. 

  2568.                 'tz' => 'Pacific/Auckland',
    2569. 

  2569.                 'str' => '%A, %d %B %Y, %I:%M %p',
    2570. 

  2570.                 'expected' => 'Saturday, 01 January 2011, 11:00 PM'
    2571. 

  2571.             ),
    2572. 

  2572.             // Following tests pass on Windows only because en lang pack does
    2573. 

  2573.             // not contain localewincharset, in real life lang pack maintainers
    2574. 

  2574.             // may use only characters that are present in localewincharset
    2575. 

  2575.             // in format strings!
    2576. 

  2576.             array(
    2577. 

  2577.                 'tz' => 99,
    2578. 

  2578.                 'str' => 'Žluťoučký koníček %A',
    2579. 

  2579.                 'expected' => 'Žluťoučký koníček Saturday'
    2580. 

  2580.             ),
    2581. 

  2581.             array(
    2582. 

  2582.                 'tz' => 99,
    2583. 

  2583.                 'str' => '言語設定言語 %A',
    2584. 

  2584.                 'expected' => '言語設定言語 Saturday'
    2585. 

  2585.             ),
    2586. 

  2586.             array(
    2587. 

  2587.                 'tz' => 99,
    2588. 

  2588.                 'str' => '简体中文简体 %A',
    2589. 

  2589.                 'expected' => '简体中文简体 Saturday'
    2590. 

  2590.             ),
    2591. 

  2591.         );
    2592. 

  2592. 

  2593.         // Note: date_format_string() uses the timezone only to differenciate
    2594. 

  2594.         // the server time from the UTC time. It does not modify the timestamp.
    2595. 

  2595.         // Hence similar results for timezones <= 13.
    2596. 

  2596.         // On different systems case of AM PM changes so compare case insensitive.
    2597. 

  2597.         foreach ($tests as $test) {
    2598. 

  2598.             $str = date_format_string(1293876000, $test['str'], $test['tz']);
    2599. 

  2599.             $this->assertSame(core_text::strtolower($test['expected']), core_text::strtolower($str));
    2600. 

  2600.         }
    2601. 

  2601.     }
    2602. 

  2602. 

  2603.     public function test_get_config() {
    2604. 

  2604.         global $CFG;
    2605. 

  2605. 

  2606.         $this->resetAfterTest();
    2607. 

  2607. 

  2608.         // Preparation.
    2609. 

  2609.         set_config('phpunit_test_get_config_1', 'test 1');
    2610. 

  2610.         set_config('phpunit_test_get_config_2', 'test 2', 'mod_forum');
    2611. 

  2611.         if (!is_array($CFG->config_php_settings)) {
    2612. 

  2612.             $CFG->config_php_settings = array();
    2613. 

  2613.         }
    2614. 

  2614.         $CFG->config_php_settings['phpunit_test_get_config_3'] = 'test 3';
    2615. 

  2615. 

  2616.         if (!is_array($CFG->forced_plugin_settings)) {
    2617. 

  2617.             $CFG->forced_plugin_settings = array();
    2618. 

  2618.         }
    2619. 

  2619.         if (!array_key_exists('mod_forum', $CFG->forced_plugin_settings)) {
    2620. 

  2620.             $CFG->forced_plugin_settings['mod_forum'] = array();
    2621. 

  2621.         }
    2622. 

  2622.         $CFG->forced_plugin_settings['mod_forum']['phpunit_test_get_config_4'] = 'test 4';
    2623. 

  2623.         $CFG->phpunit_test_get_config_5 = 'test 5';
    2624. 

  2624. 

  2625.         // Testing.
    2626. 

  2626.         $this->assertSame('test 1', get_config('core', 'phpunit_test_get_config_1'));
    2627. 

  2627.         $this->assertSame('test 2', get_config('mod_forum', 'phpunit_test_get_config_2'));
    2628. 

  2628.         $this->assertSame('test 3', get_config('core', 'phpunit_test_get_config_3'));
    2629. 

  2629.         $this->assertSame('test 4', get_config('mod_forum', 'phpunit_test_get_config_4'));
    2630. 

  2630.         $this->assertFalse(get_config('core', 'phpunit_test_get_config_5'));
    2631. 

  2631.         $this->assertFalse(get_config('core', 'phpunit_test_get_config_x'));
    2632. 

  2632.         $this->assertFalse(get_config('mod_forum', 'phpunit_test_get_config_x'));
    2633. 

  2633. 

  2634.         // Test config we know to exist.
    2635. 

  2635.         $this->assertSame($CFG->dataroot, get_config('core', 'dataroot'));
    2636. 

  2636.         $this->assertSame($CFG->phpunit_dataroot, get_config('core', 'phpunit_dataroot'));
    2637. 

  2637.         $this->assertSame($CFG->dataroot, get_config('core', 'phpunit_dataroot'));
    2638. 

  2638.         $this->assertSame(get_config('core', 'dataroot'), get_config('core', 'phpunit_dataroot'));
    2639. 

  2639. 

  2640.         // Test setting a config var that already exists.
    2641. 

  2641.         set_config('phpunit_test_get_config_1', 'test a');
    2642. 

  2642.         $this->assertSame('test a', $CFG->phpunit_test_get_config_1);
    2643. 

  2643.         $this->assertSame('test a', get_config('core', 'phpunit_test_get_config_1'));
    2644. 

  2644. 

  2645.         // Test cache invalidation.
    2646. 

  2646.         $cache = cache::make('core', 'config');
    2647. 

  2647.         $this->assertInternalType('array', $cache->get('core'));
    2648. 

  2648.         $this->assertInternalType('array', $cache->get('mod_forum'));
    2649. 

  2649.         set_config('phpunit_test_get_config_1', 'test b');
    2650. 

  2650.         $this->assertFalse($cache->get('core'));
    2651. 

  2651.         set_config('phpunit_test_get_config_4', 'test c', 'mod_forum');
    2652. 

  2652.         $this->assertFalse($cache->get('mod_forum'));
    2653. 

  2653.     }
    2654. 

  2654. 

  2655.     public function test_get_max_upload_sizes() {
    2656. 

  2656.         // Test with very low limits so we are not affected by php upload limits.
    2657. 

  2657.         // Test activity limit smallest.
    2658. 

  2658.         $sitebytes = 102400;
    2659. 

  2659.         $coursebytes = 51200;
    2660. 

  2660.         $modulebytes = 10240;
    2661. 

  2661.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes);
    2662. 

  2662. 

  2663.         $this->assertSame('Activity upload limit (10KB)', $result['0']);
    2664. 

  2664.         $this->assertCount(2, $result);
    2665. 

  2665. 

  2666.         // Test course limit smallest.
    2667. 

  2667.         $sitebytes = 102400;
    2668. 

  2668.         $coursebytes = 10240;
    2669. 

  2669.         $modulebytes = 51200;
    2670. 

  2670.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes);
    2671. 

  2671. 

  2672.         $this->assertSame('Course upload limit (10KB)', $result['0']);
    2673. 

  2673.         $this->assertCount(2, $result);
    2674. 

  2674. 

  2675.         // Test site limit smallest.
    2676. 

  2676.         $sitebytes = 10240;
    2677. 

  2677.         $coursebytes = 102400;
    2678. 

  2678.         $modulebytes = 51200;
    2679. 

  2679.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes);
    2680. 

  2680. 

  2681.         $this->assertSame('Site upload limit (10KB)', $result['0']);
    2682. 

  2682.         $this->assertCount(2, $result);
    2683. 

  2683. 

  2684.         // Test site limit not set.
    2685. 

  2685.         $sitebytes = 0;
    2686. 

  2686.         $coursebytes = 102400;
    2687. 

  2687.         $modulebytes = 51200;
    2688. 

  2688.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes);
    2689. 

  2689. 

  2690.         $this->assertSame('Activity upload limit (50KB)', $result['0']);
    2691. 

  2691.         $this->assertCount(3, $result);
    2692. 

  2692. 

  2693.         $sitebytes = 0;
    2694. 

  2694.         $coursebytes = 51200;
    2695. 

  2695.         $modulebytes = 102400;
    2696. 

  2696.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes);
    2697. 

  2697. 

  2698.         $this->assertSame('Course upload limit (50KB)', $result['0']);
    2699. 

  2699.         $this->assertCount(3, $result);
    2700. 

  2700. 

  2701.         // Test custom bytes in range.
    2702. 

  2702.         $sitebytes = 102400;
    2703. 

  2703.         $coursebytes = 51200;
    2704. 

  2704.         $modulebytes = 51200;
    2705. 

  2705.         $custombytes = 10240;
    2706. 

  2706.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes, $custombytes);
    2707. 

  2707. 

  2708.         $this->assertCount(3, $result);
    2709. 

  2709. 

  2710.         // Test custom bytes in range but non-standard.
    2711. 

  2711.         $sitebytes = 102400;
    2712. 

  2712.         $coursebytes = 51200;
    2713. 

  2713.         $modulebytes = 51200;
    2714. 

  2714.         $custombytes = 25600;
    2715. 

  2715.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes, $custombytes);
    2716. 

  2716. 

  2717.         $this->assertCount(4, $result);
    2718. 

  2718. 

  2719.         // Test custom bytes out of range.
    2720. 

  2720.         $sitebytes = 102400;
    2721. 

  2721.         $coursebytes = 51200;
    2722. 

  2722.         $modulebytes = 51200;
    2723. 

  2723.         $custombytes = 102400;
    2724. 

  2724.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes, $custombytes);
    2725. 

  2725. 

  2726.         $this->assertCount(3, $result);
    2727. 

  2727. 

  2728.         // Test custom bytes out of range and non-standard.
    2729. 

  2729.         $sitebytes = 102400;
    2730. 

  2730.         $coursebytes = 51200;
    2731. 

  2731.         $modulebytes = 51200;
    2732. 

  2732.         $custombytes = 256000;
    2733. 

  2733.         $result = get_max_upload_sizes($sitebytes, $coursebytes, $modulebytes, $custombytes);
    2734. 

  2734. 

  2735.         $this->assertCount(3, $result);
    2736. 

  2736. 

  2737.         // Test site limit only.
    2738. 

  2738.         $sitebytes = 51200;
    2739. 

  2739.         $result = get_max_upload_sizes($sitebytes);
    2740. 

  2740. 

  2741.         $this->assertSame('Site upload limit (50KB)', $result['0']);
    2742. 

  2742.         $this->assertSame('50KB', $result['51200']);
    2743. 

  2743.         $this->assertSame('10KB', $result['10240']);
    2744. 

  2744.         $this->assertCount(3, $result);
    2745. 

  2745. 

  2746.         // Test no limit.
    2747. 

  2747.         $result = get_max_upload_sizes();
    2748. 

  2748.         $this->assertArrayHasKey('0', $result);
    2749. 

  2749.         $this->assertArrayHasKey(get_max_upload_file_size(), $result);
    2750. 

  2750.     }
    2751. 

  2751. 

  2752.     /**
    2753. 

  2753.      * Test function password_is_legacy_hash().
    2754. 

  2754.      */
    2755. 

  2755.     public function test_password_is_legacy_hash() {
    2756. 

  2756.         // Well formed md5s should be matched.
    2757. 

  2757.         foreach (array('some', 'strings', 'to_check!') as $string) {
    2758. 

  2758.             $md5 = md5($string);
    2759. 

  2759.             $this->assertTrue(password_is_legacy_hash($md5));
    2760. 

  2760.         }
    2761. 

  2761.         // Strings that are not md5s should not be matched.
    2762. 

  2762.         foreach (array('', AUTH_PASSWORD_NOT_CACHED, 'IPW8WTcsWNgAWcUS1FBVHegzJnw5M2jOmYkmfc8z.xdBOyC4Caeum') as $notmd5) {
    2763. 

  2763.             $this->assertFalse(password_is_legacy_hash($notmd5));
    2764. 

  2764.         }
    2765. 

  2765.     }
    2766. 

  2766. 

  2767.     /**
    2768. 

  2768.      * Test function validate_internal_user_password().
    2769. 

  2769.      */
    2770. 

  2770.     public function test_validate_internal_user_password() {
    2771. 

  2771.         // Test bcrypt hashes.
    2772. 

  2772.         $validhashes = array(
    2773. 

  2773.             'pw' => '$2y$10$LOSDi5eaQJhutSRun.OVJ.ZSxQZabCMay7TO1KmzMkDMPvU40zGXK',
    2774. 

  2774.             'abc' => '$2y$10$VWTOhVdsBbWwtdWNDRHSpewjd3aXBQlBQf5rBY/hVhw8hciarFhXa',
    2775. 

  2775.             'C0mP1eX_&}<?@*&%` |\"' => '$2y$10$3PJf.q.9ywNJlsInPbqc8.IFeSsvXrGvQLKRFBIhVu1h1I3vpIry6',
    2776. 

  2776.             'ĩńťėŕňăţĩōŋāĹ' => '$2y$10$3A2Y8WpfRAnP3czJiSv6N.6Xp0T8hW3QZz2hUCYhzyWr1kGP1yUve'
    2777. 

  2777.         );
    2778. 

  2778. 

  2779.         foreach ($validhashes as $password => $hash) {
    2780. 

  2780.             $user = new stdClass();
    2781. 

  2781.             $user->auth = 'manual';
    2782. 

  2782.             $user->password = $hash;
    2783. 

  2783.             // The correct password should be validated.
    2784. 

  2784.             $this->assertTrue(validate_internal_user_password($user, $password));
    2785. 

  2785.             // An incorrect password should not be validated.
    2786. 

  2786.             $this->assertFalse(validate_internal_user_password($user, 'badpw'));
    2787. 

  2787.         }
    2788. 

  2788.     }
    2789. 

  2789. 

  2790.     /**
    2791. 

  2791.      * Test function hash_internal_user_password().
    2792. 

  2792.      */
    2793. 

  2793.     public function test_hash_internal_user_password() {
    2794. 

  2794.         $passwords = array('pw', 'abc123', 'C0mP1eX_&}<?@*&%` |\"', 'ĩńťėŕňăţĩōŋāĹ');
    2795. 

  2795. 

  2796.         // Check that some passwords that we convert to hashes can
    2797. 

  2797.         // be validated.
    2798. 

  2798.         foreach ($passwords as $password) {
    2799. 

  2799.             $hash = hash_internal_user_password($password);
    2800. 

  2800.             $fasthash = hash_internal_user_password($password, true);
    2801. 

  2801.             $user = new stdClass();
    2802. 

  2802.             $user->auth = 'manual';
    2803. 

  2803.             $user->password = $hash;
    2804. 

  2804.             $this->assertTrue(validate_internal_user_password($user, $password));
    2805. 

  2805. 

  2806.             // They should not be in md5 format.
    2807. 

  2807.             $this->assertFalse(password_is_legacy_hash($hash));
    2808. 

  2808. 

  2809.             // Check that cost factor in hash is correctly set.
    2810. 

  2810.             $this->assertRegExp('/\$10\$/', $hash);
    2811. 

  2811.             $this->assertRegExp('/\$04\$/', $fasthash);
    2812. 

  2812.         }
    2813. 

  2813.     }
    2814. 

  2814. 

  2815.     /**
    2816. 

  2816.      * Test function update_internal_user_password().
    2817. 

  2817.      */
    2818. 

  2818.     public function test_update_internal_user_password() {
    2819. 

  2819.         global $DB;
    2820. 

  2820.         $this->resetAfterTest();
    2821. 

  2821.         $passwords = array('password', '1234', 'changeme', '****');
    2822. 

  2822.         foreach ($passwords as $password) {
    2823. 

  2823.             $user = $this->getDataGenerator()->create_user(array('auth'=>'manual'));
    2824. 

  2824.             update_internal_user_password($user, $password);
    2825. 

  2825.             // The user object should have been updated.
    2826. 

  2826.             $this->assertTrue(validate_internal_user_password($user, $password));
    2827. 

  2827.             // The database field for the user should also have been updated to the
    2828. 

  2828.             // same value.
    2829. 

  2829.             $this->assertSame($user->password, $DB->get_field('user', 'password', array('id' => $user->id)));
    2830. 

  2830.         }
    2831. 

  2831. 

  2832.         $user = $this->getDataGenerator()->create_user(array('auth'=>'manual'));
    2833. 

  2833.         // Manually set the user's password to the md5 of the string 'password'.
    2834. 

  2834.         $DB->set_field('user', 'password', '5f4dcc3b5aa765d61d8327deb882cf99', array('id' => $user->id));
    2835. 

  2835. 

  2836.         $sink = $this->redirectEvents();
    2837. 

  2837.         // Update the password.
    2838. 

  2838.         update_internal_user_password($user, 'password');
    2839. 

  2839.         $events = $sink->get_events();
    2840. 

  2840.         $sink->close();
    2841. 

  2841.         $event = array_pop($events);
    2842. 

  2842. 

  2843.         // Password should have been updated to a bcrypt hash.
    2844. 

  2844.         $this->assertFalse(password_is_legacy_hash($user->password));
    2845. 

  2845. 

  2846.         // Verify event information.
    2847. 

  2847.         $this->assertInstanceOf('\core\event\user_password_updated', $event);
    2848. 

  2848.         $this->assertSame($user->id, $event->relateduserid);
    2849. 

  2849.         $this->assertEquals(context_user::instance($user->id), $event->get_context());
    2850. 

  2850.         $this->assertEventContextNotUsed($event);
    2851. 

  2851. 

  2852.         // Verify recovery of property 'auth'.
    2853. 

  2853.         unset($user->auth);
    2854. 

  2854.         update_internal_user_password($user, 'newpassword');
    2855. 

  2855.         $this->assertDebuggingCalled('User record in update_internal_user_password() must include field auth',
    2856. 

  2856.                 DEBUG_DEVELOPER);
    2857. 

  2857.         $this->assertEquals('manual', $user->auth);
    2858. 

  2858.     }
    2859. 

  2859. 

  2860.     /**
    2861. 

  2861.      * Testing that if the password is not cached, that it does not update
    2862. 

  2862.      * the user table and fire event.
    2863. 

  2863.      */
    2864. 

  2864.     public function test_update_internal_user_password_no_cache() {
    2865. 

  2865.         global $DB;
    2866. 

  2866.         $this->resetAfterTest();
    2867. 

  2867. 

  2868.         $user = $this->getDataGenerator()->create_user(array('auth' => 'cas'));
    2869. 

  2869.         $DB->update_record('user', ['id' => $user->id, 'password' => AUTH_PASSWORD_NOT_CACHED]);
    2870. 

  2870.         $user->password = AUTH_PASSWORD_NOT_CACHED;
    2871. 

  2871. 

  2872.         $sink = $this->redirectEvents();
    2873. 

  2873.         update_internal_user_password($user, 'wonkawonka');
    2874. 

  2874.         $this->assertEquals(0, $sink->count(), 'User updated event should not fire');
    2875. 

  2875.     }
    2876. 

  2876. 

  2877.     /**
    2878. 

  2878.      * Test if the user has a password hash, but now their auth method
    2879. 

  2879.      * says not to cache it.  Then it should update.
    2880. 

  2880.      */
    2881. 

  2881.     public function test_update_internal_user_password_update_no_cache() {
    2882. 

  2882.         $this->resetAfterTest();
    2883. 

  2883. 

  2884.         $user = $this->getDataGenerator()->create_user(array('password' => 'test'));
    2885. 

  2885.         $this->assertNotEquals(AUTH_PASSWORD_NOT_CACHED, $user->password);
    2886. 

  2886.         $user->auth = 'cas'; // Change to a auth that does not store passwords.
    2887. 

  2887. 

  2888.         $sink = $this->redirectEvents();
    2889. 

  2889.         update_internal_user_password($user, 'wonkawonka');
    2890. 

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

  2891. 

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

  2893.     }
    2894. 

  2894. 

  2895.     public function test_fullname() {
    2896. 

  2896.         global $CFG;
    2897. 

  2897. 

  2898.         $this->resetAfterTest();
    2899. 

  2899. 

  2900.         // Create a user to test the name display on.
    2901. 

  2901.         $record = array();
    2902. 

  2902.         $record['firstname'] = 'Scott';
    2903. 

  2903.         $record['lastname'] = 'Fletcher';
    2904. 

  2904.         $record['firstnamephonetic'] = 'スコット';
    2905. 

  2905.         $record['lastnamephonetic'] = 'フレチャー';
    2906. 

  2906.         $record['alternatename'] = 'No friends';
    2907. 

  2907.         $user = $this->getDataGenerator()->create_user($record);
    2908. 

  2908. 

  2909.         // Back up config settings for restore later.
    2910. 

  2910.         $originalcfg = new stdClass();
    2911. 

  2911.         $originalcfg->fullnamedisplay = $CFG->fullnamedisplay;
    2912. 

  2912.         $originalcfg->alternativefullnameformat = $CFG->alternativefullnameformat;
    2913. 

  2913. 

  2914.         // Testing existing fullnamedisplay settings.
    2915. 

  2915.         $CFG->fullnamedisplay = 'firstname';
    2916. 

  2916.         $testname = fullname($user);
    2917. 

  2917.         $this->assertSame($user->firstname, $testname);
    2918. 

  2918. 

  2919.         $CFG->fullnamedisplay = 'firstname lastname';
    2920. 

  2920.         $expectedname = "$user->firstname $user->lastname";
    2921. 

  2921.         $testname = fullname($user);
    2922. 

  2922.         $this->assertSame($expectedname, $testname);
    2923. 

  2923. 

  2924.         $CFG->fullnamedisplay = 'lastname firstname';
    2925. 

  2925.         $expectedname = "$user->lastname $user->firstname";
    2926. 

  2926.         $testname = fullname($user);
    2927. 

  2927.         $this->assertSame($expectedname, $testname);
    2928. 

  2928. 

  2929.         $expectedname = get_string('fullnamedisplay', null, $user);
    2930. 

  2930.         $CFG->fullnamedisplay = 'language';
    2931. 

  2931.         $testname = fullname($user);
    2932. 

  2932.         $this->assertSame($expectedname, $testname);
    2933. 

  2933. 

  2934.         // Test override parameter.
    2935. 

  2935.         $CFG->fullnamedisplay = 'firstname';
    2936. 

  2936.         $expectedname = "$user->firstname $user->lastname";
    2937. 

  2937.         $testname = fullname($user, true);
    2938. 

  2938.         $this->assertSame($expectedname, $testname);
    2939. 

  2939. 

  2940.         // Test alternativefullnameformat setting.
    2941. 

  2941.         // Test alternativefullnameformat that has been set to nothing.
    2942. 

  2942.         $CFG->alternativefullnameformat = '';
    2943. 

  2943.         $expectedname = "$user->firstname $user->lastname";
    2944. 

  2944.         $testname = fullname($user, true);
    2945. 

  2945.         $this->assertSame($expectedname, $testname);
    2946. 

  2946. 

  2947.         // Test alternativefullnameformat that has been set to 'language'.
    2948. 

  2948.         $CFG->alternativefullnameformat = 'language';
    2949. 

  2949.         $expectedname = "$user->firstname $user->lastname";
    2950. 

  2950.         $testname = fullname($user, true);
    2951. 

  2951.         $this->assertSame($expectedname, $testname);
    2952. 

  2952. 

  2953.         // Test customising the alternativefullnameformat setting with all additional name fields.
    2954. 

  2954.         $CFG->alternativefullnameformat = 'firstname lastname firstnamephonetic lastnamephonetic middlename alternatename';
    2955. 

  2955.         $expectedname = "$user->firstname $user->lastname $user->firstnamephonetic $user->lastnamephonetic $user->middlename $user->alternatename";
    2956. 

  2956.         $testname = fullname($user, true);
    2957. 

  2957.         $this->assertSame($expectedname, $testname);
    2958. 

  2958. 

  2959.         // Test additional name fields.
    2960. 

  2960.         $CFG->fullnamedisplay = 'lastname lastnamephonetic firstname firstnamephonetic';
    2961. 

  2961.         $expectedname = "$user->lastname $user->lastnamephonetic $user->firstname $user->firstnamephonetic";
    2962. 

  2962.         $testname = fullname($user);
    2963. 

  2963.         $this->assertSame($expectedname, $testname);
    2964. 

  2964. 

  2965.         // Test for handling missing data.
    2966. 

  2966.         $user->middlename = null;
    2967. 

  2967.         // Parenthesis with no data.
    2968. 

  2968.         $CFG->fullnamedisplay = 'firstname (middlename) lastname';
    2969. 

  2969.         $expectedname = "$user->firstname $user->lastname";
    2970. 

  2970.         $testname = fullname($user);
    2971. 

  2971.         $this->assertSame($expectedname, $testname);
    2972. 

  2972. 

  2973.         // Extra spaces due to no data.
    2974. 

  2974.         $CFG->fullnamedisplay = 'firstname middlename lastname';
    2975. 

  2975.         $expectedname = "$user->firstname $user->lastname";
    2976. 

  2976.         $testname = fullname($user);
    2977. 

  2977.         $this->assertSame($expectedname, $testname);
    2978. 

  2978. 

  2979.         // Regular expression testing.
    2980. 

  2980.         // Remove some data from the user fields.
    2981. 

  2981.         $user->firstnamephonetic = '';
    2982. 

  2982.         $user->lastnamephonetic = '';
    2983. 

  2983. 

  2984.         // Removing empty brackets and excess whitespace.
    2985. 

  2985.         // All of these configurations should resolve to just firstname lastname.
    2986. 

  2986.         $configarray = array();
    2987. 

  2987.         $configarray[] = 'firstname lastname [firstnamephonetic lastnamephonetic]';
    2988. 

  2988.         $configarray[] = 'firstname lastname \'middlename\'';
    2989. 

  2989.         $configarray[] = 'firstname "firstnamephonetic" lastname';
    2990. 

  2990.         $configarray[] = 'firstname 「firstnamephonetic」 lastname 「lastnamephonetic」';
    2991. 

  2991. 

  2992.         foreach ($configarray as $config) {
    2993. 

  2993.             $CFG->fullnamedisplay = $config;
    2994. 

  2994.             $expectedname = "$user->firstname $user->lastname";
    2995. 

  2995.             $testname = fullname($user);
    2996. 

  2996.             $this->assertSame($expectedname, $testname);
    2997. 

  2997.         }
    2998. 

  2998. 

  2999.         // Check to make sure that other characters are left in place.
    3000. 

  3000.         $configarray = array();
    3001. 

  3001.         $configarray['0'] = new stdClass();
    3002. 

  3002.         $configarray['0']->config = 'lastname firstname, middlename';
    3003. 

  3003.         $configarray['0']->expectedname = "$user->lastname $user->firstname,";
    3004. 

  3004.         $configarray['1'] = new stdClass();
    3005. 

  3005.         $configarray['1']->config = 'lastname firstname + alternatename';
    3006. 

  3006.         $configarray['1']->expectedname = "$user->lastname $user->firstname + $user->alternatename";
    3007. 

  3007.         $configarray['2'] = new stdClass();
    3008. 

  3008.         $configarray['2']->config = 'firstname aka: alternatename';
    3009. 

  3009.         $configarray['2']->expectedname = "$user->firstname aka: $user->alternatename";
    3010. 

  3010.         $configarray['3'] = new stdClass();
    3011. 

  3011.         $configarray['3']->config = 'firstname (alternatename)';
    3012. 

  3012.         $configarray['3']->expectedname = "$user->firstname ($user->alternatename)";
    3013. 

  3013.         $configarray['4'] = new stdClass();
    3014. 

  3014.         $configarray['4']->config = 'firstname [alternatename]';
    3015. 

  3015.         $configarray['4']->expectedname = "$user->firstname [$user->alternatename]";
    3016. 

  3016.         $configarray['5'] = new stdClass();
    3017. 

  3017.         $configarray['5']->config = 'firstname "lastname"';
    3018. 

  3018.         $configarray['5']->expectedname = "$user->firstname \"$user->lastname\"";
    3019. 

  3019. 

  3020.         foreach ($configarray as $config) {
    3021. 

  3021.             $CFG->fullnamedisplay = $config->config;
    3022. 

  3022.             $expectedname = $config->expectedname;
    3023. 

  3023.             $testname = fullname($user);
    3024. 

  3024.             $this->assertSame($expectedname, $testname);
    3025. 

  3025.         }
    3026. 

  3026. 

  3027.         // Test debugging message displays when
    3028. 

  3028.         // fullnamedisplay setting is "normal".
    3029. 

  3029.         $CFG->fullnamedisplay = 'firstname lastname';
    3030. 

  3030.         unset($user);
    3031. 

  3031.         $user = new stdClass();
    3032. 

  3032.         $user->firstname = 'Stan';
    3033. 

  3033.         $user->lastname = 'Lee';
    3034. 

  3034.         $namedisplay = fullname($user);
    3035. 

  3035.         $this->assertDebuggingCalled();
    3036. 

  3036. 

  3037.         // Tidy up after we finish testing.
    3038. 

  3038.         $CFG->fullnamedisplay = $originalcfg->fullnamedisplay;
    3039. 

  3039.         $CFG->alternativefullnameformat = $originalcfg->alternativefullnameformat;
    3040. 

  3040.     }
    3041. 

  3041. 

  3042.     public function test_get_all_user_name_fields() {
    3043. 

  3043.         $this->resetAfterTest();
    3044. 

  3044. 

  3045.         // Additional names in an array.
    3046. 

  3046.         $testarray = array('firstnamephonetic' => 'firstnamephonetic',
    3047. 

  3047.                 'lastnamephonetic' => 'lastnamephonetic',
    3048. 

  3048.                 'middlename' => 'middlename',
    3049. 

  3049.                 'alternatename' => 'alternatename',
    3050. 

  3050.                 'firstname' => 'firstname',
    3051. 

  3051.                 'lastname' => 'lastname');
    3052. 

  3052.         $this->assertEquals($testarray, get_all_user_name_fields());
    3053. 

  3053. 

  3054.         // Additional names as a string.
    3055. 

  3055.         $teststring = 'firstnamephonetic,lastnamephonetic,middlename,alternatename,firstname,lastname';
    3056. 

  3056.         $this->assertEquals($teststring, get_all_user_name_fields(true));
    3057. 

  3057. 

  3058.         // Additional names as a string with an alias.
    3059. 

  3059.         $teststring = 't.firstnamephonetic,t.lastnamephonetic,t.middlename,t.alternatename,t.firstname,t.lastname';
    3060. 

  3060.         $this->assertEquals($teststring, get_all_user_name_fields(true, 't'));
    3061. 

  3061. 

  3062.         // Additional name fields with a prefix - object.
    3063. 

  3063.         $testarray = array('firstnamephonetic' => 'authorfirstnamephonetic',
    3064. 

  3064.                 'lastnamephonetic' => 'authorlastnamephonetic',
    3065. 

  3065.                 'middlename' => 'authormiddlename',
    3066. 

  3066.                 'alternatename' => 'authoralternatename',
    3067. 

  3067.                 'firstname' => 'authorfirstname',
    3068. 

  3068.                 'lastname' => 'authorlastname');
    3069. 

  3069.         $this->assertEquals($testarray, get_all_user_name_fields(false, null, 'author'));
    3070. 

  3070. 

  3071.         // Additional name fields with an alias and a title - string.
    3072. 

  3072.         $teststring = 'u.firstnamephonetic AS authorfirstnamephonetic,u.lastnamephonetic AS authorlastnamephonetic,u.middlename AS authormiddlename,u.alternatename AS authoralternatename,u.firstname AS authorfirstname,u.lastname AS authorlastname';
    3073. 

  3073.         $this->assertEquals($teststring, get_all_user_name_fields(true, 'u', null, 'author'));
    3074. 

  3074. 

  3075.         // Test the order parameter of the function.
    3076. 

  3076.         // Returning an array.
    3077. 

  3077.         $testarray = array('firstname' => 'firstname',
    3078. 

  3078.                 'lastname' => 'lastname',
    3079. 

  3079.                 'firstnamephonetic' => 'firstnamephonetic',
    3080. 

  3080.                 'lastnamephonetic' => 'lastnamephonetic',
    3081. 

  3081.                 'middlename' => 'middlename',
    3082. 

  3082.                 'alternatename' => 'alternatename'
    3083. 

  3083.         );
    3084. 

  3084.         $this->assertEquals($testarray, get_all_user_name_fields(false, null, null, null, true));
    3085. 

  3085. 

  3086.         // Returning a string.
    3087. 

  3087.         $teststring = 'firstname,lastname,firstnamephonetic,lastnamephonetic,middlename,alternatename';
    3088. 

  3088.         $this->assertEquals($teststring, get_all_user_name_fields(true, null, null, null, true));
    3089. 

  3089.     }
    3090. 

  3090. 

  3091.     public function test_order_in_string() {
    3092. 

  3092.         $this->resetAfterTest();
    3093. 

  3093. 

  3094.         // Return an array in an order as they are encountered in a string.
    3095. 

  3095.         $valuearray = array('second', 'firsthalf', 'first');
    3096. 

  3096.         $formatstring = 'first firsthalf some other text (second)';
    3097. 

  3097.         $expectedarray = array('0' => 'first', '6' => 'firsthalf', '33' => 'second');
    3098. 

  3098.         $this->assertEquals($expectedarray, order_in_string($valuearray, $formatstring));
    3099. 

  3099. 

  3100.         // Try again with a different order for the format.
    3101. 

  3101.         $valuearray = array('second', 'firsthalf', 'first');
    3102. 

  3102.         $formatstring = 'firsthalf first second';
    3103. 

  3103.         $expectedarray = array('0' => 'firsthalf', '10' => 'first', '16' => 'second');
    3104. 

  3104.         $this->assertEquals($expectedarray, order_in_string($valuearray, $formatstring));
    3105. 

  3105. 

  3106.         // Try again with yet another different order for the format.
    3107. 

  3107.         $valuearray = array('second', 'firsthalf', 'first');
    3108. 

  3108.         $formatstring = 'start seconds away second firstquater first firsthalf';
    3109. 

  3109.         $expectedarray = array('19' => 'second', '38' => 'first', '44' => 'firsthalf');
    3110. 

  3110.         $this->assertEquals($expectedarray, order_in_string($valuearray, $formatstring));
    3111. 

  3111.     }
    3112. 

  3112. 

  3113.     public function test_complete_user_login() {
    3114. 

  3114.         global $USER, $DB;
    3115. 

  3115. 

  3116.         $this->resetAfterTest();
    3117. 

  3117.         $user = $this->getDataGenerator()->create_user();
    3118. 

  3118.         $this->setUser(0);
    3119. 

  3119. 

  3120.         $sink = $this->redirectEvents();
    3121. 

  3121.         $loginuser = clone($user);
    3122. 

  3122.         $this->setCurrentTimeStart();
    3123. 

  3123.         @complete_user_login($loginuser); // Hide session header errors.
    3124. 

  3124.         $this->assertSame($loginuser, $USER);
    3125. 

  3125.         $this->assertEquals($user->id, $USER->id);
    3126. 

  3126.         $events = $sink->get_events();
    3127. 

  3127.         $sink->close();
    3128. 

  3128. 

  3129.         $this->assertCount(1, $events);
    3130. 

  3130.         $event = reset($events);
    3131. 

  3131.         $this->assertInstanceOf('\core\event\user_loggedin', $event);
    3132. 

  3132.         $this->assertEquals('user', $event->objecttable);
    3133. 

  3133.         $this->assertEquals($user->id, $event->objectid);
    3134. 

  3134.         $this->assertEquals(context_system::instance()->id, $event->contextid);
    3135. 

  3135.         $this->assertEventContextNotUsed($event);
    3136. 

  3136. 

  3137.         $user = $DB->get_record('user', array('id'=>$user->id));
    3138. 

  3138. 

  3139.         $this->assertTimeCurrent($user->firstaccess);
    3140. 

  3140.         $this->assertTimeCurrent($user->lastaccess);
    3141. 

  3141. 

  3142.         $this->assertTimeCurrent($USER->firstaccess);
    3143. 

  3143.         $this->assertTimeCurrent($USER->lastaccess);
    3144. 

  3144.         $this->assertTimeCurrent($USER->currentlogin);
    3145. 

  3145.         $this->assertSame(sesskey(), $USER->sesskey);
    3146. 

  3146.         $this->assertTimeCurrent($USER->preference['_lastloaded']);
    3147. 

  3147.         $this->assertObjectNotHasAttribute('password', $USER);
    3148. 

  3148.         $this->assertObjectNotHasAttribute('description', $USER);
    3149. 

  3149.     }
    3150. 

  3150. 

  3151.     /**
    3152. 

  3152.      * Test require_logout.
    3153. 

  3153.      */
    3154. 

  3154.     public function test_require_logout() {
    3155. 

  3155.         $this->resetAfterTest();
    3156. 

  3156.         $user = $this->getDataGenerator()->create_user();
    3157. 

  3157.         $this->setUser($user);
    3158. 

  3158. 

  3159.         $this->assertTrue(isloggedin());
    3160. 

  3160. 

  3161.         // Logout user and capture event.
    3162. 

  3162.         $sink = $this->redirectEvents();
    3163. 

  3163.         require_logout();
    3164. 

  3164.         $events = $sink->get_events();
    3165. 

  3165.         $sink->close();
    3166. 

  3166.         $event = array_pop($events);
    3167. 

  3167. 

  3168.         // Check if user is logged out.
    3169. 

  3169.         $this->assertFalse(isloggedin());
    3170. 

  3170. 

  3171.         // Test Event.
    3172. 

  3172.         $this->assertInstanceOf('\core\event\user_loggedout', $event);
    3173. 

  3173.         $this->assertSame($user->id, $event->objectid);
    3174. 

  3174.         $this->assertSame('user_logout', $event->get_legacy_eventname());
    3175. 

  3175.         $this->assertEventLegacyData($user, $event);
    3176. 

  3176.         $expectedlogdata = array(SITEID, 'user', 'logout', 'view.php?id='.$event->objectid.'&course='.SITEID, $event->objectid, 0,
    3177. 

  3177.             $event->objectid);
    3178. 

  3178.         $this->assertEventLegacyLogData($expectedlogdata, $event);
    3179. 

  3179.         $this->assertEventContextNotUsed($event);
    3180. 

  3180.     }
    3181. 

  3181. 

  3182.     /**
    3183. 

  3183.      * A data provider for testing email messageid
    3184. 

  3184.      */
    3185. 

  3185.     public function generate_email_messageid_provider() {
    3186. 

  3186.         return array(
    3187. 

  3187.             'nopath' => array(
    3188. 

  3188.                 'wwwroot' => 'http://www.example.com',
    3189. 

  3189.                 'ids' => array(
    3190. 

  3190.                     'a-custom-id' => '<a-custom-id@www.example.com>',
    3191. 

  3191.                     'an-id-with-/-a-slash' => '<an-id-with-%2F-a-slash@www.example.com>',
    3192. 

  3192.                 ),
    3193. 

  3193.             ),
    3194. 

  3194.             'path' => array(
    3195. 

  3195.                 'wwwroot' => 'http://www.example.com/path/subdir',
    3196. 

  3196.                 'ids' => array(
    3197. 

  3197.                     'a-custom-id' => '<a-custom-id/path/subdir@www.example.com>',
    3198. 

  3198.                     'an-id-with-/-a-slash' => '<an-id-with-%2F-a-slash/path/subdir@www.example.com>',
    3199. 

  3199.                 ),
    3200. 

  3200.             ),
    3201. 

  3201.         );
    3202. 

  3202.     }
    3203. 

  3203. 

  3204.     /**
    3205. 

  3205.      * Test email message id generation
    3206. 

  3206.      *
    3207. 

  3207.      * @dataProvider generate_email_messageid_provider
    3208. 

  3208.      *
    3209. 

  3209.      * @param string $wwwroot The wwwroot
    3210. 

  3210.      * @param array $msgids An array of msgid local parts and the final result
    3211. 

  3211.      */
    3212. 

  3212.     public function test_generate_email_messageid($wwwroot, $msgids) {
    3213. 

  3213.         global $CFG;
    3214. 

  3214. 

  3215.         $this->resetAfterTest();
    3216. 

  3216.         $CFG->wwwroot = $wwwroot;
    3217. 

  3217. 

  3218.         foreach ($msgids as $local => $final) {
    3219. 

  3219.             $this->assertEquals($final, generate_email_messageid($local));
    3220. 

  3220.         }
    3221. 

  3221.     }
    3222. 

  3222. 

  3223.     /**
    3224. 

  3224.      * A data provider for testing email diversion
    3225. 

  3225.      */
    3226. 

  3226.     public function diverted_emails_provider() {
    3227. 

  3227.         return array(
    3228. 

  3228.             'nodiverts' => array(
    3229. 

  3229.                 'divertallemailsto' => null,
    3230. 

  3230.                 'divertallemailsexcept' => null,
    3231. 

  3231.                 array(
    3232. 

  3232.                     'foo@example.com',
    3233. 

  3233.                     'test@real.com',
    3234. 

  3234.                     'fred.jones@example.com',
    3235. 

  3235.                     'dev1@dev.com',
    3236. 

  3236.                     'fred@example.com',
    3237. 

  3237.                     'fred+verp@example.com',
    3238. 

  3238.                 ),
    3239. 

  3239.                 false,
    3240. 

  3240.             ),
    3241. 

  3241.             'alldiverts' => array(
    3242. 

  3242.                 'divertallemailsto' => 'somewhere@elsewhere.com',
    3243. 

  3243.                 'divertallemailsexcept' => null,
    3244. 

  3244.                 array(
    3245. 

  3245.                     'foo@example.com',
    3246. 

  3246.                     'test@real.com',
    3247. 

  3247.                     'fred.jones@example.com',
    3248. 

  3248.                     'dev1@dev.com',
    3249. 

  3249.                     'fred@example.com',
    3250. 

  3250.                     'fred+verp@example.com',
    3251. 

  3251.                 ),
    3252. 

  3252.                 true,
    3253. 

  3253.             ),
    3254. 

  3254.             'alsodiverts' => array(
    3255. 

  3255.                 'divertallemailsto' => 'somewhere@elsewhere.com',
    3256. 

  3256.                 'divertallemailsexcept' => '@dev.com, fred(\+.*)?@example.com',
    3257. 

  3257.                 array(
    3258. 

  3258.                     'foo@example.com',
    3259. 

  3259.                     'test@real.com',
    3260. 

  3260.                     'fred.jones@example.com',
    3261. 

  3261.                 ),
    3262. 

  3262.                 true,
    3263. 

  3263.             ),
    3264. 

  3264.             'divertsexceptions' => array(
    3265. 

  3265.                 'divertallemailsto' => 'somewhere@elsewhere.com',
    3266. 

  3266.                 'divertallemailsexcept' => '@dev.com, fred(\+.*)?@example.com',
    3267. 

  3267.                 array(
    3268. 

  3268.                     'dev1@dev.com',
    3269. 

  3269.                     'fred@example.com',
    3270. 

  3270.                     'fred+verp@example.com',
    3271. 

  3271.                 ),
    3272. 

  3272.                 false,
    3273. 

  3273.             ),
    3274. 

  3274.         );
    3275. 

  3275.     }
    3276. 

  3276. 

  3277.     /**
    3278. 

  3278.      * Test email diversion
    3279. 

  3279.      *
    3280. 

  3280.      * @dataProvider diverted_emails_provider
    3281. 

  3281.      *
    3282. 

  3282.      * @param string $divertallemailsto An optional email address
    3283. 

  3283.      * @param string $divertallemailsexcept An optional exclusion list
    3284. 

  3284.      * @param array $addresses An array of test addresses
    3285. 

  3285.      * @param boolean $expected Expected result
    3286. 

  3286.      */
    3287. 

  3287.     public function test_email_should_be_diverted($divertallemailsto, $divertallemailsexcept, $addresses, $expected) {
    3288. 

  3288.         global $CFG;
    3289. 

  3289. 

  3290.         $this->resetAfterTest();
    3291. 

  3291.         $CFG->divertallemailsto = $divertallemailsto;
    3292. 

  3292.         $CFG->divertallemailsexcept = $divertallemailsexcept;
    3293. 

  3293. 

  3294.         foreach ($addresses as $address) {
    3295. 

  3295.             $this->assertEquals($expected, email_should_be_diverted($address));
    3296. 

  3296.         }
    3297. 

  3297.     }
    3298. 

  3298. 

  3299.     public function test_email_to_user() {
    3300. 

  3300.         global $CFG;
    3301. 

  3301. 

  3302.         $this->resetAfterTest();
    3303. 

  3303. 

  3304.         $user1 = $this->getDataGenerator()->create_user(array('maildisplay' => 1, 'mailformat' => 0));
    3305. 

  3305.         $user2 = $this->getDataGenerator()->create_user(array('maildisplay' => 1, 'mailformat' => 1));
    3306. 

  3306.         $user3 = $this->getDataGenerator()->create_user(array('maildisplay' => 0));
    3307. 

  3307.         set_config('allowedemaildomains', "example.com\r\nmoodle.org");
    3308. 

  3308. 

  3309.         $subject = 'subject';
    3310. 

  3310.         $messagetext = 'message text';
    3311. 

  3311.         $subject2 = 'subject 2';
    3312. 

  3312.         $messagetext2 = '<b>message text 2</b>';
    3313. 

  3313. 

  3314.         // Close the default email sink.
    3315. 

  3315.         $sink = $this->redirectEmails();
    3316. 

  3316.         $sink->close();
    3317. 

  3317. 

  3318.         $CFG->noemailever = true;
    3319. 

  3319.         $this->assertNotEmpty($CFG->noemailever);
    3320. 

  3320.         email_to_user($user1, $user2, $subject, $messagetext);
    3321. 

  3321.         $this->assertDebuggingCalled('Not sending email due to $CFG->noemailever config setting');
    3322. 

  3322. 

  3323.         unset_config('noemailever');
    3324. 

  3324. 

  3325.         email_to_user($user1, $user2, $subject, $messagetext);
    3326. 

  3326.         $this->assertDebuggingCalled('Unit tests must not send real emails! Use $this->redirectEmails()');
    3327. 

  3327. 

  3328.         $sink = $this->redirectEmails();
    3329. 

  3329.         email_to_user($user1, $user2, $subject, $messagetext);
    3330. 

  3330.         email_to_user($user2, $user1, $subject2, $messagetext2);
    3331. 

  3331.         $this->assertSame(2, $sink->count());
    3332. 

  3332.         $result = $sink->get_messages();
    3333. 

  3333.         $this->assertCount(2, $result);
    3334. 

  3334.         $sink->close();
    3335. 

  3335. 

  3336.         $this->assertSame($subject, $result[0]->subject);
    3337. 

  3337.         $this->assertSame($messagetext, trim($result[0]->body));
    3338. 

  3338.         $this->assertSame($user1->email, $result[0]->to);
    3339. 

  3339.         $this->assertSame($user2->email, $result[0]->from);
    3340. 

  3340.         $this->assertContains('Content-Type: text/plain', $result[0]->header);
    3341. 

  3341. 

  3342.         $this->assertSame($subject2, $result[1]->subject);
    3343. 

  3343.         $this->assertContains($messagetext2, quoted_printable_decode($result[1]->body));
    3344. 

  3344.         $this->assertSame($user2->email, $result[1]->to);
    3345. 

  3345.         $this->assertSame($user1->email, $result[1]->from);
    3346. 

  3346.         $this->assertNotContains('Content-Type: text/plain', $result[1]->header);
    3347. 

  3347. 

  3348.         email_to_user($user1, $user2, $subject, $messagetext);
    3349. 

  3349.         $this->assertDebuggingCalled('Unit tests must not send real emails! Use $this->redirectEmails()');
    3350. 

  3350. 

  3351.         // Test that an empty noreplyaddress will default to a no-reply address.
    3352. 

  3352.         $sink = $this->redirectEmails();
    3353. 

  3353.         email_to_user($user1, $user3, $subject, $messagetext);
    3354. 

  3354.         $result = $sink->get_messages();
    3355. 

  3355.         $this->assertEquals($CFG->noreplyaddress, $result[0]->from);
    3356. 

  3356.         $sink->close();
    3357. 

  3357.         set_config('noreplyaddress', '');
    3358. 

  3358.         $sink = $this->redirectEmails();
    3359. 

  3359.         email_to_user($user1, $user3, $subject, $messagetext);
    3360. 

  3360.         $result = $sink->get_messages();
    3361. 

  3361.         $this->assertEquals('noreply@www.example.com', $result[0]->from);
    3362. 

  3362.         $sink->close();
    3363. 

  3363. 

  3364.         // Test $CFG->allowedemaildomains.
    3365. 

  3365.         set_config('noreplyaddress', 'noreply@www.example.com');
    3366. 

  3366.         $this->assertNotEmpty($CFG->allowedemaildomains);
    3367. 

  3367.         $sink = $this->redirectEmails();
    3368. 

  3368.         email_to_user($user1, $user2, $subject, $messagetext);
    3369. 

  3369.         unset_config('allowedemaildomains');
    3370. 

  3370.         email_to_user($user1, $user2, $subject, $messagetext);
    3371. 

  3371.         $result = $sink->get_messages();
    3372. 

  3372.         $this->assertNotEquals($CFG->noreplyaddress, $result[0]->from);
    3373. 

  3373.         $this->assertEquals($CFG->noreplyaddress, $result[1]->from);
    3374. 

  3374.         $sink->close();
    3375. 

  3375. 

  3376.         // Try to send an unsafe attachment, we should see an error message in the eventual mail body.
    3377. 

  3377.         $attachment = '../test.txt';
    3378. 

  3378.         $attachname = 'txt';
    3379. 

  3379. 

  3380.         $sink = $this->redirectEmails();
    3381. 

  3381.         email_to_user($user1, $user2, $subject, $messagetext, '', $attachment, $attachname);
    3382. 

  3382.         $this->assertSame(1, $sink->count());
    3383. 

  3383.         $result = $sink->get_messages();
    3384. 

  3384.         $this->assertCount(1, $result);
    3385. 

  3385.         $this->assertContains('error.txt', $result[0]->body);
    3386. 

  3386.         $this->assertContains('Error in attachment.  User attempted to attach a filename with a unsafe name.', $result[0]->body);
    3387. 

  3387.         $sink->close();
    3388. 

  3388.     }
    3389. 

  3389. 

  3390.     /**
    3391. 

  3391.      * Data provider for {@see test_email_to_user_attachment}
    3392. 

  3392.      *
    3393. 

  3393.      * @return array
    3394. 

  3394.      */
    3395. 

  3395.     public function email_to_user_attachment_provider(): array {
    3396. 

  3396.         global $CFG;
    3397. 

  3397. 

  3398.         // Return all paths that can be used to send attachments from.
    3399. 

  3399.         return [
    3400. 

  3400.             'cachedir' => [$CFG->cachedir],
    3401. 

  3401.             'dataroot' => [$CFG->dataroot],
    3402. 

  3402.             'dirroot' => [$CFG->dirroot],
    3403. 

  3403.             'localcachedir' => [$CFG->localcachedir],
    3404. 

  3404.             'tempdir' => [$CFG->tempdir],
    3405. 

  3405.             // Pass null to indicate we want to test a path relative to $CFG->dataroot.
    3406. 

  3406.             'relative' => [null]
    3407. 

  3407.         ];
    3408. 

  3408.     }
    3409. 

  3409. 

  3410.     /**
    3411. 

  3411.      * Test sending attachments with email_to_user
    3412. 

  3412.      *
    3413. 

  3413.      * @param string|null $filedir
    3414. 

  3414.      *
    3415. 

  3415.      * @dataProvider email_to_user_attachment_provider
    3416. 

  3416.      */
    3417. 

  3417.     public function test_email_to_user_attachment(?string $filedir): void {
    3418. 

  3418.         global $CFG;
    3419. 

  3419. 

  3420.         // If $filedir is null, then write our test file to $CFG->dataroot.
    3421. 

  3421.         $filepath = ($filedir ?: $CFG->dataroot) . '/hello.txt';
    3422. 

  3422.         file_put_contents($filepath, 'Hello');
    3423. 

  3423. 

  3424.         $user = core_user::get_support_user();
    3425. 

  3425.         $message = 'Test attachment path';
    3426. 

  3426. 

  3427.         // Create sink to catch all sent e-mails.
    3428. 

  3428.         $sink = $this->redirectEmails();
    3429. 

  3429. 

  3430.         // Attachment path will be that of the test file if $filedir was passed, otherwise the relative path from $CFG->dataroot.
    3431. 

  3431.         $filename = basename($filepath);
    3432. 

  3432.         $attachmentpath = $filedir ? $filepath : $filename;
    3433. 

  3433.         email_to_user($user, $user, $message, $message, $message, $attachmentpath, $filename);
    3434. 

  3434. 

  3435.         $messages = $sink->get_messages();
    3436. 

  3436.         $sink->close();
    3437. 

  3437. 

  3438.         $this->assertCount(1, $messages);
    3439. 

  3439. 

  3440.         // Verify attachment in message body (attachment is in MIME format, but we can detect some Content fields).
    3441. 

  3441.         $messagebody = reset($messages)->body;
    3442. 

  3442.         $this->assertContains('Content-Type: text/plain; name="' . $filename . '"', $messagebody);
    3443. 

  3443.         $this->assertContains('Content-Disposition: attachment; filename=' . $filename, $messagebody);
    3444. 

  3444. 

  3445.         // Cleanup.
    3446. 

  3446.         unlink($filepath);
    3447. 

  3447.     }
    3448. 

  3448. 

  3449.     /**
    3450. 

  3450.      * Test sending an attachment that doesn't exist to email_to_user
    3451. 

  3451.      */
    3452. 

  3452.     public function test_email_to_user_attachment_missing(): void {
    3453. 

  3453.         $user = core_user::get_support_user();
    3454. 

  3454.         $message = 'Test attachment path';
    3455. 

  3455. 

  3456.         // Create sink to catch all sent e-mails.
    3457. 

  3457.         $sink = $this->redirectEmails();
    3458. 

  3458. 

  3459.         $attachmentpath = '/hola/hello.txt';
    3460. 

  3460.         $filename = basename($attachmentpath);
    3461. 

  3461.         email_to_user($user, $user, $message, $message, $message, $attachmentpath, $filename);
    3462. 

  3462. 

  3463.         $messages = $sink->get_messages();
    3464. 

  3464.         $sink->close();
    3465. 

  3465. 

  3466.         $this->assertCount(1, $messages);
    3467. 

  3467. 

  3468.         // Verify attachment not in message body (attachment is in MIME format, but we can detect some Content fields).
    3469. 

  3469.         $messagebody = reset($messages)->body;
    3470. 

  3470.         $this->assertNotContains('Content-Type: text/plain; name="' . $filename . '"', $messagebody);
    3471. 

  3471.         $this->assertNotContains('Content-Disposition: attachment; filename=' . $filename, $messagebody);
    3472. 

  3472.     }
    3473. 

  3473. 

  3474.     /**
    3475. 

  3475.      * Test setnew_password_and_mail.
    3476. 

  3476.      */
    3477. 

  3477.     public function test_setnew_password_and_mail() {
    3478. 

  3478.         global $DB, $CFG;
    3479. 

  3479. 

  3480.         $this->resetAfterTest();
    3481. 

  3481. 

  3482.         $user = $this->getDataGenerator()->create_user();
    3483. 

  3483. 

  3484.         // Update user password.
    3485. 

  3485.         $sink = $this->redirectEvents();
    3486. 

  3486.         $sink2 = $this->redirectEmails(); // Make sure we are redirecting emails.
    3487. 

  3487.         setnew_password_and_mail($user);
    3488. 

  3488.         $events = $sink->get_events();
    3489. 

  3489.         $sink->close();
    3490. 

  3490.         $sink2->close();
    3491. 

  3491.         $event = array_pop($events);
    3492. 

  3492. 

  3493.         // Test updated value.
    3494. 

  3494.         $dbuser = $DB->get_record('user', array('id' => $user->id));
    3495. 

  3495.         $this->assertSame($user->firstname, $dbuser->firstname);
    3496. 

  3496.         $this->assertNotEmpty($dbuser->password);
    3497. 

  3497. 

  3498.         // Test event.
    3499. 

  3499.         $this->assertInstanceOf('\core\event\user_password_updated', $event);
    3500. 

  3500.         $this->assertSame($user->id, $event->relateduserid);
    3501. 

  3501.         $this->assertEquals(context_user::instance($user->id), $event->get_context());
    3502. 

  3502.         $this->assertEventContextNotUsed($event);
    3503. 

  3503.     }
    3504. 

  3504. 

  3505.     /**
    3506. 

  3506.      * Data provider for test_generate_confirmation_link
    3507. 

  3507.      * @return Array of confirmation urls and expected resultant confirmation links
    3508. 

  3508.      */
    3509. 

  3509.     public function generate_confirmation_link_provider() {
    3510. 

  3510.         global $CFG;
    3511. 

  3511.         return [
    3512. 

  3512.             "Simple name" => [
    3513. 

  3513.                 "username" => "simplename",
    3514. 

  3514.                 "confirmationurl" => null,
    3515. 

  3515.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/simplename"
    3516. 

  3516.             ],
    3517. 

  3517.             "Period in between words in username" => [
    3518. 

  3518.                 "username" => "period.inbetween",
    3519. 

  3519.                 "confirmationurl" => null,
    3520. 

  3520.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/period%2Einbetween"
    3521. 

  3521.             ],
    3522. 

  3522.             "Trailing periods in username" => [
    3523. 

  3523.                 "username" => "trailingperiods...",
    3524. 

  3524.                 "confirmationurl" => null,
    3525. 

  3525.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/trailingperiods%2E%2E%2E"
    3526. 

  3526.             ],
    3527. 

  3527.             "At symbol in username" => [
    3528. 

  3528.                 "username" => "at@symbol",
    3529. 

  3529.                 "confirmationurl" => null,
    3530. 

  3530.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/at%40symbol"
    3531. 

  3531.             ],
    3532. 

  3532.             "Dash symbol in username" => [
    3533. 

  3533.                 "username" => "has-dash",
    3534. 

  3534.                 "confirmationurl" => null,
    3535. 

  3535.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/has-dash"
    3536. 

  3536.             ],
    3537. 

  3537.             "Underscore in username" => [
    3538. 

  3538.                 "username" => "under_score",
    3539. 

  3539.                 "confirmationurl" => null,
    3540. 

  3540.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/under_score"
    3541. 

  3541.             ],
    3542. 

  3542.             "Many different characters in username" => [
    3543. 

  3543.                 "username" => "many_-.@characters@_@-..-..",
    3544. 

  3544.                 "confirmationurl" => null,
    3545. 

  3545.                 "expected" => $CFG->wwwroot . "/login/confirm.php?data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3546. 

  3546.             ],
    3547. 

  3547.             "Custom relative confirmation url" => [
    3548. 

  3548.                 "username" => "many_-.@characters@_@-..-..",
    3549. 

  3549.                 "confirmationurl" => "/custom/local/url.php",
    3550. 

  3550.                 "expected" => $CFG->wwwroot . "/custom/local/url.php?data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3551. 

  3551.             ],
    3552. 

  3552.             "Custom relative confirmation url with parameters" => [
    3553. 

  3553.                 "username" => "many_-.@characters@_@-..-..",
    3554. 

  3554.                 "confirmationurl" => "/custom/local/url.php?with=param",
    3555. 

  3555.                 "expected" => $CFG->wwwroot . "/custom/local/url.php?with=param&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3556. 

  3556.             ],
    3557. 

  3557.             "Custom local confirmation url" => [
    3558. 

  3558.                 "username" => "many_-.@characters@_@-..-..",
    3559. 

  3559.                 "confirmationurl" => $CFG->wwwroot . "/custom/local/url.php",
    3560. 

  3560.                 "expected" => $CFG->wwwroot . "/custom/local/url.php?data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3561. 

  3561.             ],
    3562. 

  3562.             "Custom local confirmation url with parameters" => [
    3563. 

  3563.                 "username" => "many_-.@characters@_@-..-..",
    3564. 

  3564.                 "confirmationurl" => $CFG->wwwroot . "/custom/local/url.php?with=param",
    3565. 

  3565.                 "expected" => $CFG->wwwroot . "/custom/local/url.php?with=param&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3566. 

  3566.             ],
    3567. 

  3567.             "Custom external confirmation url" => [
    3568. 

  3568.                 "username" => "many_-.@characters@_@-..-..",
    3569. 

  3569.                 "confirmationurl" => "http://moodle.org/custom/external/url.php",
    3570. 

  3570.                 "expected" => "http://moodle.org/custom/external/url.php?data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3571. 

  3571.             ],
    3572. 

  3572.             "Custom external confirmation url with parameters" => [
    3573. 

  3573.                 "username" => "many_-.@characters@_@-..-..",
    3574. 

  3574.                 "confirmationurl" => "http://moodle.org/ext.php?with=some&param=eters",
    3575. 

  3575.                 "expected" => "http://moodle.org/ext.php?with=some&param=eters&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3576. 

  3576.             ],
    3577. 

  3577.             "Custom external confirmation url with parameters" => [
    3578. 

  3578.                 "username" => "many_-.@characters@_@-..-..",
    3579. 

  3579.                 "confirmationurl" => "http://moodle.org/ext.php?with=some&data=test",
    3580. 

  3580.                 "expected" => "http://moodle.org/ext.php?with=some&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E"
    3581. 

  3581.             ],
    3582. 

  3582.         ];
    3583. 

  3583.     }
    3584. 

  3584. 

  3585.     /**
    3586. 

  3586.      * Test generate_confirmation_link
    3587. 

  3587.      * @dataProvider generate_confirmation_link_provider
    3588. 

  3588.      * @param string $username The name of the user
    3589. 

  3589.      * @param string $confirmationurl The url the user should go to to confirm
    3590. 

  3590.      * @param string $expected The expected url of the confirmation link
    3591. 

  3591.      */
    3592. 

  3592.     public function test_generate_confirmation_link($username, $confirmationurl, $expected) {
    3593. 

  3593.         $this->resetAfterTest();
    3594. 

  3594.         $sink = $this->redirectEmails();
    3595. 

  3595. 

  3596.         $user = $this->getDataGenerator()->create_user(
    3597. 

  3597.             [
    3598. 

  3598.                 "username" => $username,
    3599. 

  3599.                 "confirmed" => 0,
    3600. 

  3600.                 "email" => 'test@example.com',
    3601. 

  3601.             ]
    3602. 

  3602.         );
    3603. 

  3603. 

  3604.         send_confirmation_email($user, $confirmationurl);
    3605. 

  3605.         $sink->close();
    3606. 

  3606.         $messages = $sink->get_messages();
    3607. 

  3607.         $message = array_shift($messages);
    3608. 

  3608.         $messagebody = quoted_printable_decode($message->body);
    3609. 

  3609. 

  3610.         $this->assertContains($expected, $messagebody);
    3611. 

  3611.     }
    3612. 

  3612. 

  3613.     /**
    3614. 

  3614.      * Test generate_confirmation_link with custom admin link
    3615. 

  3615.      */
    3616. 

  3616.     public function test_generate_confirmation_link_with_custom_admin() {
    3617. 

  3617.         global $CFG;
    3618. 

  3618. 

  3619.         $this->resetAfterTest();
    3620. 

  3620.         $sink = $this->redirectEmails();
    3621. 

  3621. 

  3622.         $admin = $CFG->admin;
    3623. 

  3623.         $CFG->admin = 'custom/admin/path';
    3624. 

  3624. 

  3625.         $user = $this->getDataGenerator()->create_user(
    3626. 

  3626.             [
    3627. 

  3627.                 "username" => "many_-.@characters@_@-..-..",
    3628. 

  3628.                 "confirmed" => 0,
    3629. 

  3629.                 "email" => 'test@example.com',
    3630. 

  3630.             ]
    3631. 

  3631.         );
    3632. 

  3632.         $confirmationurl = "/admin/test.php?with=params";
    3633. 

  3633.         $expected = $CFG->wwwroot . "/" . $CFG->admin . "/test.php?with=params&data=/many_-%2E%40characters%40_%40-%2E%2E-%2E%2E";
    3634. 

  3634. 

  3635.         send_confirmation_email($user, $confirmationurl);
    3636. 

  3636.         $sink->close();
    3637. 

  3637.         $messages = $sink->get_messages();
    3638. 

  3638.         $message = array_shift($messages);
    3639. 

  3639.         $messagebody = quoted_printable_decode($message->body);
    3640. 

  3640. 

  3641.         $sink->close();
    3642. 

  3642.         $this->assertContains($expected, $messagebody);
    3643. 

  3643. 

  3644.         $CFG->admin = $admin;
    3645. 

  3645.     }
    3646. 

  3646. 

  3647. 

  3648.     /**
    3649. 

  3649.      * Test remove_course_content deletes course contents
    3650. 

  3650.      * TODO Add asserts to verify other data related to course is deleted as well.
    3651. 

  3651.      */
    3652. 

  3652.     public function test_remove_course_contents() {
    3653. 

  3653. 

  3654.         $this->resetAfterTest();
    3655. 

  3655. 

  3656.         $course = $this->getDataGenerator()->create_course();
    3657. 

  3657.         $user = $this->getDataGenerator()->create_user();
    3658. 

  3658.         $gen = $this->getDataGenerator()->get_plugin_generator('core_notes');
    3659. 

  3659.         $note = $gen->create_instance(array('courseid' => $course->id, 'userid' => $user->id));
    3660. 

  3660. 

  3661.         $this->assertNotEquals(false, note_load($note->id));
    3662. 

  3662.         remove_course_contents($course->id, false);
    3663. 

  3663.         $this->assertFalse(note_load($note->id));
    3664. 

  3664.     }
    3665. 

  3665. 

  3666.     /**
    3667. 

  3667.      * Test function username_load_fields_from_object().
    3668. 

  3668.      */
    3669. 

  3669.     public function test_username_load_fields_from_object() {
    3670. 

  3670.         $this->resetAfterTest();
    3671. 

  3671. 

  3672.         // This object represents the information returned from an sql query.
    3673. 

  3673.         $userinfo = new stdClass();
    3674. 

  3674.         $userinfo->userid = 1;
    3675. 

  3675.         $userinfo->username = 'loosebruce';
    3676. 

  3676.         $userinfo->firstname = 'Bruce';
    3677. 

  3677.         $userinfo->lastname = 'Campbell';
    3678. 

  3678.         $userinfo->firstnamephonetic = 'ブルース';
    3679. 

  3679.         $userinfo->lastnamephonetic = 'カンベッル';
    3680. 

  3680.         $userinfo->middlename = '';
    3681. 

  3681.         $userinfo->alternatename = '';
    3682. 

  3682.         $userinfo->email = '';
    3683. 

  3683.         $userinfo->picture = 23;
    3684. 

  3684.         $userinfo->imagealt = 'Michael Jordan draining another basket.';
    3685. 

  3685.         $userinfo->idnumber = 3982;
    3686. 

  3686. 

  3687.         // Just user name fields.
    3688. 

  3688.         $user = new stdClass();
    3689. 

  3689.         $user = username_load_fields_from_object($user, $userinfo);
    3690. 

  3690.         $expectedarray = new stdClass();
    3691. 

  3691.         $expectedarray->firstname = 'Bruce';
    3692. 

  3692.         $expectedarray->lastname = 'Campbell';
    3693. 

  3693.         $expectedarray->firstnamephonetic = 'ブルース';
    3694. 

  3694.         $expectedarray->lastnamephonetic = 'カンベッル';
    3695. 

  3695.         $expectedarray->middlename = '';
    3696. 

  3696.         $expectedarray->alternatename = '';
    3697. 

  3697.         $this->assertEquals($user, $expectedarray);
    3698. 

  3698. 

  3699.         // User information for showing a picture.
    3700. 

  3700.         $user = new stdClass();
    3701. 

  3701.         $additionalfields = explode(',', user_picture::fields());
    3702. 

  3702.         $user = username_load_fields_from_object($user, $userinfo, null, $additionalfields);
    3703. 

  3703.         $user->id = $userinfo->userid;
    3704. 

  3704.         $expectedarray = new stdClass();
    3705. 

  3705.         $expectedarray->id = 1;
    3706. 

  3706.         $expectedarray->firstname = 'Bruce';
    3707. 

  3707.         $expectedarray->lastname = 'Campbell';
    3708. 

  3708.         $expectedarray->firstnamephonetic = 'ブルース';
    3709. 

  3709.         $expectedarray->lastnamephonetic = 'カンベッル';
    3710. 

  3710.         $expectedarray->middlename = '';
    3711. 

  3711.         $expectedarray->alternatename = '';
    3712. 

  3712.         $expectedarray->email = '';
    3713. 

  3713.         $expectedarray->picture = 23;
    3714. 

  3714.         $expectedarray->imagealt = 'Michael Jordan draining another basket.';
    3715. 

  3715.         $this->assertEquals($user, $expectedarray);
    3716. 

  3716. 

  3717.         // Alter the userinfo object to have a prefix.
    3718. 

  3718.         $userinfo->authorfirstname = 'Bruce';
    3719. 

  3719.         $userinfo->authorlastname = 'Campbell';
    3720. 

  3720.         $userinfo->authorfirstnamephonetic = 'ブルース';
    3721. 

  3721.         $userinfo->authorlastnamephonetic = 'カンベッル';
    3722. 

  3722.         $userinfo->authormiddlename = '';
    3723. 

  3723.         $userinfo->authorpicture = 23;
    3724. 

  3724.         $userinfo->authorimagealt = 'Michael Jordan draining another basket.';
    3725. 

  3725.         $userinfo->authoremail = 'test@example.com';
    3726. 

  3726. 

  3727. 

  3728.         // Return an object with user picture information.
    3729. 

  3729.         $user = new stdClass();
    3730. 

  3730.         $additionalfields = explode(',', user_picture::fields());
    3731. 

  3731.         $user = username_load_fields_from_object($user, $userinfo, 'author', $additionalfields);
    3732. 

  3732.         $user->id = $userinfo->userid;
    3733. 

  3733.         $expectedarray = new stdClass();
    3734. 

  3734.         $expectedarray->id = 1;
    3735. 

  3735.         $expectedarray->firstname = 'Bruce';
    3736. 

  3736.         $expectedarray->lastname = 'Campbell';
    3737. 

  3737.         $expectedarray->firstnamephonetic = 'ブルース';
    3738. 

  3738.         $expectedarray->lastnamephonetic = 'カンベッル';
    3739. 

  3739.         $expectedarray->middlename = '';
    3740. 

  3740.         $expectedarray->alternatename = '';
    3741. 

  3741.         $expectedarray->email = 'test@example.com';
    3742. 

  3742.         $expectedarray->picture = 23;
    3743. 

  3743.         $expectedarray->imagealt = 'Michael Jordan draining another basket.';
    3744. 

  3744.         $this->assertEquals($user, $expectedarray);
    3745. 

  3745.     }
    3746. 

  3746. 

  3747.     /**
    3748. 

  3748.      * Test function count_words().
    3749. 

  3749.      */
    3750. 

  3750.     public function test_count_words() {
    3751. 

  3751.         $count = count_words("one two three'four");
    3752. 

  3752.         $this->assertEquals(3, $count);
    3753. 

  3753. 

  3754.         $count = count_words('one+two three’four');
    3755. 

  3755.         $this->assertEquals(3, $count);
    3756. 

  3756. 

  3757.         $count = count_words('one"two three-four');
    3758. 

  3758.         $this->assertEquals(2, $count);
    3759. 

  3759. 

  3760.         $count = count_words('one@two three_four');
    3761. 

  3761.         $this->assertEquals(4, $count);
    3762. 

  3762. 

  3763.         $count = count_words('one\two three/four');
    3764. 

  3764.         $this->assertEquals(4, $count);
    3765. 

  3765. 

  3766.         $count = count_words(' one ... two &nbsp; three...four ');
    3767. 

  3767.         $this->assertEquals(4, $count);
    3768. 

  3768. 

  3769.         $count = count_words('one.2 3,four');
    3770. 

  3770.         $this->assertEquals(4, $count);
    3771. 

  3771. 

  3772.         $count = count_words('1³ £2 €3.45 $6,789');
    3773. 

  3773.         $this->assertEquals(4, $count);
    3774. 

  3774. 

  3775.         $count = count_words('one—two ブルース カンベッル');
    3776. 

  3776.         $this->assertEquals(4, $count);
    3777. 

  3777. 

  3778.         $count = count_words('one…two ブルース … カンベッル');
    3779. 

  3779.         $this->assertEquals(4, $count);
    3780. 

  3780.     }
    3781. 

  3781.     /**
    3782. 

  3782.      * Tests the getremoteaddr() function.
    3783. 

  3783.      */
    3784. 

  3784.     public function test_getremoteaddr() {
    3785. 

  3785.         global $CFG;
    3786. 

  3786. 

  3787.         $this->resetAfterTest();
    3788. 

  3788.         $CFG->getremoteaddrconf = GETREMOTEADDR_SKIP_HTTP_CLIENT_IP;
    3789. 

  3789.         $xforwardedfor = isset($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : null;
    3790. 

  3790. 

  3791.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '';
    3792. 

  3792.         $noip = getremoteaddr('1.1.1.1');
    3793. 

  3793.         $this->assertEquals('1.1.1.1', $noip);
    3794. 

  3794. 

  3795.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '';
    3796. 

  3796.         $noip = getremoteaddr();
    3797. 

  3797.         $this->assertEquals('0.0.0.0', $noip);
    3798. 

  3798. 

  3799.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1';
    3800. 

  3800.         $singleip = getremoteaddr();
    3801. 

  3801.         $this->assertEquals('127.0.0.1', $singleip);
    3802. 

  3802. 

  3803.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,127.0.0.2';
    3804. 

  3804.         $twoip = getremoteaddr();
    3805. 

  3805.         $this->assertEquals('127.0.0.2', $twoip);
    3806. 

  3806. 

  3807.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,127.0.0.2,127.0.0.3';
    3808. 

  3808.         $threeip = getremoteaddr();
    3809. 

  3809.         $this->assertEquals('127.0.0.3', $threeip);
    3810. 

  3810. 

  3811.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,127.0.0.2:65535';
    3812. 

  3812.         $portip = getremoteaddr();
    3813. 

  3813.         $this->assertEquals('127.0.0.2', $portip);
    3814. 

  3814. 

  3815.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,0:0:0:0:0:0:0:2';
    3816. 

  3816.         $portip = getremoteaddr();
    3817. 

  3817.         $this->assertEquals('0:0:0:0:0:0:0:2', $portip);
    3818. 

  3818. 

  3819.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,0::2';
    3820. 

  3820.         $portip = getremoteaddr();
    3821. 

  3821.         $this->assertEquals('0:0:0:0:0:0:0:2', $portip);
    3822. 

  3822. 

  3823.         $_SERVER['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,[0:0:0:0:0:0:0:2]:65535';
    3824. 

  3824.         $portip = getremoteaddr();
    3825. 

  3825.         $this->assertEquals('0:0:0:0:0:0:0:2', $portip);
    3826. 

  3826. 

  3827.         $_SERVER['HTTP_X_FORWARDED_FOR'] = $xforwardedfor;
    3828. 

  3828. 

  3829.     }
    3830. 

  3830. 

  3831.     /*
    3832. 

  3832.      * Test emulation of random_bytes() function.
    3833. 

  3833.      */
    3834. 

  3834.     public function test_random_bytes_emulate() {
    3835. 

  3835.         $result = random_bytes_emulate(10);
    3836. 

  3836.         $this->assertSame(10, strlen($result));
    3837. 

  3837.         $this->assertnotSame($result, random_bytes_emulate(10));
    3838. 

  3838. 

  3839.         $result = random_bytes_emulate(21);
    3840. 

  3840.         $this->assertSame(21, strlen($result));
    3841. 

  3841.         $this->assertnotSame($result, random_bytes_emulate(21));
    3842. 

  3842. 

  3843.         $result = random_bytes_emulate(666);
    3844. 

  3844.         $this->assertSame(666, strlen($result));
    3845. 

  3845. 

  3846.         $result = random_bytes_emulate(40);
    3847. 

  3847.         $this->assertSame(40, strlen($result));
    3848. 

  3848. 

  3849.         $this->assertDebuggingNotCalled();
    3850. 

  3850. 

  3851.         $result = random_bytes_emulate(0);
    3852. 

  3852.         $this->assertSame('', $result);
    3853. 

  3853.         $this->assertDebuggingCalled();
    3854. 

  3854. 

  3855.         $result = random_bytes_emulate(-1);
    3856. 

  3856.         $this->assertSame('', $result);
    3857. 

  3857.         $this->assertDebuggingCalled();
    3858. 

  3858.     }
    3859. 

  3859. 

  3860.     /**
    3861. 

  3861.      * Test function for creation of random strings.
    3862. 

  3862.      */
    3863. 

  3863.     public function test_random_string() {
    3864. 

  3864.         $pool = 'a-zA-Z0-9';
    3865. 

  3865. 

  3866.         $result = random_string(10);
    3867. 

  3867.         $this->assertSame(10, strlen($result));
    3868. 

  3868.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3869. 

  3869.         $this->assertNotSame($result, random_string(10));
    3870. 

  3870. 

  3871.         $result = random_string(21);
    3872. 

  3872.         $this->assertSame(21, strlen($result));
    3873. 

  3873.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3874. 

  3874.         $this->assertNotSame($result, random_string(21));
    3875. 

  3875. 

  3876.         $result = random_string(666);
    3877. 

  3877.         $this->assertSame(666, strlen($result));
    3878. 

  3878.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3879. 

  3879. 

  3880.         $result = random_string();
    3881. 

  3881.         $this->assertSame(15, strlen($result));
    3882. 

  3882.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3883. 

  3883. 

  3884.         $this->assertDebuggingNotCalled();
    3885. 

  3885. 

  3886.         $result = random_string(0);
    3887. 

  3887.         $this->assertSame('', $result);
    3888. 

  3888.         $this->assertDebuggingCalled();
    3889. 

  3889. 

  3890.         $result = random_string(-1);
    3891. 

  3891.         $this->assertSame('', $result);
    3892. 

  3892.         $this->assertDebuggingCalled();
    3893. 

  3893.     }
    3894. 

  3894. 

  3895.     /**
    3896. 

  3896.      * Test function for creation of complex random strings.
    3897. 

  3897.      */
    3898. 

  3898.     public function test_complex_random_string() {
    3899. 

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

  3900. 

  3901.         $result = complex_random_string(10);
    3902. 

  3902.         $this->assertSame(10, strlen($result));
    3903. 

  3903.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3904. 

  3904.         $this->assertNotSame($result, complex_random_string(10));
    3905. 

  3905. 

  3906.         $result = complex_random_string(21);
    3907. 

  3907.         $this->assertSame(21, strlen($result));
    3908. 

  3908.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3909. 

  3909.         $this->assertNotSame($result, complex_random_string(21));
    3910. 

  3910. 

  3911.         $result = complex_random_string(666);
    3912. 

  3912.         $this->assertSame(666, strlen($result));
    3913. 

  3913.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3914. 

  3914. 

  3915.         $result = complex_random_string();
    3916. 

  3916.         $this->assertEquals(28, strlen($result), '', 4); // Expected length is 24 - 32.
    3917. 

  3917.         $this->assertRegExp('/^[' . $pool . ']+$/', $result);
    3918. 

  3918. 

  3919.         $this->assertDebuggingNotCalled();
    3920. 

  3920. 

  3921.         $result = complex_random_string(0);
    3922. 

  3922.         $this->assertSame('', $result);
    3923. 

  3923.         $this->assertDebuggingCalled();
    3924. 

  3924. 

  3925.         $result = complex_random_string(-1);
    3926. 

  3926.         $this->assertSame('', $result);
    3927. 

  3927.         $this->assertDebuggingCalled();
    3928. 

  3928.     }
    3929. 

  3929. 

  3930.     /**
    3931. 

  3931.      * Data provider for private ips.
    3932. 

  3932.      */
    3933. 

  3933.     public function data_private_ips() {
    3934. 

  3934.         return array(
    3935. 

  3935.             array('10.0.0.0'),
    3936. 

  3936.             array('172.16.0.0'),
    3937. 

  3937.             array('192.168.1.0'),
    3938. 

  3938.             array('fdfe:dcba:9876:ffff:fdc6:c46b:bb8f:7d4c'),
    3939. 

  3939.             array('fdc6:c46b:bb8f:7d4c:fdc6:c46b:bb8f:7d4c'),
    3940. 

  3940.             array('fdc6:c46b:bb8f:7d4c:0000:8a2e:0370:7334'),
    3941. 

  3941.             array('127.0.0.1'), // This has been buggy in past: https://bugs.php.net/bug.php?id=53150.
    3942. 

  3942.         );
    3943. 

  3943.     }
    3944. 

  3944. 

  3945.     /**
    3946. 

  3946.      * Checks ip_is_public returns false for private ips.
    3947. 

  3947.      *
    3948. 

  3948.      * @param string $ip the ipaddress to test
    3949. 

  3949.      * @dataProvider data_private_ips
    3950. 

  3950.      */
    3951. 

  3951.     public function test_ip_is_public_private_ips($ip) {
    3952. 

  3952.         $this->assertFalse(ip_is_public($ip));
    3953. 

  3953.     }
    3954. 

  3954. 

  3955.     /**
    3956. 

  3956.      * Data provider for public ips.
    3957. 

  3957.      */
    3958. 

  3958.     public function data_public_ips() {
    3959. 

  3959.         return array(
    3960. 

  3960.             array('2400:cb00:2048:1::8d65:71b3'),
    3961. 

  3961.             array('2400:6180:0:d0::1b:2001'),
    3962. 

  3962.             array('141.101.113.179'),
    3963. 

  3963.             array('123.45.67.178'),
    3964. 

  3964.         );
    3965. 

  3965.     }
    3966. 

  3966. 

  3967.     /**
    3968. 

  3968.      * Checks ip_is_public returns true for public ips.
    3969. 

  3969.      *
    3970. 

  3970.      * @param string $ip the ipaddress to test
    3971. 

  3971.      * @dataProvider data_public_ips
    3972. 

  3972.      */
    3973. 

  3973.     public function test_ip_is_public_public_ips($ip) {
    3974. 

  3974.         $this->assertTrue(ip_is_public($ip));
    3975. 

  3975.     }
    3976. 

  3976. 

  3977.     /**
    3978. 

  3978.      * Test the function can_send_from_real_email_address
    3979. 

  3979.      *
    3980. 

  3980.      * @param string $email Email address for the from user.
    3981. 

  3981.      * @param int $display The user's email display preference.
    3982. 

  3982.      * @param bool $samecourse Are the users in the same course?
    3983. 

  3983.      * @param string $config The CFG->allowedemaildomains config values
    3984. 

  3984.      * @param bool $result The expected result.
    3985. 

  3985.      * @dataProvider data_can_send_from_real_email_address
    3986. 

  3986.      */
    3987. 

  3987.     public function test_can_send_from_real_email_address($email, $display, $samecourse, $config, $result) {
    3988. 

  3988.         $this->resetAfterTest();
    3989. 

  3989. 

  3990.         $fromuser = $this->getDataGenerator()->create_user();
    3991. 

  3991.         $touser = $this->getDataGenerator()->create_user();
    3992. 

  3992.         $course = $this->getDataGenerator()->create_course();
    3993. 

  3993.         set_config('allowedemaildomains', $config);
    3994. 

  3994. 

  3995.         $fromuser->email = $email;
    3996. 

  3996.         $fromuser->maildisplay = $display;
    3997. 

  3997.         if ($samecourse) {
    3998. 

  3998.             $this->getDataGenerator()->enrol_user($fromuser->id, $course->id, 'student');
    3999. 

  3999.             $this->getDataGenerator()->enrol_user($touser->id, $course->id, 'student');
    4000. 

  4000.         } else {
    4001. 

  4001.             $this->getDataGenerator()->enrol_user($fromuser->id, $course->id, 'student');
    4002. 

  4002.         }
    4003. 

  4003.         $this->assertEquals($result, can_send_from_real_email_address($fromuser, $touser));
    4004. 

  4004.     }
    4005. 

  4005. 

  4006.     /**
    4007. 

  4007.      * Data provider for test_can_send_from_real_email_address.
    4008. 

  4008.      *
    4009. 

  4009.      * @return array Returns an array of test data for the above function.
    4010. 

  4010.      */
    4011. 

  4011.     public function data_can_send_from_real_email_address() {
    4012. 

  4012.         return [
    4013. 

  4013.             // Test from email is in allowed domain.
    4014. 

  4014.             // Test that from display is set to show no one.
    4015. 

  4015.             [
    4016. 

  4016.                 'email' => 'fromuser@example.com',
    4017. 

  4017.                 'display' => core_user::MAILDISPLAY_HIDE,
    4018. 

  4018.                 'samecourse' => false,
    4019. 

  4019.                 'config' => "example.com\r\ntest.com",
    4020. 

  4020.                 'result' => false
    4021. 

  4021.             ],
    4022. 

  4022.             // Test that from display is set to course members only (course member).
    4023. 

  4023.             [
    4024. 

  4024.                 'email' => 'fromuser@example.com',
    4025. 

  4025.                 'display' => core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY,
    4026. 

  4026.                 'samecourse' => true,
    4027. 

  4027.                 'config' => "example.com\r\ntest.com",
    4028. 

  4028.                 'result' => true
    4029. 

  4029.             ],
    4030. 

  4030.             // Test that from display is set to course members only (Non course member).
    4031. 

  4031.             [
    4032. 

  4032.                 'email' => 'fromuser@example.com',
    4033. 

  4033.                 'display' => core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY,
    4034. 

  4034.                 'samecourse' => false,
    4035. 

  4035.                 'config' => "example.com\r\ntest.com",
    4036. 

  4036.                 'result' => false
    4037. 

  4037.             ],
    4038. 

  4038.             // Test that from display is set to show everyone.
    4039. 

  4039.             [
    4040. 

  4040.                 'email' => 'fromuser@example.com',
    4041. 

  4041.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4042. 

  4042.                 'samecourse' => false,
    4043. 

  4043.                 'config' => "example.com\r\ntest.com",
    4044. 

  4044.                 'result' => true
    4045. 

  4045.             ],
    4046. 

  4046.             // Test a few different config value formats for parsing correctness.
    4047. 

  4047.             [
    4048. 

  4048.                 'email' => 'fromuser@example.com',
    4049. 

  4049.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4050. 

  4050.                 'samecourse' => false,
    4051. 

  4051.                 'config' => "\n test.com\nexample.com \n",
    4052. 

  4052.                 'result' => true
    4053. 

  4053.             ],
    4054. 

  4054.             [
    4055. 

  4055.                 'email' => 'fromuser@example.com',
    4056. 

  4056.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4057. 

  4057.                 'samecourse' => false,
    4058. 

  4058.                 'config' => "\r\n example.com \r\n test.com \r\n",
    4059. 

  4059.                 'result' => true
    4060. 

  4060.             ],
    4061. 

  4061. 

  4062.             // Test from email is not in allowed domain.
    4063. 

  4063.             // Test that from display is set to show no one.
    4064. 

  4064.             [   'email' => 'fromuser@moodle.com',
    4065. 

  4065.                 'display' => core_user::MAILDISPLAY_HIDE,
    4066. 

  4066.                 'samecourse' => false,
    4067. 

  4067.                 'config' => "example.com\r\ntest.com",
    4068. 

  4068.                 'result' => false
    4069. 

  4069.             ],
    4070. 

  4070.             // Test that from display is set to course members only (course member).
    4071. 

  4071.             [   'email' => 'fromuser@moodle.com',
    4072. 

  4072.                 'display' => core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY,
    4073. 

  4073.                 'samecourse' => true,
    4074. 

  4074.                 'config' => "example.com\r\ntest.com",
    4075. 

  4075.                 'result' => false
    4076. 

  4076.             ],
    4077. 

  4077.             // Test that from display is set to course members only (Non course member.
    4078. 

  4078.             [   'email' => 'fromuser@moodle.com',
    4079. 

  4079.                 'display' => core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY,
    4080. 

  4080.                 'samecourse' => false,
    4081. 

  4081.                 'config' => "example.com\r\ntest.com",
    4082. 

  4082.                 'result' => false
    4083. 

  4083.             ],
    4084. 

  4084.             // Test that from display is set to show everyone.
    4085. 

  4085.             [   'email' => 'fromuser@moodle.com',
    4086. 

  4086.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4087. 

  4087.                 'samecourse' => false,
    4088. 

  4088.                 'config' => "example.com\r\ntest.com",
    4089. 

  4089.                 'result' => false
    4090. 

  4090.             ],
    4091. 

  4091.             // Test a few erroneous config value and confirm failure.
    4092. 

  4092.             [   'email' => 'fromuser@moodle.com',
    4093. 

  4093.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4094. 

  4094.                 'samecourse' => false,
    4095. 

  4095.                 'config' => "\r\n   \r\n",
    4096. 

  4096.                 'result' => false
    4097. 

  4097.             ],
    4098. 

  4098.             [   'email' => 'fromuser@moodle.com',
    4099. 

  4099.                 'display' => core_user::MAILDISPLAY_EVERYONE,
    4100. 

  4100.                 'samecourse' => false,
    4101. 

  4101.                 'config' => " \n   \n \n ",
    4102. 

  4102.                 'result' => false
    4103. 

  4103.             ],
    4104. 

  4104.         ];
    4105. 

  4105.     }
    4106. 

  4106. 

  4107.     /**
    4108. 

  4108.      * Test that generate_email_processing_address() returns valid email address.
    4109. 

  4109.      */
    4110. 

  4110.     public function test_generate_email_processing_address() {
    4111. 

  4111.         global $CFG;
    4112. 

  4112.         $this->resetAfterTest();
    4113. 

  4113. 

  4114.         $data = (object)[
    4115. 

  4115.             'id' => 42,
    4116. 

  4116.             'email' => 'my.email+from_moodle@example.com',
    4117. 

  4117.         ];
    4118. 

  4118. 

  4119.         $modargs = 'B'.base64_encode(pack('V', $data->id)).substr(md5($data->email), 0, 16);
    4120. 

  4120. 

  4121.         $CFG->maildomain = 'example.com';
    4122. 

  4122.         $CFG->mailprefix = 'mdl+';
    4123. 

  4123.         $this->assertTrue(validate_email(generate_email_processing_address(0, $modargs)));
    4124. 

  4124. 

  4125.         $CFG->maildomain = 'mail.example.com';
    4126. 

  4126.         $CFG->mailprefix = 'mdl-';
    4127. 

  4127.         $this->assertTrue(validate_email(generate_email_processing_address(23, $modargs)));
    4128. 

  4128.     }
    4129. 

  4129. 

  4130.     /**
    4131. 

  4131.      * Test allowemailaddresses setting.
    4132. 

  4132.      *
    4133. 

  4133.      * @param string $email Email address for the from user.
    4134. 

  4134.      * @param string $config The CFG->allowemailaddresses config values
    4135. 

  4135.      * @param false/string $result The expected result.
    4136. 

  4136.      *
    4137. 

  4137.      * @dataProvider data_email_is_not_allowed_for_allowemailaddresses
    4138. 

  4138.      */
    4139. 

  4139.     public function test_email_is_not_allowed_for_allowemailaddresses($email, $config, $result) {
    4140. 

  4140.         $this->resetAfterTest();
    4141. 

  4141. 

  4142.         set_config('allowemailaddresses', $config);
    4143. 

  4143.         $this->assertEquals($result, email_is_not_allowed($email));
    4144. 

  4144.     }
    4145. 

  4145. 

  4146.     /**
    4147. 

  4147.      * Data provider for data_email_is_not_allowed_for_allowemailaddresses.
    4148. 

  4148.      *
    4149. 

  4149.      * @return array Returns an array of test data for the above function.
    4150. 

  4150.      */
    4151. 

  4151.     public function data_email_is_not_allowed_for_allowemailaddresses() {
    4152. 

  4152.         return [
    4153. 

  4153.             // Test allowed domain empty list.
    4154. 

  4154.             [
    4155. 

  4155.                 'email' => 'fromuser@example.com',
    4156. 

  4156.                 'config' => '',
    4157. 

  4157.                 'result' => false
    4158. 

  4158.             ],
    4159. 

  4159.             // Test from email is in allowed domain.
    4160. 

  4160.             [
    4161. 

  4161.                 'email' => 'fromuser@example.com',
    4162. 

  4162.                 'config' => 'example.com test.com',
    4163. 

  4163.                 'result' => false
    4164. 

  4164.             ],
    4165. 

  4165.             // Test from email is in allowed domain but uppercase config.
    4166. 

  4166.             [
    4167. 

  4167.                 'email' => 'fromuser@example.com',
    4168. 

  4168.                 'config' => 'EXAMPLE.com test.com',
    4169. 

  4169.                 'result' => false
    4170. 

  4170.             ],
    4171. 

  4171.             // Test from email is in allowed domain but uppercase email.
    4172. 

  4172.             [
    4173. 

  4173.                 'email' => 'fromuser@EXAMPLE.com',
    4174. 

  4174.                 'config' => 'example.com test.com',
    4175. 

  4175.                 'result' => false
    4176. 

  4176.             ],
    4177. 

  4177.             // Test from email is in allowed subdomain.
    4178. 

  4178.             [
    4179. 

  4179.                 'email' => 'fromuser@something.example.com',
    4180. 

  4180.                 'config' => '.example.com test.com',
    4181. 

  4181.                 'result' => false
    4182. 

  4182.             ],
    4183. 

  4183.             // Test from email is in allowed subdomain but uppercase config.
    4184. 

  4184.             [
    4185. 

  4185.                 'email' => 'fromuser@something.example.com',
    4186. 

  4186.                 'config' => '.EXAMPLE.com test.com',
    4187. 

  4187.                 'result' => false
    4188. 

  4188.             ],
    4189. 

  4189.             // Test from email is in allowed subdomain but uppercase email.
    4190. 

  4190.             [
    4191. 

  4191.                 'email' => 'fromuser@something.EXAMPLE.com',
    4192. 

  4192.                 'config' => '.example.com test.com',
    4193. 

  4193.                 'result' => false
    4194. 

  4194.             ],
    4195. 

  4195.             // Test from email is not in allowed domain.
    4196. 

  4196.             [   'email' => 'fromuser@moodle.com',
    4197. 

  4197.                 'config' => 'example.com test.com',
    4198. 

  4198.                 'result' => get_string('emailonlyallowed', '', 'example.com test.com')
    4199. 

  4199.             ],
    4200. 

  4200.             // Test from email is not in allowed subdomain.
    4201. 

  4201.             [   'email' => 'fromuser@something.example.com',
    4202. 

  4202.                 'config' => 'example.com test.com',
    4203. 

  4203.                 'result' => get_string('emailonlyallowed', '', 'example.com test.com')
    4204. 

  4204.             ],
    4205. 

  4205.         ];
    4206. 

  4206.     }
    4207. 

  4207. 

  4208.     /**
    4209. 

  4209.      * Test denyemailaddresses setting.
    4210. 

  4210.      *
    4211. 

  4211.      * @param string $email Email address for the from user.
    4212. 

  4212.      * @param string $config The CFG->denyemailaddresses config values
    4213. 

  4213.      * @param false/string $result The expected result.
    4214. 

  4214.      *
    4215. 

  4215.      * @dataProvider data_email_is_not_allowed_for_denyemailaddresses
    4216. 

  4216.      */
    4217. 

  4217.     public function test_email_is_not_allowed_for_denyemailaddresses($email, $config, $result) {
    4218. 

  4218.         $this->resetAfterTest();
    4219. 

  4219. 

  4220.         set_config('denyemailaddresses', $config);
    4221. 

  4221.         $this->assertEquals($result, email_is_not_allowed($email));
    4222. 

  4222.     }
    4223. 

  4223. 

  4224. 

  4225.     /**
    4226. 

  4226.      * Data provider for test_email_is_not_allowed_for_denyemailaddresses.
    4227. 

  4227.      *
    4228. 

  4228.      * @return array Returns an array of test data for the above function.
    4229. 

  4229.      */
    4230. 

  4230.     public function data_email_is_not_allowed_for_denyemailaddresses() {
    4231. 

  4231.         return [
    4232. 

  4232.             // Test denied domain empty list.
    4233. 

  4233.             [
    4234. 

  4234.                 'email' => 'fromuser@example.com',
    4235. 

  4235.                 'config' => '',
    4236. 

  4236.                 'result' => false
    4237. 

  4237.             ],
    4238. 

  4238.             // Test from email is in denied domain.
    4239. 

  4239.             [
    4240. 

  4240.                 'email' => 'fromuser@example.com',
    4241. 

  4241.                 'config' => 'example.com test.com',
    4242. 

  4242.                 'result' => get_string('emailnotallowed', '', 'example.com test.com')
    4243. 

  4243.             ],
    4244. 

  4244.             // Test from email is in denied domain but uppercase config.
    4245. 

  4245.             [
    4246. 

  4246.                 'email' => 'fromuser@example.com',
    4247. 

  4247.                 'config' => 'EXAMPLE.com test.com',
    4248. 

  4248.                 'result' => get_string('emailnotallowed', '', 'EXAMPLE.com test.com')
    4249. 

  4249.             ],
    4250. 

  4250.             // Test from email is in denied domain but uppercase email.
    4251. 

  4251.             [
    4252. 

  4252.                 'email' => 'fromuser@EXAMPLE.com',
    4253. 

  4253.                 'config' => 'example.com test.com',
    4254. 

  4254.                 'result' => get_string('emailnotallowed', '', 'example.com test.com')
    4255. 

  4255.             ],
    4256. 

  4256.             // Test from email is in denied subdomain.
    4257. 

  4257.             [
    4258. 

  4258.                 'email' => 'fromuser@something.example.com',
    4259. 

  4259.                 'config' => '.example.com test.com',
    4260. 

  4260.                 'result' => get_string('emailnotallowed', '', '.example.com test.com')
    4261. 

  4261.             ],
    4262. 

  4262.             // Test from email is in denied subdomain but uppercase config.
    4263. 

  4263.             [
    4264. 

  4264.                 'email' => 'fromuser@something.example.com',
    4265. 

  4265.                 'config' => '.EXAMPLE.com test.com',
    4266. 

  4266.                 'result' => get_string('emailnotallowed', '', '.EXAMPLE.com test.com')
    4267. 

  4267.             ],
    4268. 

  4268.             // Test from email is in denied subdomain but uppercase email.
    4269. 

  4269.             [
    4270. 

  4270.                 'email' => 'fromuser@something.EXAMPLE.com',
    4271. 

  4271.                 'config' => '.example.com test.com',
    4272. 

  4272.                 'result' => get_string('emailnotallowed', '', '.example.com test.com')
    4273. 

  4273.             ],
    4274. 

  4274.             // Test from email is not in denied domain.
    4275. 

  4275.             [   'email' => 'fromuser@moodle.com',
    4276. 

  4276.                 'config' => 'example.com test.com',
    4277. 

  4277.                 'result' => false
    4278. 

  4278.             ],
    4279. 

  4279.             // Test from email is not in denied subdomain.
    4280. 

  4280.             [   'email' => 'fromuser@something.example.com',
    4281. 

  4281.                 'config' => 'example.com test.com',
    4282. 

  4282.                 'result' => false
    4283. 

  4283.             ],
    4284. 

  4284.         ];
    4285. 

  4285.     }
    4286. 

  4286. 

  4287.     /**
    4288. 

  4288.      * Test safe method unserialize_array().
    4289. 

  4289.      */
    4290. 

  4290.     public function test_unserialize_array() {
    4291. 

  4291.         $a = [1, 2, 3];
    4292. 

  4292.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4293. 

  4293.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4294. 

  4294.         $a = ['a' => 1, 2 => 2, 'b' => 'cde'];
    4295. 

  4295.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4296. 

  4296.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4297. 

  4297.         $a = ['a' => 1, 2 => 2, 'b' => 'c"d"e'];
    4298. 

  4298.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4299. 

  4299.         $a = ['a' => 1, 2 => ['c' => 'd', 'e' => 'f'], 'b' => 'cde'];
    4300. 

  4300.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4301. 

  4301. 

  4302.         // Can not unserialize if any string contains semicolons.
    4303. 

  4303.         $a = ['a' => 1, 2 => 2, 'b' => 'c"d";e'];
    4304. 

  4304.         $this->assertEquals(false, unserialize_array(serialize($a)));
    4305. 

  4305. 

  4306.         // Can not unserialize if there are any objects.
    4307. 

  4307.         $a = (object)['a' => 1, 2 => 2, 'b' => 'cde'];
    4308. 

  4308.         $this->assertEquals(false, unserialize_array(serialize($a)));
    4309. 

  4309.         $a = ['a' => 1, 2 => 2, 'b' => (object)['a' => 'cde']];
    4310. 

  4310.         $this->assertEquals(false, unserialize_array(serialize($a)));
    4311. 

  4311. 

  4312.         // Array used in the grader report.
    4313. 

  4313.         $a = array('aggregatesonly' => [51, 34], 'gradesonly' => [21, 45, 78]);
    4314. 

  4314.         $this->assertEquals($a, unserialize_array(serialize($a)));
    4315. 

  4315.     }
    4316. 

  4316. 

  4317.     /**
    4318. 

  4318.      * Test that the component_class_callback returns the correct default value when the class was not found.
    4319. 

  4319.      *
    4320. 

  4320.      * @dataProvider component_class_callback_default_provider
    4321. 

  4321.      * @param $default
    4322. 

  4322.      */
    4323. 

  4323.     public function test_component_class_callback_not_found($default) {
    4324. 

  4324.         $this->assertSame($default, component_class_callback('thisIsNotTheClassYouWereLookingFor', 'anymethod', [], $default));
    4325. 

  4325.     }
    4326. 

  4326. 

  4327.     /**
    4328. 

  4328.      * Test that the component_class_callback returns the correct default value when the class was not found.
    4329. 

  4329.      *
    4330. 

  4330.      * @dataProvider component_class_callback_default_provider
    4331. 

  4331.      * @param $default
    4332. 

  4332.      */
    4333. 

  4333.     public function test_component_class_callback_method_not_found($default) {
    4334. 

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

  4335. 

  4336.         $this->assertSame($default, component_class_callback(test_component_class_callback_example::class, 'this_is_not_the_method_you_were_looking_for', ['abc'], $default));
    4337. 

  4337.     }
    4338. 

  4338. 

  4339.     /**
    4340. 

  4340.      * Test that the component_class_callback returns the default when the method returned null.
    4341. 

  4341.      *
    4342. 

  4342.      * @dataProvider component_class_callback_default_provider
    4343. 

  4343.      * @param $default
    4344. 

  4344.      */
    4345. 

  4345.     public function test_component_class_callback_found_returns_null($default) {
    4346. 

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

  4347. 

  4348.         $this->assertSame($default, component_class_callback(test_component_class_callback_example::class, 'method_returns_value', [null], $default));
    4349. 

  4349.         $this->assertSame($default, component_class_callback(test_component_class_callback_child_example::class, 'method_returns_value', [null], $default));
    4350. 

  4350.     }
    4351. 

  4351. 

  4352.     /**
    4353. 

  4353.      * Test that the component_class_callback returns the expected value and not the default when there was a value.
    4354. 

  4354.      *
    4355. 

  4355.      * @dataProvider component_class_callback_data_provider
    4356. 

  4356.      * @param $default
    4357. 

  4357.      */
    4358. 

  4358.     public function test_component_class_callback_found_returns_value($value) {
    4359. 

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

  4360. 

  4361.         $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'));
    4362. 

  4362.         $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'));
    4363. 

  4363.     }
    4364. 

  4364. 

  4365.     /**
    4366. 

  4366.      * Test that the component_class_callback handles multiple params correctly.
    4367. 

  4367.      *
    4368. 

  4368.      * @dataProvider component_class_callback_multiple_params_provider
    4369. 

  4369.      * @param $default
    4370. 

  4370.      */
    4371. 

  4371.     public function test_component_class_callback_found_accepts_multiple($params, $count) {
    4372. 

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

  4373. 

  4374.         $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'));
    4375. 

  4375.         $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'));
    4376. 

  4376.     }
    4377. 

  4377. 

  4378.     /**
    4379. 

  4379.      * Data provider with list of default values for user in component_class_callback tests.
    4380. 

  4380.      *
    4381. 

  4381.      * @return array
    4382. 

  4382.      */
    4383. 

  4383.     public function component_class_callback_default_provider() {
    4384. 

  4384.         return [
    4385. 

  4385.             'null' => [null],
    4386. 

  4386.             'empty string' => [''],
    4387. 

  4387.             'string' => ['This is a string'],
    4388. 

  4388.             'int' => [12345],
    4389. 

  4389.             'stdClass' => [(object) ['this is my content']],
    4390. 

  4390.             'array' => [['a' => 'b',]],
    4391. 

  4391.         ];
    4392. 

  4392.     }
    4393. 

  4393. 

  4394.     /**
    4395. 

  4395.      * Data provider with list of default values for user in component_class_callback tests.
    4396. 

  4396.      *
    4397. 

  4397.      * @return array
    4398. 

  4398.      */
    4399. 

  4399.     public function component_class_callback_data_provider() {
    4400. 

  4400.         return [
    4401. 

  4401.             'empty string' => [''],
    4402. 

  4402.             'string' => ['This is a string'],
    4403. 

  4403.             'int' => [12345],
    4404. 

  4404.             'stdClass' => [(object) ['this is my content']],
    4405. 

  4405.             'array' => [['a' => 'b',]],
    4406. 

  4406.         ];
    4407. 

  4407.     }
    4408. 

  4408. 

  4409.     /**
    4410. 

  4410.      * Data provider with list of default values for user in component_class_callback tests.
    4411. 

  4411.      *
    4412. 

  4412.      * @return array
    4413. 

  4413.      */
    4414. 

  4414.     public function component_class_callback_multiple_params_provider() {
    4415. 

  4415.         return [
    4416. 

  4416.             'empty array' => [
    4417. 

  4417.                 [],
    4418. 

  4418.                 0,
    4419. 

  4419.             ],
    4420. 

  4420.             'string value' => [
    4421. 

  4421.                 ['one'],
    4422. 

  4422.                 1,
    4423. 

  4423.             ],
    4424. 

  4424.             'string values' => [
    4425. 

  4425.                 ['one', 'two'],
    4426. 

  4426.                 2,
    4427. 

  4427.             ],
    4428. 

  4428.             'arrays' => [
    4429. 

  4429.                 [[], []],
    4430. 

  4430.                 2,
    4431. 

  4431.             ],
    4432. 

  4432.             'nulls' => [
    4433. 

  4433.                 [null, null, null, null],
    4434. 

  4434.                 4,
    4435. 

  4435.             ],
    4436. 

  4436.             'mixed' => [
    4437. 

  4437.                 ['a', 1, null, (object) [], []],
    4438. 

  4438.                 5,
    4439. 

  4439.             ],
    4440. 

  4440.         ];
    4441. 

  4441.     }
    4442. 

  4442. 

  4443.     /**
    4444. 

  4444.      * Test that {@link get_callable_name()} describes the callable as expected.
    4445. 

  4445.      *
    4446. 

  4446.      * @dataProvider callable_names_provider
    4447. 

  4447.      * @param callable $callable
    4448. 

  4448.      * @param string $expectedname
    4449. 

  4449.      */
    4450. 

  4450.     public function test_get_callable_name($callable, $expectedname) {
    4451. 

  4451.         $this->assertSame($expectedname, get_callable_name($callable));
    4452. 

  4452.     }
    4453. 

  4453. 

  4454.     /**
    4455. 

  4455.      * Provides a set of callables and their human readable names.
    4456. 

  4456.      *
    4457. 

  4457.      * @return array of (string)case => [(mixed)callable, (string|bool)expected description]
    4458. 

  4458.      */
    4459. 

  4459.     public function callable_names_provider() {
    4460. 

  4460.         return [
    4461. 

  4461.             'integer' => [
    4462. 

  4462.                 386,
    4463. 

  4463.                 false,
    4464. 

  4464.             ],
    4465. 

  4465.             'boolean' => [
    4466. 

  4466.                 true,
    4467. 

  4467.                 false,
    4468. 

  4468.             ],
    4469. 

  4469.             'static_method_as_literal' => [
    4470. 

  4470.                 'my_foobar_class::my_foobar_method',
    4471. 

  4471.                 'my_foobar_class::my_foobar_method',
    4472. 

  4472.             ],
    4473. 

  4473.             'static_method_of_literal_class' => [
    4474. 

  4474.                 ['my_foobar_class', 'my_foobar_method'],
    4475. 

  4475.                 'my_foobar_class::my_foobar_method',
    4476. 

  4476.             ],
    4477. 

  4477.             'static_method_of_object' => [
    4478. 

  4478.                 [$this, 'my_foobar_method'],
    4479. 

  4479.                 'core_moodlelib_testcase::my_foobar_method',
    4480. 

  4480.             ],
    4481. 

  4481.             'method_of_object' => [
    4482. 

  4482.                 [new lang_string('parentlanguage', 'core_langconfig'), 'my_foobar_method'],
    4483. 

  4483.                 'lang_string::my_foobar_method',
    4484. 

  4484.             ],
    4485. 

  4485.             'function_as_literal' => [
    4486. 

  4486.                 'my_foobar_callback',
    4487. 

  4487.                 'my_foobar_callback',
    4488. 

  4488.             ],
    4489. 

  4489.             'function_as_closure' => [
    4490. 

  4490.                 function($a) { return $a; },
    4491. 

  4491.                 'Closure::__invoke',
    4492. 

  4492.             ],
    4493. 

  4493.         ];
    4494. 

  4494.     }
    4495. 

  4495. 

  4496.     /**
    4497. 

  4497.      * Data provider for \core_moodlelib_testcase::test_get_complete_user_data().
    4498. 

  4498.      *
    4499. 

  4499.      * @return array
    4500. 

  4500.      */
    4501. 

  4501.     public function user_data_provider() {
    4502. 

  4502.         return [
    4503. 

  4503.             'Fetch data using a valid username' => [
    4504. 

  4504.                 'username', 's1', true
    4505. 

  4505.             ],
    4506. 

  4506.             'Fetch data using a valid username, different case' => [
    4507. 

  4507.                 'username', 'S1', true
    4508. 

  4508.             ],
    4509. 

  4509.             'Fetch data using a valid username, different case for fieldname and value' => [
    4510. 

  4510.                 'USERNAME', 'S1', true
    4511. 

  4511.             ],
    4512. 

  4512.             'Fetch data using an invalid username' => [
    4513. 

  4513.                 'username', 's2', false
    4514. 

  4514.             ],
    4515. 

  4515.             'Fetch by email' => [
    4516. 

  4516.                 'email', 's1@example.com', true
    4517. 

  4517.             ],
    4518. 

  4518.             'Fetch data using a non-existent email' => [
    4519. 

  4519.                 'email', 's2@example.com', false
    4520. 

  4520.             ],
    4521. 

  4521.             'Fetch data using a non-existent email, throw exception' => [
    4522. 

  4522.                 'email', 's2@example.com', false, dml_missing_record_exception::class
    4523. 

  4523.             ],
    4524. 

  4524.             'Multiple accounts with the same email' => [
    4525. 

  4525.                 'email', 's1@example.com', false, 1
    4526. 

  4526.             ],
    4527. 

  4527.             'Multiple accounts with the same email, throw exception' => [
    4528. 

  4528.                 'email', 's1@example.com', false, 1, dml_multiple_records_exception::class
    4529. 

  4529.             ],
    4530. 

  4530.             'Fetch data using a valid user ID' => [
    4531. 

  4531.                 'id', true, true
    4532. 

  4532.             ],
    4533. 

  4533.             'Fetch data using a non-existent user ID' => [
    4534. 

  4534.                 'id', false, false
    4535. 

  4535.             ],
    4536. 

  4536.         ];
    4537. 

  4537.     }
    4538. 

  4538. 

  4539.     /**
    4540. 

  4540.      * Test for get_complete_user_data().
    4541. 

  4541.      *
    4542. 

  4542.      * @dataProvider user_data_provider
    4543. 

  4543.      * @param string $field The field to use for the query.
    4544. 

  4544.      * @param string|boolean $value The field value. When fetching by ID, set true to fetch valid user ID, false otherwise.
    4545. 

  4545.      * @param boolean $success Whether we expect for the fetch to succeed or return false.
    4546. 

  4546.      * @param int $allowaccountssameemail Value for $CFG->allowaccountssameemail.
    4547. 

  4547.      * @param string $expectedexception The exception to be expected.
    4548. 

  4548.      */
    4549. 

  4549.     public function test_get_complete_user_data($field, $value, $success, $allowaccountssameemail = 0, $expectedexception = '') {
    4550. 

  4550.         $this->resetAfterTest();
    4551. 

  4551. 

  4552.         // Set config settings we need for our environment.
    4553. 

  4553.         set_config('allowaccountssameemail', $allowaccountssameemail);
    4554. 

  4554. 

  4555.         // Generate the user data.
    4556. 

  4556.         $generator = $this->getDataGenerator();
    4557. 

  4557.         $userdata = [
    4558. 

  4558.             'username' => 's1',
    4559. 

  4559.             'email' => 's1@example.com',
    4560. 

  4560.         ];
    4561. 

  4561.         $user = $generator->create_user($userdata);
    4562. 

  4562. 

  4563.         if ($allowaccountssameemail) {
    4564. 

  4564.             // Create another user with the same email address.
    4565. 

  4565.             $generator->create_user(['email' => 's1@example.com']);
    4566. 

  4566.         }
    4567. 

  4567. 

  4568.         // Since the data provider can't know what user ID to use, do a special handling for ID field tests.
    4569. 

  4569.         if ($field === 'id') {
    4570. 

  4570.             if ($value) {
    4571. 

  4571.                 // Test for fetching data using a valid user ID. Use the generated user's ID.
    4572. 

  4572.                 $value = $user->id;
    4573. 

  4573.             } else {
    4574. 

  4574.                 // Test for fetching data using a non-existent user ID.
    4575. 

  4575.                 $value = $user->id + 1;
    4576. 

  4576.             }
    4577. 

  4577.         }
    4578. 

  4578. 

  4579.         // When an exception is expected.
    4580. 

  4580.         $throwexception = false;
    4581. 

  4581.         if ($expectedexception) {
    4582. 

  4582.             $this->expectException($expectedexception);
    4583. 

  4583.             $throwexception = true;
    4584. 

  4584.         }
    4585. 

  4585. 

  4586.         $fetcheduser = get_complete_user_data($field, $value, null, $throwexception);
    4587. 

  4587.         if ($success) {
    4588. 

  4588.             $this->assertEquals($user->id, $fetcheduser->id);
    4589. 

  4589.             $this->assertEquals($user->username, $fetcheduser->username);
    4590. 

  4590.             $this->assertEquals($user->email, $fetcheduser->email);
    4591. 

  4591.         } else {
    4592. 

  4592.             $this->assertFalse($fetcheduser);
    4593. 

  4593.         }
    4594. 

  4594.     }
    4595. 

  4595. 

  4596.     /**
    4597. 

  4597.      * Test for send_password_change_().
    4598. 

  4598.      */
    4599. 

  4599.     public function test_send_password_change_info() {
    4600. 

  4600.         $this->resetAfterTest();
    4601. 

  4601. 

  4602.         $user = $this->getDataGenerator()->create_user();
    4603. 

  4603. 

  4604.         $sink = $this->redirectEmails(); // Make sure we are redirecting emails.
    4605. 

  4605.         send_password_change_info($user);
    4606. 

  4606.         $result = $sink->get_messages();
    4607. 

  4607.         $sink->close();
    4608. 

  4608. 

  4609.         $this->assertContains('passwords cannot be reset on this site', quoted_printable_decode($result[0]->body));
    4610. 

  4610.     }
    4611. 

  4611. 

  4612.     /**
    4613. 

  4613.      * Test the get_time_interval_string for a range of inputs.
    4614. 

  4614.      *
    4615. 

  4615.      * @dataProvider get_time_interval_string_provider
    4616. 

  4616.      * @param int $time1 the time1 param.
    4617. 

  4617.      * @param int $time2 the time2 param.
    4618. 

  4618.      * @param string|null $format the format param.
    4619. 

  4619.      * @param string $expected the expected string.
    4620. 

  4620.      */
    4621. 

  4621.     public function test_get_time_interval_string(int $time1, int $time2, ?string $format, string $expected) {
    4622. 

  4622.         if (is_null($format)) {
    4623. 

  4623.             $this->assertEquals($expected, get_time_interval_string($time1, $time2));
    4624. 

  4624.         } else {
    4625. 

  4625.             $this->assertEquals($expected, get_time_interval_string($time1, $time2, $format));
    4626. 

  4626.         }
    4627. 

  4627.     }
    4628. 

  4628. 

  4629.     /**
    4630. 

  4630.      * Data provider for the test_get_time_interval_string() method.
    4631. 

  4631.      */
    4632. 

  4632.     public function get_time_interval_string_provider() {
    4633. 

  4633.         return [
    4634. 

  4634.             'Time is after the reference time by 1 minute, omitted format' => [
    4635. 

  4635.                 'time1' => 12345660,
    4636. 

  4636.                 'time2' => 12345600,
    4637. 

  4637.                 'format' => null,
    4638. 

  4638.                 'expected' => '0d 0h 1m'
    4639. 

  4639.             ],
    4640. 

  4640.             'Time is before the reference time by 1 minute, omitted format' => [
    4641. 

  4641.                 'time1' => 12345540,
    4642. 

  4642.                 'time2' => 12345600,
    4643. 

  4643.                 'format' => null,
    4644. 

  4644.                 'expected' => '0d 0h 1m'
    4645. 

  4645.             ],
    4646. 

  4646.             'Time is equal to the reference time, omitted format' => [
    4647. 

  4647.                 'time1' => 12345600,
    4648. 

  4648.                 'time2' => 12345600,
    4649. 

  4649.                 'format' => null,
    4650. 

  4650.                 'expected' => '0d 0h 0m'
    4651. 

  4651.             ],
    4652. 

  4652.             'Time is after the reference time by 1 minute, empty string format' => [
    4653. 

  4653.                 'time1' => 12345660,
    4654. 

  4654.                 'time2' => 12345600,
    4655. 

  4655.                 'format' => '',
    4656. 

  4656.                 'expected' => '0d 0h 1m'
    4657. 

  4657.             ],
    4658. 

  4658.             'Time is before the reference time by 1 minute, empty string format' => [
    4659. 

  4659.                 'time1' => 12345540,
    4660. 

  4660.                 'time2' => 12345600,
    4661. 

  4661.                 'format' => '',
    4662. 

  4662.                 'expected' => '0d 0h 1m'
    4663. 

  4663.             ],
    4664. 

  4664.             'Time is equal to the reference time, empty string format' => [
    4665. 

  4665.                 'time1' => 12345600,
    4666. 

  4666.                 'time2' => 12345600,
    4667. 

  4667.                 'format' => '',
    4668. 

  4668.                 'expected' => '0d 0h 0m'
    4669. 

  4669.             ],
    4670. 

  4670.             'Time is after the reference time by 1 minute, custom format' => [
    4671. 

  4671.                 'time1' => 12345660,
    4672. 

  4672.                 'time2' => 12345600,
    4673. 

  4673.                 'format' => '%R%adays %hhours %imins',
    4674. 

  4674.                 'expected' => '+0days 0hours 1mins'
    4675. 

  4675.             ],
    4676. 

  4676.             'Time is before the reference time by 1 minute, custom format' => [
    4677. 

  4677.                 'time1' => 12345540,
    4678. 

  4678.                 'time2' => 12345600,
    4679. 

  4679.                 'format' => '%R%adays %hhours %imins',
    4680. 

  4680.                 'expected' => '-0days 0hours 1mins'
    4681. 

  4681.             ],
    4682. 

  4682.             'Time is equal to the reference time, custom format' => [
    4683. 

  4683.                 'time1' => 12345600,
    4684. 

  4684.                 'time2' => 12345600,
    4685. 

  4685.                 'format' => '%R%adays %hhours %imins',
    4686. 

  4686.                 'expected' => '+0days 0hours 0mins'
    4687. 

  4687.             ],
    4688. 

  4688.         ];
    4689. 

  4689.     }
    4690. 

  4690. }
    4691. 

  4691.