<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.


< /**
<  * Quiz attempt walk through tests.
<  *
<  * @package    mod_quiz
<  * @category   phpunit
<  * @copyright  2013 The Open University
<  * @author     Jamie Pratt <me@jamiep.org>
<  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
<  */



> namespace mod_quiz;
> 
> use moodle_url;
> use question_bank;
> use question_engine;



defined('MOODLE_INTERNAL') || die();

global $CFG;
require_once($CFG->dirroot . '/mod/quiz/locallib.php');

/**
 * Quiz attempt walk through.
 *
 * @package    mod_quiz

<  * @category   phpunit



>  * @category  test


 * @copyright  2013 The Open University
 * @author     Jamie Pratt <me@jamiep.org>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

>  * @covers \mod_quiz\quiz_attempt


 */

< class mod_quiz_attempt_walkthrough_testcase extends advanced_testcase {



> class attempt_walkthrough_test extends \advanced_testcase {



    /**
     * Create a quiz with questions and walk through a quiz attempt.
     */
    public function test_quiz_attempt_walkthrough() {
        global $SITE;

        $this->resetAfterTest(true);

        // Make a quiz.
        $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');


<         $quiz = $quizgenerator->create_instance(array('course'=>$SITE->id, 'questionsperpage' => 0, 'grade' => 100.0,
<                                                       'sumgrades' => 2));



>         $quiz = $quizgenerator->create_instance(['course' => $SITE->id, 'questionsperpage' => 0, 'grade' => 100.0,
>                                                       'sumgrades' => 3]);



        // Create a couple of questions.
        $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');

        $cat = $questiongenerator->create_question_category();

<         $saq = $questiongenerator->create_question('shortanswer', null, array('category' => $cat->id));
<         $numq = $questiongenerator->create_question('numerical', null, array('category' => $cat->id));



>         $saq = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);
>         $numq = $questiongenerator->create_question('numerical', null, ['category' => $cat->id]);
>         $matchq = $questiongenerator->create_question('match', null, ['category' => $cat->id]);
>         $description = $questiongenerator->create_question('description', null, ['category' => $cat->id]);



        // Add them to the quiz.
        quiz_add_quiz_question($saq->id, $quiz);
        quiz_add_quiz_question($numq->id, $quiz);

>         quiz_add_quiz_question($matchq->id, $quiz);

>         quiz_add_quiz_question($description->id, $quiz);


        // Make a user to do the quiz.
        $user1 = $this->getDataGenerator()->create_user();


<         $quizobj = quiz::create($quiz->id, $user1->id);



>         $quizobj = quiz_settings::create($quiz->id, $user1->id);



        // Start the attempt.
        $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
        $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);

        $timenow = time();
        $attempt = quiz_create_attempt($quizobj, 1, false, $timenow, false, $user1->id);

        quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow);

<         $this->assertEquals('1,2,0', $attempt->layout);



>         $this->assertEquals('1,2,3,4,0', $attempt->layout);



        quiz_attempt_save_started($quizobj, $quba, $attempt);

        // Process some responses from the student.
        $attemptobj = quiz_attempt::create($attempt->id);
        $this->assertFalse($attemptobj->has_response_to_at_least_one_graded_question());

>         // The student has not answered any questions.

>         $this->assertEquals(3, $attemptobj->get_number_of_unanswered_questions());
        $prefix1 = $quba->get_field_prefix(1);
> 
        $prefix2 = $quba->get_field_prefix(2);
>         $tosubmit = [1 => ['answer' => 'frog'],

>                           2 => ['answer' => '3.14']];
        $tosubmit = array(1 => array('answer' => 'frog'),
> 
                          2 => array('answer' => '3.14'));
>         $attemptobj->process_submitted_actions($timenow, false, $tosubmit);

>         // The student has answered two questions, and only one remaining.
        $attemptobj->process_submitted_actions($timenow, false, $tosubmit);
>         $this->assertEquals(1, $attemptobj->get_number_of_unanswered_questions());

> 
        // Finish the attempt.
>         $tosubmit = [
        $attemptobj = quiz_attempt::create($attempt->id);
>             3 => [
        $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
>                 'frog' => 'amphibian',
        $attemptobj->process_finish($timenow, false);
>                 'cat' => 'mammal',

>                 'newt' => ''
        // Re-load quiz attempt data.
>             ]
        $attemptobj = quiz_attempt::create($attempt->id);
>         ];



<         $prefix1 = $quba->get_field_prefix(1);
<         $prefix2 = $quba->get_field_prefix(2);



>         $attemptobj->process_submitted_actions($timenow, false, $tosubmit);
>         // The student has answered three questions but one is invalid, so there is still one remaining.
>         $this->assertEquals(1, $attemptobj->get_number_of_unanswered_questions());



<         $tosubmit = array(1 => array('answer' => 'frog'),
<                           2 => array('answer' => '3.14'));



>         $tosubmit = [
>             3 => [
>                 'frog' => 'amphibian',
>                 'cat' => 'mammal',
>                 'newt' => 'amphibian'
>             ]
>         ];


        $this->assertEquals(true, $attemptobj->is_finished());

>         // The student has answered three questions, so there are no remaining.
        $this->assertEquals($timenow, $attemptobj->get_submitted_date());
>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());



<         $this->assertEquals(2, $attemptobj->get_sum_marks());



>         $this->assertEquals(3, $attemptobj->get_sum_marks());


        $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());

>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());



        // Check quiz grades.
        $grades = quiz_get_user_grades($quiz, $user1->id);
        $grade = array_shift($grades);
        $this->assertEquals(100.0, $grade->rawgrade);

        // Check grade book.
        $gradebookgrades = grade_get_grades($SITE->id, 'mod', 'quiz', $quiz->id, $user1->id);
        $gradebookitem = array_shift($gradebookgrades->items);
        $gradebookgrade = array_shift($gradebookitem->grades);
        $this->assertEquals(100, $gradebookgrade->grade);
    }

    /**

>      * Create a quiz containing one question and a close time.
     * Create a quiz with a random as well as other questions and walk through quiz attempts.
>      *
     */
>      * The question is the standard shortanswer test question.
    public function test_quiz_with_random_question_attempt_walkthrough() {
>      * The quiz is set to close 1 hour from now.
        global $SITE;
>      * The quiz is set to use a grade period of 1 hour once time expires.

>      *
        $this->resetAfterTest(true);
>      * @param string $overduehandling value for the overduehandling quiz setting.
        question_bank::get_qtype('random')->clear_caches_before_testing();
>      * @return \stdClass the quiz that was created.

>      */
        $this->setAdminUser();
>     protected function create_quiz_with_one_question(string $overduehandling = 'graceperiod'): \stdClass {

>         global $SITE;
        // Make a quiz.
>         $this->resetAfterTest();
        $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
> 

>         // Make a quiz.
        $quiz = $quizgenerator->create_instance(array('course' => $SITE->id, 'questionsperpage' => 2, 'grade' => 100.0,
>         $timeclose = time() + HOURSECS;
                                                      'sumgrades' => 4));
>         $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');

> 
        $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
>         $quiz = $quizgenerator->create_instance(

>                 ['course' => $SITE->id, 'timeclose' => $timeclose,
        // Add two questions to question category.
>                         'overduehandling' => $overduehandling, 'graceperiod' => HOURSECS]);
        $cat = $questiongenerator->create_question_category();
> 
        $saq = $questiongenerator->create_question('shortanswer', null, array('category' => $cat->id));
>         // Create a question.
        $numq = $questiongenerator->create_question('numerical', null, array('category' => $cat->id));
>         /** @var \core_question_generator $questiongenerator */

>         $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
        // Add random question to the quiz.
>         $cat = $questiongenerator->create_question_category();
        quiz_add_random_questions($quiz, 0, $cat->id, 1, false);
>         $saq = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);

> 
        // Make another category.
>         // Add them to the quiz.
        $cat2 = $questiongenerator->create_question_category();
>         $quizobj = quiz_settings::create($quiz->id);
        $match = $questiongenerator->create_question('match', null, array('category' => $cat->id));
>         quiz_add_quiz_question($saq->id, $quiz, 0, 1);

>         $quizobj->get_grade_calculator()->recompute_quiz_sumgrades();
        quiz_add_quiz_question($match->id, $quiz, 0);
> 

>         return $quiz;
        $multichoicemulti = $questiongenerator->create_question('multichoice', 'two_of_four', array('category' => $cat->id));
>     }

> 
        quiz_add_quiz_question($multichoicemulti->id, $quiz, 0);
>     public function test_quiz_attempt_walkthrough_submit_time_recorded_correctly_when_overdue() {

> 
        $multichoicesingle = $questiongenerator->create_question('multichoice', 'one_of_four', array('category' => $cat->id));
>         $quiz = $this->create_quiz_with_one_question();

> 
        quiz_add_quiz_question($multichoicesingle->id, $quiz, 0);
>         // Make a user to do the quiz.

>         $user = $this->getDataGenerator()->create_user();
        foreach (array($saq->id => 'frog', $numq->id => '3.14') as $randomqidtoselect => $randqanswer) {
>         $this->setUser($user);
            // Make a new user to do the quiz each loop.
>         $quizobj = quiz_settings::create($quiz->id, $user->id);
            $user1 = $this->getDataGenerator()->create_user();
> 
            $this->setUser($user1);
>         // Start the attempt.

>         $attempt = quiz_prepare_and_start_new_attempt($quizobj, 1, null);
            $quizobj = quiz::create($quiz->id, $user1->id);
> 

>         // Process some responses from the student.
            // Start the attempt.
>         $attemptobj = quiz_attempt::create($attempt->id);
            $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
>         $this->assertEquals(1, $attemptobj->get_number_of_unanswered_questions());
            $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);
>         $attemptobj->process_submitted_actions($quiz->timeclose - 30 * MINSECS, false, [1 => ['answer' => 'frog']]);

> 
            $timenow = time();
>         // Attempt goes overdue (e.g. if cron ran).
            $attempt = quiz_create_attempt($quizobj, 1, false, $timenow);
>         $attemptobj = quiz_attempt::create($attempt->id);

>         $attemptobj->process_going_overdue($quiz->timeclose + 2 * get_config('quiz', 'graceperiodmin'), false);
            quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow, array(1 => $randomqidtoselect));
> 
            $this->assertEquals('1,2,0,3,4,0', $attempt->layout);
>         // Verify the attempt state.

>         $attemptobj = quiz_attempt::create($attempt->id);
            quiz_attempt_save_started($quizobj, $quba, $attempt);
>         $this->assertEquals(1, $attemptobj->get_attempt_number());

>         $this->assertEquals(false, $attemptobj->is_finished());
            // Process some responses from the student.
>         $this->assertEquals(0, $attemptobj->get_submitted_date());
            $attemptobj = quiz_attempt::create($attempt->id);
>         $this->assertEquals($user->id, $attemptobj->get_userid());
            $this->assertFalse($attemptobj->has_response_to_at_least_one_graded_question());
>         $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());

>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());
            $tosubmit = array();
> 
            $selectedquestionid = $quba->get_question_attempt(1)->get_question_id();
>         // Student submits the attempt during the grace period.
            $tosubmit[1] = array('answer' => $randqanswer);
>         $attemptobj = quiz_attempt::create($attempt->id);
            $tosubmit[2] = array(
>         $attemptobj->process_attempt($quiz->timeclose + 30 * MINSECS, true, false, 1);
                'frog' => 'amphibian',
> 
                'cat'  => 'mammal',
>         // Verify the attempt state.
                'newt' => 'amphibian');
>         $attemptobj = quiz_attempt::create($attempt->id);
            $tosubmit[3] = array('One' => '1', 'Two' => '0', 'Three' => '1', 'Four' => '0'); // First and third choice.
>         $this->assertEquals(1, $attemptobj->get_attempt_number());
            $tosubmit[4] = array('answer' => 'One'); // The first choice.
>         $this->assertEquals(true, $attemptobj->is_finished());

>         $this->assertEquals($quiz->timeclose + 30 * MINSECS, $attemptobj->get_submitted_date());
            $attemptobj->process_submitted_actions($timenow, false, $tosubmit);
>         $this->assertEquals($user->id, $attemptobj->get_userid());

>         $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
            // Finish the attempt.
>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());
            $attemptobj = quiz_attempt::create($attempt->id);
>     }
            $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
> 
            $attemptobj->process_finish($timenow, false);
>     public function test_quiz_attempt_walkthrough_close_time_extended_at_last_minute() {

>         global $DB;
            // Re-load quiz attempt data.
> 
            $attemptobj = quiz_attempt::create($attempt->id);
>         $quiz = $this->create_quiz_with_one_question();

>         $originaltimeclose = $quiz->timeclose;
            // Check that results are stored as expected.
> 
            $this->assertEquals(1, $attemptobj->get_attempt_number());
>         // Make a user to do the quiz.
            $this->assertEquals(4, $attemptobj->get_sum_marks());
>         $user = $this->getDataGenerator()->create_user();
            $this->assertEquals(true, $attemptobj->is_finished());
>         $this->setUser($user);
            $this->assertEquals($timenow, $attemptobj->get_submitted_date());
>         $quizobj = quiz_settings::create($quiz->id, $user->id);
            $this->assertEquals($user1->id, $attemptobj->get_userid());
> 
            $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
>         // Start the attempt.

>         $attempt = quiz_prepare_and_start_new_attempt($quizobj, 1, null);
            // Check quiz grades.
> 
            $grades = quiz_get_user_grades($quiz, $user1->id);
>         // Process some responses from the student during the attempt.
            $grade = array_shift($grades);
>         $attemptobj = quiz_attempt::create($attempt->id);
            $this->assertEquals(100.0, $grade->rawgrade);
>         $attemptobj->process_submitted_actions($originaltimeclose - 30 * MINSECS, false, [1 => ['answer' => 'frog']]);

> 
            // Check grade book.
>         // Teacher edits the quiz to extend the time-limit by one minute.
            $gradebookgrades = grade_get_grades($SITE->id, 'mod', 'quiz', $quiz->id, $user1->id);
>         $DB->set_field('quiz', 'timeclose', $originaltimeclose + MINSECS, ['id' => $quiz->id]);
            $gradebookitem = array_shift($gradebookgrades->items);
>         \course_modinfo::clear_instance_cache($quiz->course);
            $gradebookgrade = array_shift($gradebookitem->grades);
> 
            $this->assertEquals(100, $gradebookgrade->grade);
>         // Timer expires in the student browser and thinks it is time to submit the quiz.
        }
>         // This sets $finishattempt to false - since the student did not click the button, and $timeup to true.
    }
>         $attemptobj = quiz_attempt::create($attempt->id);

>         $attemptobj->process_attempt($originaltimeclose, false, true, 1);

> 
    public function get_correct_response_for_variants() {
>         // Verify the attempt state - the $timeup was ignored becuase things have changed server-side.
        return array(array(1, 9.9), array(2, 8.5), array(5, 14.2), array(10, 6.8, true));
>         $attemptobj = quiz_attempt::create($attempt->id);
    }
>         $this->assertEquals(1, $attemptobj->get_attempt_number());

>         $this->assertFalse($attemptobj->is_finished());
    protected $quizwithvariants = null;
>         $this->assertEquals(quiz_attempt::IN_PROGRESS, $attemptobj->get_state());

>         $this->assertEquals(0, $attemptobj->get_submitted_date());
    /**
>         $this->assertEquals($user->id, $attemptobj->get_userid());
     * Create a quiz with a single question with variants and walk through quiz attempts.
>     }
     *
> 
     * @dataProvider get_correct_response_for_variants
>     /**



<         $quiz = $quizgenerator->create_instance(array('course' => $SITE->id, 'questionsperpage' => 2, 'grade' => 100.0,
<                                                       'sumgrades' => 4));



>         $quiz = $quizgenerator->create_instance(['course' => $SITE->id, 'questionsperpage' => 2, 'grade' => 100.0,
>                                                       'sumgrades' => 4]);



<         $saq = $questiongenerator->create_question('shortanswer', null, array('category' => $cat->id));
<         $numq = $questiongenerator->create_question('numerical', null, array('category' => $cat->id));



>         $saq = $questiongenerator->create_question('shortanswer', null, ['category' => $cat->id]);
>         $numq = $questiongenerator->create_question('numerical', null, ['category' => $cat->id]);



<         $match = $questiongenerator->create_question('match', null, array('category' => $cat->id));



>         $match = $questiongenerator->create_question('match', null, ['category' => $cat->id]);



<         $multichoicemulti = $questiongenerator->create_question('multichoice', 'two_of_four', array('category' => $cat->id));



>         $multichoicemulti = $questiongenerator->create_question('multichoice', 'two_of_four', ['category' => $cat->id]);



<         $multichoicesingle = $questiongenerator->create_question('multichoice', 'one_of_four', array('category' => $cat->id));



>         $multichoicesingle = $questiongenerator->create_question('multichoice', 'one_of_four', ['category' => $cat->id]);



<         foreach (array($saq->id => 'frog', $numq->id => '3.14') as $randomqidtoselect => $randqanswer) {



>         foreach ([$saq->id => 'frog', $numq->id => '3.14'] as $randomqidtoselect => $randqanswer) {



<             $quizobj = quiz::create($quiz->id, $user1->id);



>             $quizobj = quiz_settings::create($quiz->id, $user1->id);



<             quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow, array(1 => $randomqidtoselect));



>             quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow, [1 => $randomqidtoselect]);


            $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');

>             $this->assertEquals(4, $attemptobj->get_number_of_unanswered_questions());



<             $tosubmit = array();



>             $tosubmit = [];



<             $tosubmit[1] = array('answer' => $randqanswer);
<             $tosubmit[2] = array(



>             $tosubmit[1] = ['answer' => $randqanswer];
>             $tosubmit[2] = [



<                 'newt' => 'amphibian');
<             $tosubmit[3] = array('One' => '1', 'Two' => '0', 'Three' => '1', 'Four' => '0'); // First and third choice.
<             $tosubmit[4] = array('answer' => 'One'); // The first choice.



>                 'newt' => 'amphibian'];
>             $tosubmit[3] = ['One' => '1', 'Two' => '0', 'Three' => '1', 'Four' => '0']; // First and third choice.
>             $tosubmit[4] = ['answer' => 'One']; // The first choice.


            $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');

>             $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());




>             $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());



<         return array(array(1, 9.9), array(2, 8.5), array(5, 14.2), array(10, 6.8, true));



>         return [[1, 9.9], [2, 8.5], [5, 14.2], [10, 6.8, true]];



<             $this->quizwithvariants = $quizgenerator->create_instance(array('course'=>$SITE->id,



>             $this->quizwithvariants = $quizgenerator->create_instance(['course' => $SITE->id,



<                                                                             'sumgrades' => 1));



>                                                                             'sumgrades' => 1]);



<             $calc = $questiongenerator->create_question('calculatedsimple', 'sumwithvariants', array('category' => $cat->id));



>             $calc = $questiongenerator->create_question('calculatedsimple', 'sumwithvariants', ['category' => $cat->id]);




        // Make a new user to do the quiz.
        $user1 = $this->getDataGenerator()->create_user();
        $this->setUser($user1);

<         $quizobj = quiz::create($this->quizwithvariants->id, $user1->id);



>         $quizobj = quiz_settings::create($this->quizwithvariants->id, $user1->id);



        // Start the attempt.
        $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
        $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);

        $timenow = time();
        $attempt = quiz_create_attempt($quizobj, 1, false, $timenow);

        // Select variant.

<         quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow, array(), array(1 => $variantno));



>         quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow, [], [1 => $variantno]);


        $this->assertEquals('1,0', $attempt->layout);
        quiz_attempt_save_started($quizobj, $quba, $attempt);

        // Process some responses from the student.
        $attemptobj = quiz_attempt::create($attempt->id);
        $this->assertFalse($attemptobj->has_response_to_at_least_one_graded_question());

>         $this->assertEquals(1, $attemptobj->get_number_of_unanswered_questions());




<         $tosubmit = array(1 => array('answer' => $correctresponse));



>         $tosubmit = [1 => ['answer' => $correctresponse]];


        $attemptobj->process_submitted_actions($timenow, false, $tosubmit);

        // Finish the attempt.
        $attemptobj = quiz_attempt::create($attempt->id);
        $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());

>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());



        $attemptobj->process_finish($timenow, false);

        // Re-load quiz attempt data.
        $attemptobj = quiz_attempt::create($attempt->id);

        // Check that results are stored as expected.
        $this->assertEquals(1, $attemptobj->get_attempt_number());
        $this->assertEquals(1, $attemptobj->get_sum_marks());
        $this->assertEquals(true, $attemptobj->is_finished());
        $this->assertEquals($timenow, $attemptobj->get_submitted_date());
        $this->assertEquals($user1->id, $attemptobj->get_userid());
        $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());

>         $this->assertEquals(0, $attemptobj->get_number_of_unanswered_questions());



        // Check quiz grades.
        $grades = quiz_get_user_grades($this->quizwithvariants, $user1->id);
        $grade = array_shift($grades);
        $this->assertEquals(100.0, $grade->rawgrade);

        // Check grade book.
        $gradebookgrades = grade_get_grades($SITE->id, 'mod', 'quiz', $this->quizwithvariants->id, $user1->id);
        $gradebookitem = array_shift($gradebookgrades->items);
        $gradebookgrade = array_shift($gradebookitem->grades);
        $this->assertEquals(100, $gradebookgrade->grade);

>     }
    }
> 
}
>     public function test_quiz_attempt_walkthrough_abandoned_attempt_reopened_with_timelimit_override() {
>         global $DB;
> 
>         $quiz = $this->create_quiz_with_one_question('autoabandon');
>         $originaltimeclose = $quiz->timeclose;
> 
>         // Make a user to do the quiz.
>         $user = $this->getDataGenerator()->create_user();
>         $this->setUser($user);
>         $quizobj = quiz_settings::create($quiz->id, $user->id);
> 
>         // Start the attempt.
>         $attempt = quiz_prepare_and_start_new_attempt($quizobj, 1, null);
> 
>         // Process some responses from the student during the attempt.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $attemptobj->process_submitted_actions($originaltimeclose - 30 * MINSECS, false, [1 => ['answer' => 'frog']]);
> 
>         // Student leaves, so cron closes the attempt when time expires.
>         $attemptobj->process_abandon($originaltimeclose + 5 * MINSECS, false);
> 
>         // Verify the attempt state.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $this->assertEquals(quiz_attempt::ABANDONED, $attemptobj->get_state());
>         $this->assertEquals(0, $attemptobj->get_submitted_date());
>         $this->assertEquals($user->id, $attemptobj->get_userid());
> 
>         // The teacher feels kind, so adds an override for the student, and re-opens the attempt.
>         $sink = $this->redirectEvents();
>         $overriddentimeclose = $originaltimeclose + HOURSECS;
>         $DB->insert_record('quiz_overrides', [
>             'quiz' => $quiz->id,
>             'userid' => $user->id,
>             'timeclose' => $overriddentimeclose,
>         ]);
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $reopentime = $originaltimeclose + 10 * MINSECS;
>         $attemptobj->process_reopen_abandoned($reopentime);
> 
>         // Verify the attempt state.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $this->assertEquals(1, $attemptobj->get_attempt_number());
>         $this->assertFalse($attemptobj->is_finished());
>         $this->assertEquals(quiz_attempt::IN_PROGRESS, $attemptobj->get_state());
>         $this->assertEquals(0, $attemptobj->get_submitted_date());
>         $this->assertEquals($user->id, $attemptobj->get_userid());
>         $this->assertEquals($overriddentimeclose,
>                 $attemptobj->get_access_manager($reopentime)->get_end_time($attemptobj->get_attempt()));
> 
>         // Verify this was logged correctly.
>         $events = $sink->get_events();
>         $this->assertCount(1, $events);
> 
>         $reopenedevent = array_shift($events);
>         $this->assertInstanceOf('\mod_quiz\event\attempt_reopened', $reopenedevent);
>         $this->assertEquals($attemptobj->get_context(), $reopenedevent->get_context());
>         $this->assertEquals(new moodle_url('/mod/quiz/review.php', ['attempt' => $attemptobj->get_attemptid()]),
>                 $reopenedevent->get_url());
>     }
> 
>     public function test_quiz_attempt_walkthrough_abandoned_attempt_reopened_after_close_time() {
>         $quiz = $this->create_quiz_with_one_question('autoabandon');
>         $originaltimeclose = $quiz->timeclose;
> 
>         // Make a user to do the quiz.
>         $user = $this->getDataGenerator()->create_user();
>         $this->setUser($user);
>         $quizobj = quiz_settings::create($quiz->id, $user->id);
> 
>         // Start the attempt.
>         $attempt = quiz_prepare_and_start_new_attempt($quizobj, 1, null);
> 
>         // Process some responses from the student during the attempt.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $attemptobj->process_submitted_actions($originaltimeclose - 30 * MINSECS, false, [1 => ['answer' => 'frog']]);
> 
>         // Student leaves, so cron closes the attempt when time expires.
>         $attemptobj->process_abandon($originaltimeclose + 5 * MINSECS, false);
> 
>         // Verify the attempt state.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $this->assertEquals(quiz_attempt::ABANDONED, $attemptobj->get_state());
>         $this->assertEquals(0, $attemptobj->get_submitted_date());
>         $this->assertEquals($user->id, $attemptobj->get_userid());
> 
>         // The teacher reopens the attempt without granting more time, so previously submitted responess are graded.
>         $sink = $this->redirectEvents();
>         $reopentime = $originaltimeclose + 10 * MINSECS;
>         $attemptobj->process_reopen_abandoned($reopentime);
> 
>         // Verify the attempt state.
>         $attemptobj = quiz_attempt::create($attempt->id);
>         $this->assertEquals(1, $attemptobj->get_attempt_number());
>         $this->assertTrue($attemptobj->is_finished());
>         $this->assertEquals(quiz_attempt::FINISHED, $attemptobj->get_state());
>         $this->assertEquals($originaltimeclose, $attemptobj->get_submitted_date());
>         $this->assertEquals($user->id, $attemptobj->get_userid());
>         $this->assertEquals(1, $attemptobj->get_sum_marks());
> 
>         // Verify this was logged correctly - there are some gradebook events between the two we want to check.
>         $events = $sink->get_events();
>         $this->assertGreaterThanOrEqual(2, $events);
> 
>         $reopenedevent = array_shift($events);
>         $this->assertInstanceOf('\mod_quiz\event\attempt_reopened', $reopenedevent);
>         $this->assertEquals($attemptobj->get_context(), $reopenedevent->get_context());
>         $this->assertEquals(new moodle_url('/mod/quiz/review.php', ['attempt' => $attemptobj->get_attemptid()]),
>                 $reopenedevent->get_url());
> 
>         $submittedevent = array_pop($events);
>         $this->assertInstanceOf('\mod_quiz\event\attempt_submitted', $submittedevent);
>         $this->assertEquals($attemptobj->get_context(), $submittedevent->get_context());
>         $this->assertEquals(new moodle_url('/mod/quiz/review.php', ['attempt' => $attemptobj->get_attemptid()]),
>                 $submittedevent->get_url());