[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/mod/quiz/tests/ -> lib_test.php (source)

   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  /**
  18   * Unit tests for (some of) mod/quiz/locallib.php.
  19   *
  20   * @package    mod_quiz
  21   * @category   test
  22   * @copyright  2008 The Open University
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
  24   */
  25  
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  global $CFG;
  30  require_once($CFG->dirroot . '/mod/quiz/lib.php');
  31  
  32  /**
  33   * @copyright  2008 The Open University
  34   * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
  35   */
  36  class mod_quiz_lib_testcase extends advanced_testcase {
  37      public function test_quiz_has_grades() {
  38          $quiz = new stdClass();
  39          $quiz->grade = '100.0000';
  40          $quiz->sumgrades = '100.0000';
  41          $this->assertTrue(quiz_has_grades($quiz));
  42          $quiz->sumgrades = '0.0000';
  43          $this->assertFalse(quiz_has_grades($quiz));
  44          $quiz->grade = '0.0000';
  45          $this->assertFalse(quiz_has_grades($quiz));
  46          $quiz->sumgrades = '100.0000';
  47          $this->assertFalse(quiz_has_grades($quiz));
  48      }
  49  
  50      public function test_quiz_format_grade() {
  51          $quiz = new stdClass();
  52          $quiz->decimalpoints = 2;
  53          $this->assertEquals(quiz_format_grade($quiz, 0.12345678), format_float(0.12, 2));
  54          $this->assertEquals(quiz_format_grade($quiz, 0), format_float(0, 2));
  55          $this->assertEquals(quiz_format_grade($quiz, 1.000000000000), format_float(1, 2));
  56          $quiz->decimalpoints = 0;
  57          $this->assertEquals(quiz_format_grade($quiz, 0.12345678), '0');
  58      }
  59  
  60      public function test_quiz_get_grade_format() {
  61          $quiz = new stdClass();
  62          $quiz->decimalpoints = 2;
  63          $this->assertEquals(quiz_get_grade_format($quiz), 2);
  64          $this->assertEquals($quiz->questiondecimalpoints, -1);
  65          $quiz->questiondecimalpoints = 2;
  66          $this->assertEquals(quiz_get_grade_format($quiz), 2);
  67          $quiz->decimalpoints = 3;
  68          $quiz->questiondecimalpoints = -1;
  69          $this->assertEquals(quiz_get_grade_format($quiz), 3);
  70          $quiz->questiondecimalpoints = 4;
  71          $this->assertEquals(quiz_get_grade_format($quiz), 4);
  72      }
  73  
  74      public function test_quiz_format_question_grade() {
  75          $quiz = new stdClass();
  76          $quiz->decimalpoints = 2;
  77          $quiz->questiondecimalpoints = 2;
  78          $this->assertEquals(quiz_format_question_grade($quiz, 0.12345678), format_float(0.12, 2));
  79          $this->assertEquals(quiz_format_question_grade($quiz, 0), format_float(0, 2));
  80          $this->assertEquals(quiz_format_question_grade($quiz, 1.000000000000), format_float(1, 2));
  81          $quiz->decimalpoints = 3;
  82          $quiz->questiondecimalpoints = -1;
  83          $this->assertEquals(quiz_format_question_grade($quiz, 0.12345678), format_float(0.123, 3));
  84          $this->assertEquals(quiz_format_question_grade($quiz, 0), format_float(0, 3));
  85          $this->assertEquals(quiz_format_question_grade($quiz, 1.000000000000), format_float(1, 3));
  86          $quiz->questiondecimalpoints = 4;
  87          $this->assertEquals(quiz_format_question_grade($quiz, 0.12345678), format_float(0.1235, 4));
  88          $this->assertEquals(quiz_format_question_grade($quiz, 0), format_float(0, 4));
  89          $this->assertEquals(quiz_format_question_grade($quiz, 1.000000000000), format_float(1, 4));
  90      }
  91  
  92      /**
  93       * Test deleting a quiz instance.
  94       */
  95      public function test_quiz_delete_instance() {
  96          global $SITE, $DB;
  97          $this->resetAfterTest(true);
  98          $this->setAdminUser();
  99  
 100          // Setup a quiz with 1 standard and 1 random question.
 101          $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 102          $quiz = $quizgenerator->create_instance(array('course' => $SITE->id, 'questionsperpage' => 3, 'grade' => 100.0));
 103  
 104          $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
 105          $cat = $questiongenerator->create_question_category();
 106          $standardq = $questiongenerator->create_question('shortanswer', null, array('category' => $cat->id));
 107  
 108          quiz_add_quiz_question($standardq->id, $quiz);
 109          quiz_add_random_questions($quiz, 0, $cat->id, 1, false);
 110  
 111          // Get the random question.
 112          $randomq = $DB->get_record('question', array('qtype' => 'random'));
 113  
 114          quiz_delete_instance($quiz->id);
 115  
 116          // Check that the random question was deleted.
 117          $count = $DB->count_records('question', array('id' => $randomq->id));
 118          $this->assertEquals(0, $count);
 119          // Check that the standard question was not deleted.
 120          $count = $DB->count_records('question', array('id' => $standardq->id));
 121          $this->assertEquals(1, $count);
 122  
 123          // Check that all the slots were removed.
 124          $count = $DB->count_records('quiz_slots', array('quizid' => $quiz->id));
 125          $this->assertEquals(0, $count);
 126  
 127          // Check that the quiz was removed.
 128          $count = $DB->count_records('quiz', array('id' => $quiz->id));
 129          $this->assertEquals(0, $count);
 130      }
 131  
 132      /**
 133       * Test checking the completion state of a quiz.
 134       */
 135      public function test_quiz_get_completion_state() {
 136          global $CFG, $DB;
 137          $this->resetAfterTest(true);
 138  
 139          // Enable completion before creating modules, otherwise the completion data is not written in DB.
 140          $CFG->enablecompletion = true;
 141  
 142          // Create a course and student.
 143          $course = $this->getDataGenerator()->create_course(array('enablecompletion' => true));
 144          $passstudent = $this->getDataGenerator()->create_user();
 145          $failstudent = $this->getDataGenerator()->create_user();
 146          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 147          $this->assertNotEmpty($studentrole);
 148  
 149          // Enrol students.
 150          $this->assertTrue($this->getDataGenerator()->enrol_user($passstudent->id, $course->id, $studentrole->id));
 151          $this->assertTrue($this->getDataGenerator()->enrol_user($failstudent->id, $course->id, $studentrole->id));
 152  
 153          // Make a scale and an outcome.
 154          $scale = $this->getDataGenerator()->create_scale();
 155          $data = array('courseid' => $course->id,
 156                        'fullname' => 'Team work',
 157                        'shortname' => 'Team work',
 158                        'scaleid' => $scale->id);
 159          $outcome = $this->getDataGenerator()->create_grade_outcome($data);
 160  
 161          // Make a quiz with the outcome on.
 162          $quizgenerator = $this->getDataGenerator()->get_plugin_generator('mod_quiz');
 163          $data = array('course' => $course->id,
 164                        'outcome_'.$outcome->id => 1,
 165                        'grade' => 100.0,
 166                        'questionsperpage' => 0,
 167                        'sumgrades' => 1,
 168                        'completion' => COMPLETION_TRACKING_AUTOMATIC,
 169                        'completionpass' => 1);
 170          $quiz = $quizgenerator->create_instance($data);
 171          $cm = get_coursemodule_from_id('quiz', $quiz->cmid);
 172  
 173          // Create a couple of questions.
 174          $questiongenerator = $this->getDataGenerator()->get_plugin_generator('core_question');
 175  
 176          $cat = $questiongenerator->create_question_category();
 177          $question = $questiongenerator->create_question('numerical', null, array('category' => $cat->id));
 178          quiz_add_quiz_question($question->id, $quiz);
 179  
 180          $quizobj = quiz::create($quiz->id, $passstudent->id);
 181  
 182          // Set grade to pass.
 183          $item = grade_item::fetch(array('courseid' => $course->id, 'itemtype' => 'mod',
 184                                          'itemmodule' => 'quiz', 'iteminstance' => $quiz->id, 'outcomeid' => null));
 185          $item->gradepass = 80;
 186          $item->update();
 187  
 188          // Start the passing attempt.
 189          $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
 190          $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);
 191  
 192          $timenow = time();
 193          $attempt = quiz_create_attempt($quizobj, 1, false, $timenow, false, $passstudent->id);
 194          quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow);
 195          quiz_attempt_save_started($quizobj, $quba, $attempt);
 196  
 197          // Process some responses from the student.
 198          $attemptobj = quiz_attempt::create($attempt->id);
 199          $tosubmit = array(1 => array('answer' => '3.14'));
 200          $attemptobj->process_submitted_actions($timenow, false, $tosubmit);
 201  
 202          // Finish the attempt.
 203          $attemptobj = quiz_attempt::create($attempt->id);
 204          $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
 205          $attemptobj->process_finish($timenow, false);
 206  
 207          // Start the failing attempt.
 208          $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
 209          $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);
 210  
 211          $timenow = time();
 212          $attempt = quiz_create_attempt($quizobj, 1, false, $timenow, false, $failstudent->id);
 213          quiz_start_new_attempt($quizobj, $quba, $attempt, 1, $timenow);
 214          quiz_attempt_save_started($quizobj, $quba, $attempt);
 215  
 216          // Process some responses from the student.
 217          $attemptobj = quiz_attempt::create($attempt->id);
 218          $tosubmit = array(1 => array('answer' => '0'));
 219          $attemptobj->process_submitted_actions($timenow, false, $tosubmit);
 220  
 221          // Finish the attempt.
 222          $attemptobj = quiz_attempt::create($attempt->id);
 223          $this->assertTrue($attemptobj->has_response_to_at_least_one_graded_question());
 224          $attemptobj->process_finish($timenow, false);
 225  
 226          // Check the results.
 227          $this->assertTrue(quiz_get_completion_state($course, $cm, $passstudent->id, 'return'));
 228          $this->assertFalse(quiz_get_completion_state($course, $cm, $failstudent->id, 'return'));
 229      }
 230  
 231      public function test_quiz_get_user_attempts() {
 232          global $DB;
 233          $this->resetAfterTest();
 234  
 235          $dg = $this->getDataGenerator();
 236          $quizgen = $dg->get_plugin_generator('mod_quiz');
 237          $course = $dg->create_course();
 238          $u1 = $dg->create_user();
 239          $u2 = $dg->create_user();
 240          $u3 = $dg->create_user();
 241          $u4 = $dg->create_user();
 242          $role = $DB->get_record('role', ['shortname' => 'student']);
 243  
 244          $dg->enrol_user($u1->id, $course->id, $role->id);
 245          $dg->enrol_user($u2->id, $course->id, $role->id);
 246          $dg->enrol_user($u3->id, $course->id, $role->id);
 247          $dg->enrol_user($u4->id, $course->id, $role->id);
 248  
 249          $quiz1 = $quizgen->create_instance(['course' => $course->id, 'sumgrades' => 2]);
 250          $quiz2 = $quizgen->create_instance(['course' => $course->id, 'sumgrades' => 2]);
 251  
 252          // Questions.
 253          $questgen = $dg->get_plugin_generator('core_question');
 254          $quizcat = $questgen->create_question_category();
 255          $question = $questgen->create_question('numerical', null, ['category' => $quizcat->id]);
 256          quiz_add_quiz_question($question->id, $quiz1);
 257          quiz_add_quiz_question($question->id, $quiz2);
 258  
 259          $quizobj1a = quiz::create($quiz1->id, $u1->id);
 260          $quizobj1b = quiz::create($quiz1->id, $u2->id);
 261          $quizobj1c = quiz::create($quiz1->id, $u3->id);
 262          $quizobj1d = quiz::create($quiz1->id, $u4->id);
 263          $quizobj2a = quiz::create($quiz2->id, $u1->id);
 264  
 265          // Set attempts.
 266          $quba1a = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj1a->get_context());
 267          $quba1a->set_preferred_behaviour($quizobj1a->get_quiz()->preferredbehaviour);
 268          $quba1b = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj1b->get_context());
 269          $quba1b->set_preferred_behaviour($quizobj1b->get_quiz()->preferredbehaviour);
 270          $quba1c = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj1c->get_context());
 271          $quba1c->set_preferred_behaviour($quizobj1c->get_quiz()->preferredbehaviour);
 272          $quba1d = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj1d->get_context());
 273          $quba1d->set_preferred_behaviour($quizobj1d->get_quiz()->preferredbehaviour);
 274          $quba2a = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj2a->get_context());
 275          $quba2a->set_preferred_behaviour($quizobj2a->get_quiz()->preferredbehaviour);
 276  
 277          $timenow = time();
 278  
 279          // User 1 passes quiz 1.
 280          $attempt = quiz_create_attempt($quizobj1a, 1, false, $timenow, false, $u1->id);
 281          quiz_start_new_attempt($quizobj1a, $quba1a, $attempt, 1, $timenow);
 282          quiz_attempt_save_started($quizobj1a, $quba1a, $attempt);
 283          $attemptobj = quiz_attempt::create($attempt->id);
 284          $attemptobj->process_submitted_actions($timenow, false, [1 => ['answer' => '3.14']]);
 285          $attemptobj->process_finish($timenow, false);
 286  
 287          // User 2 goes overdue in quiz 1.
 288          $attempt = quiz_create_attempt($quizobj1b, 1, false, $timenow, false, $u2->id);
 289          quiz_start_new_attempt($quizobj1b, $quba1b, $attempt, 1, $timenow);
 290          quiz_attempt_save_started($quizobj1b, $quba1b, $attempt);
 291          $attemptobj = quiz_attempt::create($attempt->id);
 292          $attemptobj->process_going_overdue($timenow, true);
 293  
 294          // User 3 does not finish quiz 1.
 295          $attempt = quiz_create_attempt($quizobj1c, 1, false, $timenow, false, $u3->id);
 296          quiz_start_new_attempt($quizobj1c, $quba1c, $attempt, 1, $timenow);
 297          quiz_attempt_save_started($quizobj1c, $quba1c, $attempt);
 298  
 299          // User 4 abandons the quiz 1.
 300          $attempt = quiz_create_attempt($quizobj1d, 1, false, $timenow, false, $u4->id);
 301          quiz_start_new_attempt($quizobj1d, $quba1d, $attempt, 1, $timenow);
 302          quiz_attempt_save_started($quizobj1d, $quba1d, $attempt);
 303          $attemptobj = quiz_attempt::create($attempt->id);
 304          $attemptobj->process_abandon($timenow, true);
 305  
 306          // User 1 attempts the quiz three times (abandon, finish, in progress).
 307          $quba2a = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj2a->get_context());
 308          $quba2a->set_preferred_behaviour($quizobj2a->get_quiz()->preferredbehaviour);
 309  
 310          $attempt = quiz_create_attempt($quizobj2a, 1, false, $timenow, false, $u1->id);
 311          quiz_start_new_attempt($quizobj2a, $quba2a, $attempt, 1, $timenow);
 312          quiz_attempt_save_started($quizobj2a, $quba2a, $attempt);
 313          $attemptobj = quiz_attempt::create($attempt->id);
 314          $attemptobj->process_abandon($timenow, true);
 315  
 316          $quba2a = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj2a->get_context());
 317          $quba2a->set_preferred_behaviour($quizobj2a->get_quiz()->preferredbehaviour);
 318  
 319          $attempt = quiz_create_attempt($quizobj2a, 2, false, $timenow, false, $u1->id);
 320          quiz_start_new_attempt($quizobj2a, $quba2a, $attempt, 2, $timenow);
 321          quiz_attempt_save_started($quizobj2a, $quba2a, $attempt);
 322          $attemptobj = quiz_attempt::create($attempt->id);
 323          $attemptobj->process_finish($timenow, false);
 324  
 325          $quba2a = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj2a->get_context());
 326          $quba2a->set_preferred_behaviour($quizobj2a->get_quiz()->preferredbehaviour);
 327  
 328          $attempt = quiz_create_attempt($quizobj2a, 3, false, $timenow, false, $u1->id);
 329          quiz_start_new_attempt($quizobj2a, $quba2a, $attempt, 3, $timenow);
 330          quiz_attempt_save_started($quizobj2a, $quba2a, $attempt);
 331  
 332          // Check for user 1.
 333          $attempts = quiz_get_user_attempts($quiz1->id, $u1->id, 'all');
 334          $this->assertCount(1, $attempts);
 335          $attempt = array_shift($attempts);
 336          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 337          $this->assertEquals($u1->id, $attempt->userid);
 338          $this->assertEquals($quiz1->id, $attempt->quiz);
 339  
 340          $attempts = quiz_get_user_attempts($quiz1->id, $u1->id, 'finished');
 341          $this->assertCount(1, $attempts);
 342          $attempt = array_shift($attempts);
 343          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 344          $this->assertEquals($u1->id, $attempt->userid);
 345          $this->assertEquals($quiz1->id, $attempt->quiz);
 346  
 347          $attempts = quiz_get_user_attempts($quiz1->id, $u1->id, 'unfinished');
 348          $this->assertCount(0, $attempts);
 349  
 350          // Check for user 2.
 351          $attempts = quiz_get_user_attempts($quiz1->id, $u2->id, 'all');
 352          $this->assertCount(1, $attempts);
 353          $attempt = array_shift($attempts);
 354          $this->assertEquals(quiz_attempt::OVERDUE, $attempt->state);
 355          $this->assertEquals($u2->id, $attempt->userid);
 356          $this->assertEquals($quiz1->id, $attempt->quiz);
 357  
 358          $attempts = quiz_get_user_attempts($quiz1->id, $u2->id, 'finished');
 359          $this->assertCount(0, $attempts);
 360  
 361          $attempts = quiz_get_user_attempts($quiz1->id, $u2->id, 'unfinished');
 362          $this->assertCount(1, $attempts);
 363          $attempt = array_shift($attempts);
 364          $this->assertEquals(quiz_attempt::OVERDUE, $attempt->state);
 365          $this->assertEquals($u2->id, $attempt->userid);
 366          $this->assertEquals($quiz1->id, $attempt->quiz);
 367  
 368          // Check for user 3.
 369          $attempts = quiz_get_user_attempts($quiz1->id, $u3->id, 'all');
 370          $this->assertCount(1, $attempts);
 371          $attempt = array_shift($attempts);
 372          $this->assertEquals(quiz_attempt::IN_PROGRESS, $attempt->state);
 373          $this->assertEquals($u3->id, $attempt->userid);
 374          $this->assertEquals($quiz1->id, $attempt->quiz);
 375  
 376          $attempts = quiz_get_user_attempts($quiz1->id, $u3->id, 'finished');
 377          $this->assertCount(0, $attempts);
 378  
 379          $attempts = quiz_get_user_attempts($quiz1->id, $u3->id, 'unfinished');
 380          $this->assertCount(1, $attempts);
 381          $attempt = array_shift($attempts);
 382          $this->assertEquals(quiz_attempt::IN_PROGRESS, $attempt->state);
 383          $this->assertEquals($u3->id, $attempt->userid);
 384          $this->assertEquals($quiz1->id, $attempt->quiz);
 385  
 386          // Check for user 4.
 387          $attempts = quiz_get_user_attempts($quiz1->id, $u4->id, 'all');
 388          $this->assertCount(1, $attempts);
 389          $attempt = array_shift($attempts);
 390          $this->assertEquals(quiz_attempt::ABANDONED, $attempt->state);
 391          $this->assertEquals($u4->id, $attempt->userid);
 392          $this->assertEquals($quiz1->id, $attempt->quiz);
 393  
 394          $attempts = quiz_get_user_attempts($quiz1->id, $u4->id, 'finished');
 395          $this->assertCount(1, $attempts);
 396          $attempt = array_shift($attempts);
 397          $this->assertEquals(quiz_attempt::ABANDONED, $attempt->state);
 398          $this->assertEquals($u4->id, $attempt->userid);
 399          $this->assertEquals($quiz1->id, $attempt->quiz);
 400  
 401          $attempts = quiz_get_user_attempts($quiz1->id, $u4->id, 'unfinished');
 402          $this->assertCount(0, $attempts);
 403  
 404          // Multiple attempts for user 1 in quiz 2.
 405          $attempts = quiz_get_user_attempts($quiz2->id, $u1->id, 'all');
 406          $this->assertCount(3, $attempts);
 407          $attempt = array_shift($attempts);
 408          $this->assertEquals(quiz_attempt::ABANDONED, $attempt->state);
 409          $this->assertEquals($u1->id, $attempt->userid);
 410          $this->assertEquals($quiz2->id, $attempt->quiz);
 411          $attempt = array_shift($attempts);
 412          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 413          $this->assertEquals($u1->id, $attempt->userid);
 414          $this->assertEquals($quiz2->id, $attempt->quiz);
 415          $attempt = array_shift($attempts);
 416          $this->assertEquals(quiz_attempt::IN_PROGRESS, $attempt->state);
 417          $this->assertEquals($u1->id, $attempt->userid);
 418          $this->assertEquals($quiz2->id, $attempt->quiz);
 419  
 420          $attempts = quiz_get_user_attempts($quiz2->id, $u1->id, 'finished');
 421          $this->assertCount(2, $attempts);
 422          $attempt = array_shift($attempts);
 423          $this->assertEquals(quiz_attempt::ABANDONED, $attempt->state);
 424          $attempt = array_shift($attempts);
 425          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 426  
 427          $attempts = quiz_get_user_attempts($quiz2->id, $u1->id, 'unfinished');
 428          $this->assertCount(1, $attempts);
 429          $attempt = array_shift($attempts);
 430  
 431          // Multiple quiz attempts fetched at once.
 432          $attempts = quiz_get_user_attempts([$quiz1->id, $quiz2->id], $u1->id, 'all');
 433          $this->assertCount(4, $attempts);
 434          $attempt = array_shift($attempts);
 435          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 436          $this->assertEquals($u1->id, $attempt->userid);
 437          $this->assertEquals($quiz1->id, $attempt->quiz);
 438          $attempt = array_shift($attempts);
 439          $this->assertEquals(quiz_attempt::ABANDONED, $attempt->state);
 440          $this->assertEquals($u1->id, $attempt->userid);
 441          $this->assertEquals($quiz2->id, $attempt->quiz);
 442          $attempt = array_shift($attempts);
 443          $this->assertEquals(quiz_attempt::FINISHED, $attempt->state);
 444          $this->assertEquals($u1->id, $attempt->userid);
 445          $this->assertEquals($quiz2->id, $attempt->quiz);
 446          $attempt = array_shift($attempts);
 447          $this->assertEquals(quiz_attempt::IN_PROGRESS, $attempt->state);
 448          $this->assertEquals($u1->id, $attempt->userid);
 449          $this->assertEquals($quiz2->id, $attempt->quiz);
 450      }
 451  
 452  }


Generated: Thu Aug 11 10:00:09 2016 Cross-referenced by PHPXref 0.7.1