question/bank/statistics/tests/helper_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 namespace qbank_statistics;
  18
  19 use core_question\statistics\questions\all_calculated_for_qubaid_condition;
  20 use mod_quiz\quiz_attempt;
  21 use quiz;
  22 use question_engine;
  23
  24 /**
  25  * Tests for question statistics.
  26  *
  27  * @package    qbank_statistics
  28  * @copyright  2021 Catalyst IT Australia Pty Ltd
  29  * @author     Nathan Nguyen <nathannguyen@catalyst-au.net>
  30  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  31  */
  32 class helper_test extends \advanced_testcase {
  33
  34     /**
  35      * Test quizzes that contain a specified question.
  36      *
  37      * @covers ::get_all_places_where_questions_were_attempted
  38      * @throws \coding_exception
  39      * @throws \dml_exception
  40      */
  41     public function test_get_all_places_where_questions_were_attempted(): void {
  42         $this->resetAfterTest();
  43         $this->setAdminUser();
  44
  45         $rcm = new \ReflectionMethod(helper::class, 'get_all_places_where_questions_were_attempted');
  46         $rcm->setAccessible(true);
  47
  48         // Create a course.
  49         $course = $this->getDataGenerator()->create_course();
  50
  51         // Create three quizzes.
  52         $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
  53         $quiz1 = $quizgenerator->create_instance([
  54             'course' => $course->id,
  55             'grade' => 100.0, 'sumgrades' => 2,
  56             'layout' => '1,2,0'
  57         ]);
  58         $quiz1context = \context_module::instance($quiz1->cmid);
  59
  60         $quiz2 = $quizgenerator->create_instance([
  61             'course' => $course->id,
  62             'grade' => 100.0, 'sumgrades' => 2,
  63             'layout' => '1,2,0'
  64         ]);
  65         $quiz2context = \context_module::instance($quiz2->cmid);
  66
  67         $quiz3 = $quizgenerator->create_instance([
  68             'course' => $course->id,
  69             'grade' => 100.0, 'sumgrades' => 2,
  70             'layout' => '1,2,0'
  71         ]);
  72         $quiz3context = \context_module::instance($quiz3->cmid);
  73
  74         // Create questions.
  75         /** @var \core_question_generator $questiongenerator */
  76         $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
  77         $cat = $questiongenerator->create_question_category();
  78         $question1 = $questiongenerator->create_question('shortanswer', null, array('category' => $cat->id));
  79         $question2 = $questiongenerator->create_question('numerical', null, array('category' => $cat->id));
  80
  81         // Add question 1 to quiz 1 and make an attempt.
  82         quiz_add_quiz_question($question1->id, $quiz1);
  83         // Quiz 1 attempt.
  84         $this->submit_quiz($quiz1, [1 => ['answer' => 'frog']]);
  85
  86         // Add questions 1 and 2 to quiz 2.
  87         quiz_add_quiz_question($question1->id, $quiz2);
  88         quiz_add_quiz_question($question2->id, $quiz2);
  89         $this->submit_quiz($quiz2, [1 => ['answer' => 'frog'], 2 => ['answer' => 10]]);
  90
  91         // Checking quizzes that use question 1.
  92         $q1places = $rcm->invoke(null, [$question1->id]);
  93         $this->assertCount(2, $q1places);
  94         $this->assertEquals((object) ['component' => 'mod_quiz', 'contextid' => $quiz1context->id], $q1places[0]);
  95         $this->assertEquals((object) ['component' => 'mod_quiz', 'contextid' => $quiz2context->id], $q1places[1]);
  96
  97         // Checking quizzes that contain question 2.
  98         $q2places = $rcm->invoke(null, [$question2->id]);
  99         $this->assertCount(1, $q2places);
 100         $this->assertEquals((object) ['component' => 'mod_quiz', 'contextid' => $quiz2context->id], $q2places[0]);
 101
 102         // Add a random question to quiz3.
 103         quiz_add_random_questions($quiz3, 0, $cat->id, 1, false);
 104         $this->submit_quiz($quiz3, [1 => ['answer' => 'willbewrong']]);
 105
 106         // Quiz 3 will now be in one of these arrays.
 107         $q1places = $rcm->invoke(null, [$question1->id]);
 108         $q2places = $rcm->invoke(null, [$question2->id]);
 109         if (count($q1places) == 3) {
 110             $newplace = end($q1places);
 111         } else {
 112             $newplace = end($q2places);
 113         }
 114         $this->assertEquals((object) ['component' => 'mod_quiz', 'contextid' => $quiz3context->id], $newplace);
 115     }
 116
 117     /**
 118      * Create 2 quizzes.
 119      *
 120      * @return array return 2 quizzes
 121      * @throws \coding_exception
 122      */
 123     private function prepare_quizzes(): array {
 124         // Create a course.
 125         $course = $this->getDataGenerator()->create_course();
 126
 127         // Make 2 quizzes.
 128         $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 129         $layout = '1,2,0,3,4,0';
 130         $quiz1 = $quizgenerator->create_instance([
 131             'course' => $course->id,
 132             'grade' => 100.0, 'sumgrades' => 2,
 133             'layout' => $layout
 134         ]);
 135
 136         $quiz2 = $quizgenerator->create_instance([
 137             'course' => $course->id,
 138             'grade' => 100.0, 'sumgrades' => 2,
 139             'layout' => $layout
 140         ]);
 141
 142         /** @var \core_question_generator $questiongenerator */
 143         $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
 144         $cat = $questiongenerator->create_question_category();
 145
 146         $page = 1;
 147         $questions = [];
 148         foreach (explode(',', $layout) as $slot) {
 149             if ($slot == 0) {
 150                 $page += 1;
 151                 continue;
 152             }
 153
 154             $question = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);
 155             $questions[$slot] = $question;
 156             quiz_add_quiz_question($question->id, $quiz1, $page);
 157             quiz_add_quiz_question($question->id, $quiz2, $page);
 158         }
 159
 160         return [$quiz1, $quiz2, $questions];
 161     }
 162
 163     /**
 164      * Submit quiz answers
 165      *
 166      * @param object $quiz
 167      * @param array $answers
 168      * @throws \moodle_exception
 169      */
 170     private function submit_quiz(object $quiz, array $answers): void {
 171         // Create user.
 172         $user = $this->getDataGenerator()->create_user();
 173         // Create attempt.
 174         $quizobj = quiz::create($quiz->id, $user->id);
 175         $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
 176         $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);
 177         $timenow = time();
 178         $attempt = quiz_create_attempt($quizobj, 1, null, $timenow, false, $user->id);
 179         quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow);
 180         quiz_attempt_save_started($quizobj, $quba, $attempt);
 181         // Submit attempt.
 182         $attemptobj = quiz_attempt::create($attempt->id);
 183         $attemptobj->process_submitted_actions($timenow, false, $answers);
 184         $attemptobj->process_finish($timenow, false);
 185     }
 186
 187     /**
 188      * Generate attempt answers.
 189      *
 190      * @param array $correctanswerflags array of 1 or 0
 191      * 1 : generate correct answer
 192      * 0 : generate wrong answer
 193      *
 194      * @return array
 195      */
 196     private function generate_attempt_answers(array $correctanswerflags): array {
 197         $attempt = [];
 198         for ($i = 1; $i <= 4; $i++) {
 199             if (isset($correctanswerflags) && $correctanswerflags[$i - 1] == 1) {
 200                 // Correct answer.
 201                 $attempt[$i] = ['answer' => 'frog'];
 202             } else {
 203                 $attempt[$i] = ['answer' => 'false'];
 204             }
 205         }
 206         return $attempt;
 207     }
 208
 209     /**
 210      *
 211      * Generate quizzes and submit answers.
 212      *
 213      * @param array $quiz1attempts quiz 1 attempts
 214      * @param array $quiz2attempts quiz 2 attempts
 215      *
 216      * @return array
 217      */
 218     private function prepare_and_submit_quizzes(array $quiz1attempts, array $quiz2attempts): array {
 219         list($quiz1, $quiz2, $questions) = $this->prepare_quizzes();
 220         // Submit attempts of quiz1.
 221         foreach ($quiz1attempts as $attempt) {
 222             $this->submit_quiz($quiz1, $attempt);
 223         }
 224         // Submit attempts of quiz2.
 225         foreach ($quiz2attempts as $attempt) {
 226             $this->submit_quiz($quiz2, $attempt);
 227         }
 228         return [$quiz1, $quiz2, $questions];
 229     }
 230
 231     /**
 232      * To use private helper::extract_item_value function.
 233      *
 234      * @param all_calculated_for_qubaid_condition $statistics the batch of statistics.
 235      * @param int $questionid a question id.
 236      * @param string $item ane of the field names in all_calculated_for_qubaid_condition, e.g. 'facility'.
 237      * @return float|null the required value.
 238      */
 239     private function extract_item_value(all_calculated_for_qubaid_condition $statistics,
 240                                         int $questionid, string $item): ?float {
 241         $rcm = new \ReflectionMethod(helper::class, 'extract_item_value');
 242         $rcm->setAccessible(true);
 243         return $rcm->invoke(null, $statistics, $questionid, $item);
 244     }
 245
 246     /**
 247      * To use private helper::load_statistics_for_place function (with mod_quiz component).
 248      *
 249      * @param \context $context the context to load the statistics for.
 250      * @return all_calculated_for_qubaid_condition|null question statistics.
 251      */
 252     private function load_quiz_statistics_for_place(\context $context): ?all_calculated_for_qubaid_condition {
 253         $rcm = new \ReflectionMethod(helper::class, 'load_statistics_for_place');
 254         $rcm->setAccessible(true);
 255         return $rcm->invoke(null, 'mod_quiz', $context);
 256     }
 257
 258     /**
 259      * Data provider for {@see test_load_question_facility()}.
 260      *
 261      * @return \Generator
 262      */
 263     public function load_question_facility_provider(): \Generator {
 264         yield 'Facility case 1' => [
 265             'Quiz 1 attempts' => [
 266                 $this->generate_attempt_answers([1, 0, 0, 0]),
 267             ],
 268             'Expected quiz 1 facilities' => ['100.00%', '0.00%', '0.00%', '0.00%'],
 269             'Quiz 2 attempts' => [
 270                 $this->generate_attempt_answers([1, 0, 0, 0]),
 271                 $this->generate_attempt_answers([1, 1, 0, 0]),
 272             ],
 273             'Expected quiz 2 facilities' => ['100.00%', '50.00%', '0.00%', '0.00%'],
 274             'Expected average facilities' => ['100.00%', '25.00%', '0.00%', '0.00%'],
 275         ];
 276         yield 'Facility case 2' => [
 277             'Quiz 1 attempts' => [
 278                 $this->generate_attempt_answers([1, 0, 0, 0]),
 279                 $this->generate_attempt_answers([1, 1, 0, 0]),
 280                 $this->generate_attempt_answers([1, 1, 1, 0]),
 281             ],
 282             'Expected quiz 1 facilities' => ['100.00%', '66.67%', '33.33%', '0.00%'],
 283             'Quiz 2 attempts' => [
 284                 $this->generate_attempt_answers([1, 0, 0, 0]),
 285                 $this->generate_attempt_answers([1, 1, 0, 0]),
 286                 $this->generate_attempt_answers([1, 1, 1, 0]),
 287                 $this->generate_attempt_answers([1, 1, 1, 1]),
 288             ],
 289             'Expected quiz 2 facilities' => ['100.00%', '75.00%', '50.00%', '25.00%'],
 290             'Expected average facilities' => ['100.00%', '70.83%', '41.67%', '12.50%'],
 291         ];
 292     }
 293
 294     /**
 295      * Test question facility
 296      *
 297      * @dataProvider load_question_facility_provider
 298      *
 299      * @param array $quiz1attempts quiz 1 attempts
 300      * @param array $expectedquiz1facilities expected quiz 1 facilities
 301      * @param array $quiz2attempts quiz 2 attempts
 302      * @param array $expectedquiz2facilities  expected quiz 2 facilities
 303      * @param array $expectedaveragefacilities expected average facilities
 304      */
 305     public function test_load_question_facility(
 306         array $quiz1attempts,
 307         array $expectedquiz1facilities,
 308         array $quiz2attempts,
 309         array $expectedquiz2facilities,
 310         array $expectedaveragefacilities)
 311     : void {
 312         $this->resetAfterTest();
 313
 314         list($quiz1, $quiz2, $questions) = $this->prepare_and_submit_quizzes($quiz1attempts, $quiz2attempts);
 315
 316         // Quiz 1 facilities.
 317         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz1->cmid));
 318         $quiz1facility1 = $this->extract_item_value($stats, $questions[1]->id, 'facility');
 319         $quiz1facility2 = $this->extract_item_value($stats, $questions[2]->id, 'facility');
 320         $quiz1facility3 = $this->extract_item_value($stats, $questions[3]->id, 'facility');
 321         $quiz1facility4 = $this->extract_item_value($stats, $questions[4]->id, 'facility');
 322
 323         $this->assertEquals($expectedquiz1facilities[0], helper::format_percentage($quiz1facility1));
 324         $this->assertEquals($expectedquiz1facilities[1], helper::format_percentage($quiz1facility2));
 325         $this->assertEquals($expectedquiz1facilities[2], helper::format_percentage($quiz1facility3));
 326         $this->assertEquals($expectedquiz1facilities[3], helper::format_percentage($quiz1facility4));
 327
 328         // Quiz 2 facilities.
 329         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz2->cmid));
 330         $quiz2facility1 = $this->extract_item_value($stats, $questions[1]->id, 'facility');
 331         $quiz2facility2 = $this->extract_item_value($stats, $questions[2]->id, 'facility');
 332         $quiz2facility3 = $this->extract_item_value($stats, $questions[3]->id, 'facility');
 333         $quiz2facility4 = $this->extract_item_value($stats, $questions[4]->id, 'facility');
 334
 335         $this->assertEquals($expectedquiz2facilities[0], helper::format_percentage($quiz2facility1));
 336         $this->assertEquals($expectedquiz2facilities[1], helper::format_percentage($quiz2facility2));
 337         $this->assertEquals($expectedquiz2facilities[2], helper::format_percentage($quiz2facility3));
 338         $this->assertEquals($expectedquiz2facilities[3], helper::format_percentage($quiz2facility4));
 339
 340         // Average question facilities.
 341         $averagefacility1 = helper::calculate_average_question_facility($questions[1]->id);
 342         $averagefacility2 = helper::calculate_average_question_facility($questions[2]->id);
 343         $averagefacility3 = helper::calculate_average_question_facility($questions[3]->id);
 344         $averagefacility4 = helper::calculate_average_question_facility($questions[4]->id);
 345
 346         $this->assertEquals($expectedaveragefacilities[0], helper::format_percentage($averagefacility1));
 347         $this->assertEquals($expectedaveragefacilities[1], helper::format_percentage($averagefacility2));
 348         $this->assertEquals($expectedaveragefacilities[2], helper::format_percentage($averagefacility3));
 349         $this->assertEquals($expectedaveragefacilities[3], helper::format_percentage($averagefacility4));
 350     }
 351
 352     /**
 353      * Data provider for {@see test_load_question_discriminative_efficiency()}.
 354      * @return \Generator
 355      */
 356     public function load_question_discriminative_efficiency_provider(): \Generator {
 357         yield 'Discriminative efficiency' => [
 358             'Quiz 1 attempts' => [
 359                 $this->generate_attempt_answers([1, 0, 0, 0]),
 360                 $this->generate_attempt_answers([1, 1, 0, 0]),
 361                 $this->generate_attempt_answers([1, 0, 1, 0]),
 362                 $this->generate_attempt_answers([1, 1, 1, 1]),
 363             ],
 364             'Expected quiz 1 discriminative efficiency' => ['N/A', '33.33%', '33.33%', '100.00%'],
 365             'Quiz 2 attempts' => [
 366                 $this->generate_attempt_answers([1, 1, 1, 1]),
 367                 $this->generate_attempt_answers([0, 0, 0, 0]),
 368                 $this->generate_attempt_answers([1, 0, 0, 1]),
 369                 $this->generate_attempt_answers([0, 1, 1, 0]),
 370             ],
 371             'Expected quiz 2 discriminative efficiency' => ['50.00%', '50.00%', '50.00%', '50.00%'],
 372             'Expected average discriminative efficiency' => ['50.00%', '41.67%', '41.67%', '75.00%'],
 373         ];
 374     }
 375
 376     /**
 377      * Test discriminative efficiency
 378      *
 379      * @dataProvider load_question_discriminative_efficiency_provider
 380      *
 381      * @param array $quiz1attempts quiz 1 attempts
 382      * @param array $expectedquiz1discriminativeefficiency expected quiz 1 discriminative efficiency
 383      * @param array $quiz2attempts quiz 2 attempts
 384      * @param array $expectedquiz2discriminativeefficiency expected quiz 2 discriminative efficiency
 385      * @param array $expectedaveragediscriminativeefficiency expected average discriminative efficiency
 386      */
 387     public function test_load_question_discriminative_efficiency(
 388         array $quiz1attempts,
 389         array $expectedquiz1discriminativeefficiency,
 390         array $quiz2attempts,
 391         array $expectedquiz2discriminativeefficiency,
 392         array $expectedaveragediscriminativeefficiency
 393     ): void {
 394         $this->resetAfterTest();
 395
 396         list($quiz1, $quiz2, $questions) = $this->prepare_and_submit_quizzes($quiz1attempts, $quiz2attempts);
 397
 398         // Quiz 1 discriminative efficiency.
 399         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz1->cmid));
 400         $discriminativeefficiency1 = $this->extract_item_value($stats, $questions[1]->id, 'discriminativeefficiency');
 401         $discriminativeefficiency2 = $this->extract_item_value($stats, $questions[2]->id, 'discriminativeefficiency');
 402         $discriminativeefficiency3 = $this->extract_item_value($stats, $questions[3]->id, 'discriminativeefficiency');
 403         $discriminativeefficiency4 = $this->extract_item_value($stats, $questions[4]->id, 'discriminativeefficiency');
 404
 405         $this->assertEquals($expectedquiz1discriminativeefficiency[0],
 406             helper::format_percentage($discriminativeefficiency1, false),
 407             "Failure in quiz 1 - question 1 discriminative efficiency");
 408         $this->assertEquals($expectedquiz1discriminativeefficiency[1],
 409             helper::format_percentage($discriminativeefficiency2, false),
 410             "Failure in quiz 1 - question 2 discriminative efficiency");
 411         $this->assertEquals($expectedquiz1discriminativeefficiency[2],
 412             helper::format_percentage($discriminativeefficiency3, false),
 413             "Failure in quiz 1 - question 3 discriminative efficiency");
 414         $this->assertEquals($expectedquiz1discriminativeefficiency[3],
 415             helper::format_percentage($discriminativeefficiency4, false),
 416             "Failure in quiz 1 - question 4 discriminative efficiency");
 417
 418         // Quiz 2 discriminative efficiency.
 419         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz2->cmid));
 420         $discriminativeefficiency1 = $this->extract_item_value($stats, $questions[1]->id, 'discriminativeefficiency');
 421         $discriminativeefficiency2 = $this->extract_item_value($stats, $questions[2]->id, 'discriminativeefficiency');
 422         $discriminativeefficiency3 = $this->extract_item_value($stats, $questions[3]->id, 'discriminativeefficiency');
 423         $discriminativeefficiency4 = $this->extract_item_value($stats, $questions[4]->id, 'discriminativeefficiency');
 424
 425         $this->assertEquals($expectedquiz2discriminativeefficiency[0],
 426             helper::format_percentage($discriminativeefficiency1, false),
 427             "Failure in quiz 2 - question 1 discriminative efficiency");
 428         $this->assertEquals($expectedquiz2discriminativeefficiency[1],
 429             helper::format_percentage($discriminativeefficiency2, false),
 430             "Failure in quiz 2 - question 2 discriminative efficiency");
 431         $this->assertEquals($expectedquiz2discriminativeefficiency[2],
 432             helper::format_percentage($discriminativeefficiency3, false),
 433             "Failure in quiz 2 - question 3 discriminative efficiency");
 434         $this->assertEquals($expectedquiz2discriminativeefficiency[3],
 435             helper::format_percentage($discriminativeefficiency4, false),
 436             "Failure in quiz 2 - question 4 discriminative efficiency");
 437
 438         // Average question discriminative efficiency.
 439         $avgdiscriminativeefficiency1 = helper::calculate_average_question_discriminative_efficiency($questions[1]->id);
 440         $avgdiscriminativeefficiency2 = helper::calculate_average_question_discriminative_efficiency($questions[2]->id);
 441         $avgdiscriminativeefficiency3 = helper::calculate_average_question_discriminative_efficiency($questions[3]->id);
 442         $avgdiscriminativeefficiency4 = helper::calculate_average_question_discriminative_efficiency($questions[4]->id);
 443
 444         $this->assertEquals($expectedaveragediscriminativeefficiency[0],
 445             helper::format_percentage($avgdiscriminativeefficiency1, false),
 446             "Failure in question 1 average discriminative efficiency");
 447         $this->assertEquals($expectedaveragediscriminativeefficiency[1],
 448             helper::format_percentage($avgdiscriminativeefficiency2, false),
 449             "Failure in question 2 average discriminative efficiency");
 450         $this->assertEquals($expectedaveragediscriminativeefficiency[2],
 451             helper::format_percentage($avgdiscriminativeefficiency3, false),
 452             "Failure in question 3 average discriminative efficiency");
 453         $this->assertEquals($expectedaveragediscriminativeefficiency[3],
 454             helper::format_percentage($avgdiscriminativeefficiency4, false),
 455             "Failure in question 4 average discriminative efficiency");
 456     }
 457
 458     /**
 459      * Data provider for {@see test_load_question_discrimination_index()}.
 460      * @return \Generator
 461      */
 462     public function load_question_discrimination_index_provider(): \Generator {
 463         yield 'Discrimination Index' => [
 464             'Quiz 1 attempts' => [
 465                 $this->generate_attempt_answers([1, 0, 0, 0]),
 466                 $this->generate_attempt_answers([1, 1, 0, 0]),
 467                 $this->generate_attempt_answers([1, 0, 1, 0]),
 468                 $this->generate_attempt_answers([1, 1, 1, 1]),
 469             ],
 470             'Expected quiz 1 Discrimination Index' => ['N/A', '30.15%', '30.15%', '81.65%'],
 471             'Quiz 2 attempts' => [
 472                 $this->generate_attempt_answers([1, 1, 1, 1]),
 473                 $this->generate_attempt_answers([0, 0, 0, 0]),
 474                 $this->generate_attempt_answers([1, 0, 0, 1]),
 475                 $this->generate_attempt_answers([0, 1, 1, 0]),
 476             ],
 477             'Expected quiz 2 discrimination Index' => ['44.72%', '44.72%', '44.72%', '44.72%'],
 478             'Expected average discrimination Index' => ['44.72%', '37.44%', '37.44%', '63.19%'],
 479         ];
 480     }
 481
 482     /**
 483      * Test discrimination index
 484      *
 485      * @dataProvider load_question_discrimination_index_provider
 486      *
 487      * @param array $quiz1attempts quiz 1 attempts
 488      * @param array $expectedquiz1discriminationindex expected quiz 1 discrimination index
 489      * @param array $quiz2attempts quiz 2 attempts
 490      * @param array $expectedquiz2discriminationindex expected quiz 2 discrimination index
 491      * @param array $expectedaveragediscriminationindex expected average discrimination index
 492      */
 493     public function test_load_question_discrimination_index(
 494         array $quiz1attempts,
 495         array $expectedquiz1discriminationindex,
 496         array $quiz2attempts,
 497         array $expectedquiz2discriminationindex,
 498         array $expectedaveragediscriminationindex
 499     ): void {
 500         $this->resetAfterTest();
 501
 502         list($quiz1, $quiz2, $questions) = $this->prepare_and_submit_quizzes($quiz1attempts, $quiz2attempts);
 503
 504         // Quiz 1 discrimination index.
 505         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz1->cmid));
 506         $discriminationindex1 = $this->extract_item_value($stats, $questions[1]->id, 'discriminationindex');
 507         $discriminationindex2 = $this->extract_item_value($stats, $questions[2]->id, 'discriminationindex');
 508         $discriminationindex3 = $this->extract_item_value($stats, $questions[3]->id, 'discriminationindex');
 509         $discriminationindex4 = $this->extract_item_value($stats, $questions[4]->id, 'discriminationindex');
 510
 511         $this->assertEquals($expectedquiz1discriminationindex[0],
 512             helper::format_percentage($discriminationindex1, false),
 513             "Failure in quiz 1 - question 1 discrimination index");
 514         $this->assertEquals($expectedquiz1discriminationindex[1],
 515             helper::format_percentage($discriminationindex2, false),
 516             "Failure in quiz 1 - question 2 discrimination index");
 517         $this->assertEquals($expectedquiz1discriminationindex[2],
 518             helper::format_percentage($discriminationindex3, false),
 519             "Failure in quiz 1 - question 3 discrimination index");
 520         $this->assertEquals($expectedquiz1discriminationindex[3],
 521             helper::format_percentage($discriminationindex4, false),
 522             "Failure in quiz 1 - question 4 discrimination index");
 523
 524         // Quiz 2 discrimination index.
 525         $stats = $this->load_quiz_statistics_for_place(\context_module::instance($quiz2->cmid));
 526         $discriminationindex1 = $this->extract_item_value($stats, $questions[1]->id, 'discriminationindex');
 527         $discriminationindex2 = $this->extract_item_value($stats, $questions[2]->id, 'discriminationindex');
 528         $discriminationindex3 = $this->extract_item_value($stats, $questions[3]->id, 'discriminationindex');
 529         $discriminationindex4 = $this->extract_item_value($stats, $questions[4]->id, 'discriminationindex');
 530
 531         $this->assertEquals($expectedquiz2discriminationindex[0],
 532             helper::format_percentage($discriminationindex1, false),
 533             "Failure in quiz 2 - question 1 discrimination index");
 534         $this->assertEquals($expectedquiz2discriminationindex[1],
 535             helper::format_percentage($discriminationindex2, false),
 536             "Failure in quiz 2 - question 2 discrimination index");
 537         $this->assertEquals($expectedquiz2discriminationindex[2],
 538             helper::format_percentage($discriminationindex3, false),
 539             "Failure in quiz 2 - question 3 discrimination index");
 540         $this->assertEquals($expectedquiz2discriminationindex[3],
 541             helper::format_percentage($discriminationindex4, false),
 542             "Failure in quiz 2 - question 4 discrimination index");
 543
 544         // Average question discrimination index.
 545         $avgdiscriminationindex1 = helper::calculate_average_question_discrimination_index($questions[1]->id);
 546         $avgdiscriminationindex2 = helper::calculate_average_question_discrimination_index($questions[2]->id);
 547         $avgdiscriminationindex3 = helper::calculate_average_question_discrimination_index($questions[3]->id);
 548         $avgdiscriminationindex4 = helper::calculate_average_question_discrimination_index($questions[4]->id);
 549
 550         $this->assertEquals($expectedaveragediscriminationindex[0],
 551             helper::format_percentage($avgdiscriminationindex1, false),
 552             "Failure in question 1 average discrimination index");
 553         $this->assertEquals($expectedaveragediscriminationindex[1],
 554             helper::format_percentage($avgdiscriminationindex2, false),
 555             "Failure in question 2 average discrimination index");
 556         $this->assertEquals($expectedaveragediscriminationindex[2],
 557             helper::format_percentage($avgdiscriminationindex3, false),
 558             "Failure in question 3 average discrimination index");
 559         $this->assertEquals($expectedaveragediscriminationindex[3],
 560             helper::format_percentage($avgdiscriminationindex4, false),
 561             "Failure in question 4 average discrimination index");
 562     }
 563 }