gradebook MDL-24330 unit tests now function differently so produce different results
[moodle.git] / lib / simpletest / fixtures / gradetest.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * @package    moodlecore
20  * @copyright  nicolas@moodle.com
21  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
22  */
24 if (!defined('MOODLE_INTERNAL')) {
25     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
26 }
28 require_once($CFG->libdir . '/adminlib.php');
29 require_once($CFG->libdir . '/gradelib.php');
31 /**
32  * Shared code for all grade related tests.
33  *
34  * Here is a brief explanation of the test data set up in these unit tests.
35  * category1 => array(category2 => array(grade_item1, grade_item2), category3 => array(grade_item3))
36  * 3 users for 3 grade_items
37  */
38 class grade_test extends UnitTestCaseUsingDatabase {
40     public $grade_tables = array('lib' => array(
41                                      'grade_categories', 'grade_categories_history',
42                                      'scale', 'scale_history',
43                                      'grade_items', 'grade_items_history',
44                                      'grade_grades', 'grade_grades_history',
45                                      'grade_outcomes', 'grade_outcomes_history','grade_outcomes_courses',
46                                      'files',
47                                      'modules',
48                                      'course_modules'),
49                                  'mod/quiz' => array('quiz')
50                             );
52     public $grade_items = array();
53     public $grade_categories = array();
54     public $grade_grades = array();
55     public $grade_outcomes = array();
56     public $scale = array();
58     public $activities = array();
59     public $courseid = 1;
60     public $userid = 1;
62     /**
63      * Create temporary test tables and entries in the database for these tests.
64      * These tests have to work on a brand new site.
65      */
66     function setUp() {
67         global $CFG;
69         parent::setup();
70         $CFG->grade_droplow = -1;
71         $CFG->grade_keephigh = -1;
72         $CFG->grade_aggregation = -1;
73         $CFG->grade_aggregateonlygraded = -1;
74         $CFG->grade_aggregateoutcomes = -1;
75         $CFG->grade_aggregatesubcats = -1;
77         $this->switch_to_test_db(); // All operations until end of test method will happen in test DB
79         foreach ($this->grade_tables as $dir => $tables) {
80             $this->create_test_tables($tables, $dir); // Create tables
81             foreach ($tables as $table) { // Fill them if load_xxx method is available
82                 $function = "load_$table";
83                 if (method_exists($this, $function)) {
84                     $this->$function();
85                 }
86             }
87         }
89     }
91     function tearDown() {
92         parent::tearDown(); // All the test tables created in setUp will be dropped by this
93     }
95     /**
96      * Load scale data into the database, and adds the corresponding objects to this class' variable.
97      */
98     function load_scale() {
99         global $DB;
100         $scale = new stdClass();
102         $scale->name        = 'unittestscale1';
103         $scale->courseid    = $this->courseid;
104         $scale->userid      = $this->userid;
105         $scale->scale       = 'Way off topic, Not very helpful, Fairly neutral, Fairly helpful, Supportive, Some good information, Perfect answer!';
106         $scale->description = 'This scale defines some of qualities that make posts helpful within the Moodle help forums.\n Your feedback will help others see how their posts are being received.';
107         $scale->timemodified = mktime();
109         $scale->id = $DB->insert_record('scale', $scale);
110         $this->scale[0] = $scale;
111         $temp = explode(',', $scale->scale);
112         $this->scalemax[0] = count($temp) -1;
114         $scale = new stdClass();
116         $scale->name        = 'unittestscale2';
117         $scale->courseid    = $this->courseid;
118         $scale->userid      = $this->userid;
119         $scale->scale       = 'Distinction, Very Good, Good, Pass, Fail';
120         $scale->description = 'This scale is used to mark standard assignments.';
121         $scale->timemodified = mktime();
123         $scale->id = $DB->insert_record('scale', $scale);
124         $this->scale[1] = $scale;
125         $temp = explode(',', $scale->scale);
126         $this->scalemax[1] = count($temp) -1;
128         $scale = new stdClass();
130         $scale->name        = 'unittestscale3';
131         $scale->courseid    = $this->courseid;
132         $scale->userid      = $this->userid;
133         $scale->scale       = 'Loner, Contentious, Disinterested, Participative, Follower, Leader';
134         $scale->description = 'Describes the level of teamwork of a student.';
135         $scale->timemodified = mktime();
136         $temp  = explode(',', $scale->scale);
137         $scale->max         = count($temp) -1;
139         $scale->id = $DB->insert_record('scale', $scale);
140         $this->scale[2] = $scale;
141         $temp = explode(',', $scale->scale);
142         $this->scalemax[2] = count($temp) -1;
144         $scale->name        = 'unittestscale4';
145         $scale->courseid    = $this->courseid;
146         $scale->userid      = $this->userid;
147         $scale->scale       = 'Does not understand theory, Understands theory but fails practice, Manages through, Excels';
148         $scale->description = 'Level of expertise at a technical task, with a theoretical framework.';
149         $scale->timemodified = mktime();
150         $temp  = explode(',', $scale->scale);
151         $scale->max         = count($temp) -1;
153         $scale->id = $DB->insert_record('scale', $scale);
154         $this->scale[3] = $scale;
155         $temp = explode(',', $scale->scale);
156         $this->scalemax[3] = count($temp) -1;
158         $scale->name        = 'unittestscale5';
159         $scale->courseid    = $this->courseid;
160         $scale->userid      = $this->userid;
161         $scale->scale       = 'Insufficient, Acceptable, Excellent.';
162         $scale->description = 'Description of skills.';
163         $scale->timemodified = mktime();
164         $temp  = explode(',', $scale->scale);
165         $scale->max         = count($temp) -1;
167         $scale->id = $DB->insert_record('scale', $scale);
168         $this->scale[4] = $scale;
169         $temp = explode(',', $scale->scale);
170         $this->scalemax[4] = count($temp) -1;
171     }
173     /**
174      * Load grade_category data into the database, and adds the corresponding objects to this class' variable.
175      * category structure:
176                               course category
177                                     |
178                            +--------+-------------+
179                            |                      |
180              unittestcategory1               level1category
181                   |
182          +--------+-------------+
183          |                      |
184         unittestcategory2  unittestcategory3
185      */
186     function load_grade_categories() {
187         global $DB;
189         $course_category = grade_category::fetch_course_category($this->courseid);
191         $grade_category = new stdClass();
193         $grade_category->fullname    = 'unittestcategory1';
194         $grade_category->courseid    = $this->courseid;
195         $grade_category->aggregation = GRADE_AGGREGATE_MEAN;
196         $grade_category->aggregateonlygraded = 1;
197         $grade_category->keephigh    = 0;
198         $grade_category->droplow     = 0;
199         $grade_category->parent      = $course_category->id;
200         $grade_category->timecreated = mktime();
201         $grade_category->timemodified = mktime();
202         $grade_category->depth = 2;
204         $grade_category->id = $DB->insert_record('grade_categories', $grade_category);
205         $grade_category->path = '/'.$course_category->id.'/'.$grade_category->id.'/';
206         $DB->update_record('grade_categories', $grade_category);
207         $this->grade_categories[0] = $grade_category;
209         $grade_category = new stdClass();
211         $grade_category->fullname    = 'unittestcategory2';
212         $grade_category->courseid    = $this->courseid;
213         $grade_category->aggregation = GRADE_AGGREGATE_MEAN;
214         $grade_category->aggregateonlygraded = 1;
215         $grade_category->keephigh    = 0;
216         $grade_category->droplow     = 0;
217         $grade_category->parent      = $this->grade_categories[0]->id;
218         $grade_category->timecreated = mktime();
219         $grade_category->timemodified = mktime();
220         $grade_category->depth = 3;
222         $grade_category->id = $DB->insert_record('grade_categories', $grade_category);
223         $grade_category->path = $this->grade_categories[0]->path.$grade_category->id.'/';
224         $DB->update_record('grade_categories', $grade_category);
225         $this->grade_categories[1] = $grade_category;
227         $grade_category = new stdClass();
229         $grade_category->fullname    = 'unittestcategory3';
230         $grade_category->courseid    = $this->courseid;
231         $grade_category->aggregation = GRADE_AGGREGATE_MEAN;
232         $grade_category->aggregateonlygraded = 1;
233         $grade_category->keephigh    = 0;
234         $grade_category->droplow     = 0;
235         $grade_category->parent      = $this->grade_categories[0]->id;
236         $grade_category->timecreated = mktime();
237         $grade_category->timemodified = mktime();
238         $grade_category->depth = 3;
240         $grade_category->id = $DB->insert_record('grade_categories', $grade_category);
241         $grade_category->path = $this->grade_categories[0]->path.$grade_category->id.'/';
242         $DB->update_record('grade_categories', $grade_category);
243         $this->grade_categories[2] = $grade_category;
245         // A category with no parent, but grade_items as children
247         $grade_category = new stdClass();
249         $grade_category->fullname    = 'level1category';
250         $grade_category->courseid    = $this->courseid;
251         $grade_category->aggregation = GRADE_AGGREGATE_MEAN;
252         $grade_category->aggregateonlygraded = 1;
253         $grade_category->keephigh    = 0;
254         $grade_category->droplow     = 0;
255         $grade_category->parent      = $course_category->id;
256         $grade_category->timecreated = mktime();
257         $grade_category->timemodified = mktime();
258         $grade_category->depth = 2;
260         $grade_category->id = $DB->insert_record('grade_categories', $grade_category);
261         $grade_category->path = '/'.$course_category->id.'/'.$grade_category->id.'/';
262         $DB->update_record('grade_categories', $grade_category);
263         $this->grade_categories[3] = $grade_category;
264     }
266     /**
267      * Load module entries in modules table
268      */
269     function load_modules() {
270         global $DB;
271         $module = new stdClass();
272         $module->name = 'assignment';
273         $module->id = $DB->insert_record('modules', $module);
274         $this->modules[0] = $module;
276         $module = new stdClass();
277         $module->name = 'quiz';
278         $module->id = $DB->insert_record('modules', $module);
279         $this->modules[1] = $module;
281         $module = new stdClass();
282         $module->name = 'forum';
283         $module->id = $DB->insert_record('modules', $module);
284         $this->modules[2] = $module;
285     }
287     /**
288      * Load module instance entries in course_modules table
289      */
290     function load_course_modules() {
291         global $DB;
292         $course_module = new stdClass();
293         $course_module->course = $this->courseid;
294         $quiz->module = 1;
295         $quiz->instance = 2;
296         $course_module->id = $DB->insert_record('course_modules', $course_module);
297         $this->course_module[0] = $course_module;
299         $course_module = new stdClass();
300         $course_module->course = $this->courseid;
301         $quiz->module = 2;
302         $quiz->instance = 1;
303         $course_module->id = $DB->insert_record('course_modules', $course_module);
304         $this->course_module[0] = $course_module;
306         $course_module = new stdClass();
307         $course_module->course = $this->courseid;
308         $quiz->module = 2;
309         $quiz->instance = 5;
310         $course_module->id = $DB->insert_record('course_modules', $course_module);
311         $this->course_module[0] = $course_module;
313         $course_module = new stdClass();
314         $course_module->course = $this->courseid;
315         $quiz->module = 3;
316         $quiz->instance = 3;
317         $course_module->id = $DB->insert_record('course_modules', $course_module);
318         $this->course_module[0] = $course_module;
320         $course_module = new stdClass();
321         $course_module->course = $this->courseid;
322         $quiz->module = 3;
323         $quiz->instance = 7;
324         $course_module->id = $DB->insert_record('course_modules', $course_module);
325         $this->course_module[0] = $course_module;
327         $course_module = new stdClass();
328         $course_module->course = $this->courseid;
329         $quiz->module = 3;
330         $quiz->instance = 9;
331         $course_module->id = $DB->insert_record('course_modules', $course_module);
332         $this->course_module[0] = $course_module;
333     }
335     /**
336      * Load test quiz data into the database
337      */
338     function load_quiz_activities() {
339         global $DB;
340         $quiz = new stdClass();
341         $quiz->course = $this->courseid;
342         $quiz->name = 'test quiz';
343         $quiz->intro = 'let us quiz you!';
344         $quiz->questions = '1,2';
345         $quiz->id = $DB->insert_record('quiz', $quiz);
346         $this->activities[0] = $quiz;
348         $quiz = new stdClass();
349         $quiz->course = $this->courseid;
350         $quiz->name = 'test quiz 2';
351         $quiz->intro = 'let us quiz you again!';
352         $quiz->questions = '1,3';
353         $quiz->id = $DB->insert_record('quiz', $quiz);
354         $this->activities[1] = $quiz;
355     }
357     /**
358      * Load grade_item data into the database, and adds the corresponding objects to this class' variable.
359      */
360     function load_grade_items() {
361         global $DB;
363         $course_category = grade_category::fetch_course_category($this->courseid);
365         // id = 0
366         $grade_item = new stdClass();
368         $grade_item->courseid = $this->courseid;
369         $grade_item->categoryid = $this->grade_categories[1]->id;
370         $grade_item->itemname = 'unittestgradeitem1';
371         $grade_item->itemtype = 'mod';
372         $grade_item->itemmodule = 'quiz';
373         $grade_item->iteminstance = 1;
374         $grade_item->gradetype = GRADE_TYPE_VALUE;
375         $grade_item->grademin = 30;
376         $grade_item->grademax = 110;
377         $grade_item->itemnumber = 1;
378         $grade_item->idnumber = 'item id 0';
379         $grade_item->iteminfo = 'Grade item 0 used for unit testing';
380         $grade_item->timecreated = mktime();
381         $grade_item->timemodified = mktime();
382         $grade_item->sortorder = 3;
384         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
385         $this->grade_items[0] = $grade_item;
387         // id = 1
388         $grade_item = new stdClass();
390         $grade_item->courseid = $this->courseid;
391         $grade_item->categoryid = $this->grade_categories[1]->id;
392         $grade_item->itemname = 'unittestgradeitem2';
393         $grade_item->itemtype = 'import';
394         $grade_item->itemmodule = 'assignment';
395         $grade_item->calculation = '= ##gi'.$this->grade_items[0]->id.'## + 30 + [[item id 0]] - [[item id 0]]';
396         $grade_item->gradetype = GRADE_TYPE_VALUE;
397         $grade_item->iteminstance = 2;
398         $grade_item->itemnumber = null;
399         $grade_item->grademin = 0;
400         $grade_item->grademax = 100;
401         $grade_item->iteminfo = 'Grade item 1 used for unit testing';
402         $grade_item->timecreated = mktime();
403         $grade_item->timemodified = mktime();
404         $grade_item->sortorder = 4;
406         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
407         $this->grade_items[1] = $grade_item;
409         // id = 2
410         $grade_item = new stdClass();
412         $grade_item->courseid = $this->courseid;
413         $grade_item->categoryid = $this->grade_categories[2]->id;
414         $grade_item->itemname = 'unittestgradeitem3';
415         $grade_item->itemtype = 'mod';
416         $grade_item->itemmodule = 'forum';
417         $grade_item->iteminstance = 3;
418         $grade_item->gradetype = GRADE_TYPE_SCALE;
419         $grade_item->scaleid = $this->scale[0]->id;
420         $grade_item->grademin = 0;
421         $grade_item->grademax = $this->scalemax[0];
422         $grade_item->iteminfo = 'Grade item 2 used for unit testing';
423         $grade_item->timecreated = mktime();
424         $grade_item->timemodified = mktime();
425         $grade_item->sortorder = 6;
427         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
428         $this->grade_items[2] = $grade_item;
430         // Load grade_items associated with the 3 categories
431         // id = 3
432         $grade_item = new stdClass();
434         $grade_item->courseid = $this->courseid;
435         $grade_item->iteminstance = $this->grade_categories[0]->id;
436         $grade_item->itemname = 'unittestgradeitemcategory1';
437         $grade_item->needsupdate = 0;
438         $grade_item->itemtype = 'category';
439         $grade_item->gradetype = GRADE_TYPE_VALUE;
440         $grade_item->grademin = 0;
441         $grade_item->grademax = 100;
442         $grade_item->iteminfo = 'Grade item 3 used for unit testing';
443         $grade_item->timecreated = mktime();
444         $grade_item->timemodified = mktime();
445         $grade_item->sortorder = 1;
447         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
448         $this->grade_items[3] = $grade_item;
450         // id = 4
451         $grade_item = new stdClass();
453         $grade_item->courseid = $this->courseid;
454         $grade_item->iteminstance = $this->grade_categories[1]->id;
455         $grade_item->itemname = 'unittestgradeitemcategory2';
456         $grade_item->itemtype = 'category';
457         $grade_item->gradetype = GRADE_TYPE_VALUE;
458         $grade_item->needsupdate = 0;
459         $grade_item->grademin = 0;
460         $grade_item->grademax = 100;
461         $grade_item->iteminfo = 'Grade item 4 used for unit testing';
462         $grade_item->timecreated = mktime();
463         $grade_item->timemodified = mktime();
464         $grade_item->sortorder = 2;
466         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
467         $this->grade_items[4] = $grade_item;
469         // id = 5
470         $grade_item = new stdClass();
472         $grade_item->courseid = $this->courseid;
473         $grade_item->iteminstance = $this->grade_categories[2]->id;
474         $grade_item->itemname = 'unittestgradeitemcategory3';
475         $grade_item->itemtype = 'category';
476         $grade_item->gradetype = GRADE_TYPE_VALUE;
477         $grade_item->needsupdate = true;
478         $grade_item->grademin = 0;
479         $grade_item->grademax = 100;
480         $grade_item->iteminfo = 'Grade item 5 used for unit testing';
481         $grade_item->timecreated = mktime();
482         $grade_item->timemodified = mktime();
483         $grade_item->sortorder = 5;
485         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
486         $this->grade_items[5] = $grade_item;
488         // Orphan grade_item
489         // id = 6
490         $grade_item = new stdClass();
492         $grade_item->courseid = $this->courseid;
493         $grade_item->categoryid = $course_category->id;
494         $grade_item->itemname = 'unittestorphangradeitem1';
495         $grade_item->itemtype = 'mod';
496         $grade_item->itemmodule = 'quiz';
497         $grade_item->iteminstance = 5;
498         $grade_item->itemnumber = 0;
499         $grade_item->gradetype = GRADE_TYPE_VALUE;
500         $grade_item->grademin = 10;
501         $grade_item->grademax = 120;
502         $grade_item->locked = time();
503         $grade_item->iteminfo = 'Orphan Grade 6 item used for unit testing';
504         $grade_item->timecreated = mktime();
505         $grade_item->timemodified = mktime();
506         $grade_item->sortorder = 7;
508         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
509         $this->grade_items[6] = $grade_item;
511         // 2 grade items under level1category
512         // id = 7
513         $grade_item = new stdClass();
515         $grade_item->courseid = $this->courseid;
516         $grade_item->categoryid = $this->grade_categories[3]->id;
517         $grade_item->itemname = 'singleparentitem1';
518         $grade_item->itemtype = 'mod';
519         $grade_item->itemmodule = 'forum';
520         $grade_item->iteminstance = 7;
521         $grade_item->gradetype = GRADE_TYPE_SCALE;
522         $grade_item->scaleid = $this->scale[0]->id;
523         $grade_item->grademin = 0;
524         $grade_item->grademax = $this->scalemax[0];
525         $grade_item->iteminfo = 'Grade item 7 used for unit testing';
526         $grade_item->timecreated = mktime();
527         $grade_item->timemodified = mktime();
528         $grade_item->sortorder = 9;
530         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
531         $this->grade_items[7] = $grade_item;
533         // id = 8
534         $grade_item = new stdClass();
536         $grade_item->courseid = $this->courseid;
537         $grade_item->categoryid = $this->grade_categories[3]->id;
538         $grade_item->itemname = 'singleparentitem2';
539         $grade_item->itemtype = 'mod';
540         $grade_item->itemmodule = 'forum';
541         $grade_item->iteminstance = 9;
542         $grade_item->gradetype = GRADE_TYPE_VALUE;
543         $grade_item->grademin = 0;
544         $grade_item->grademax = 100;
545         $grade_item->iteminfo = 'Grade item 8 used for unit testing';
546         $grade_item->timecreated = mktime();
547         $grade_item->timemodified = mktime();
548         $grade_item->sortorder = 10;
550         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
551         $this->grade_items[8] = $grade_item;
553         // Grade_item for level1category
554         // id = 9
555         $grade_item = new stdClass();
557         $grade_item->courseid = $this->courseid;
558         $grade_item->itemname = 'grade_item for level1 category';
559         $grade_item->itemtype = 'category';
560         $grade_item->itemmodule = 'quiz';
561         $grade_item->iteminstance = $this->grade_categories[3]->id;
562         $grade_item->needsupdate = true;
563         $grade_item->gradetype = GRADE_TYPE_VALUE;
564         $grade_item->grademin = 0;
565         $grade_item->grademax = 100;
566         $grade_item->iteminfo = 'Orphan Grade item 9 used for unit testing';
567         $grade_item->timecreated = mktime();
568         $grade_item->timemodified = mktime();
569         $grade_item->sortorder = 8;
571         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
572         $this->grade_items[9] = $grade_item;
574         // Manual grade_item
575         // id = 10
576         $grade_item = new stdClass();
578         $grade_item->courseid = $this->courseid;
579         $grade_item->categoryid = $course_category->id;
580         $grade_item->itemname = 'manual grade_item';
581         $grade_item->itemtype = 'manual';
582         $grade_item->itemnumber = 0;
583         $grade_item->needsupdate = false;
584         $grade_item->gradetype = GRADE_TYPE_VALUE;
585         $grade_item->grademin = 0;
586         $grade_item->grademax = 100;
587         $grade_item->iteminfo = 'Manual grade item 10 used for unit testing';
588         $grade_item->timecreated = mktime();
589         $grade_item->timemodified = mktime();
591         $grade_item->id = $DB->insert_record('grade_items', $grade_item);
592         $this->grade_items[10] = $grade_item;
593     }
595     /**
596      * Load grade_grades data into the database, and adds the corresponding objects to this class' variable.
597      */
598     function load_grade_grades() {
599         global $DB;
601         //this method is called once for each test method. Avoid adding things to $this->grade_grades multiple times
602         $this->grade_grades = array();
604         // Grades for grade_item 1
605         $grade = new stdClass();
606         $grade->itemid = $this->grade_items[0]->id;
607         $grade->userid = 1;
608         $grade->rawgrade = 15; // too small
609         $grade->finalgrade = 30;
610         $grade->timecreated = mktime();
611         $grade->timemodified = mktime();
612         $grade->information = '1 of 17 grade_grades';
613         $grade->informationformat = FORMAT_PLAIN;
614         $grade->feedback = 'Good, but not good enough..';
615         $grade->feedbackformat = FORMAT_PLAIN;
617         $grade->id = $DB->insert_record('grade_grades', $grade);
618         $this->grade_grades[0] = $grade;
620         $grade = new stdClass();
621         $grade->itemid = $this->grade_items[0]->id;
622         $grade->userid = 2;
623         $grade->rawgrade = 40;
624         $grade->finalgrade = 40;
625         $grade->timecreated = mktime();
626         $grade->timemodified = mktime();
627         $grade->information = '2 of 17 grade_grades';
629         $grade->id = $DB->insert_record('grade_grades', $grade);
630         $this->grade_grades[1] = $grade;
632         $grade = new stdClass();
633         $grade->itemid = $this->grade_items[0]->id;
634         $grade->userid = 3;
635         $grade->rawgrade = 170; // too big
636         $grade->finalgrade = 110;
637         $grade->timecreated = mktime();
638         $grade->timemodified = mktime();
639         $grade->information = '3 of 17 grade_grades';
641         $grade->id = $DB->insert_record('grade_grades', $grade);
642         $this->grade_grades[2] = $grade;
645         // No raw grades for grade_item 2 - it is calculated
647         $grade = new stdClass();
648         $grade->itemid = $this->grade_items[1]->id;
649         $grade->userid = 1;
650         $grade->finalgrade = 72;
651         $grade->timecreated = mktime();
652         $grade->timemodified = mktime();
653         $grade->information = '4 of 17 grade_grades';
655         $grade->id = $DB->insert_record('grade_grades', $grade);
656         $this->grade_grades[3] = $grade;
658         $grade = new stdClass();
659         $grade->itemid = $this->grade_items[1]->id;
660         $grade->userid = 2;
661         $grade->finalgrade = 92;
662         $grade->timecreated = mktime();
663         $grade->timemodified = mktime();
664         $grade->information = '5 of 17 grade_grades';
666         $grade->id = $DB->insert_record('grade_grades', $grade);
667         $this->grade_grades[4] = $grade;
669         $grade = new stdClass();
670         $grade->itemid = $this->grade_items[1]->id;
671         $grade->userid = 3;
672         $grade->finalgrade = 100;
673         $grade->timecreated = mktime();
674         $grade->timemodified = mktime();
675         $grade->information = '6 of 17 grade_grades';
677         $grade->id = $DB->insert_record('grade_grades', $grade);
678         $this->grade_grades[5] = $grade;
681         // Grades for grade_item 3
683         $grade = new stdClass();
684         $grade->itemid = $this->grade_items[2]->id;
685         $grade->userid = 1;
686         $grade->rawgrade = 2;
687         $grade->finalgrade = 6;
688         $grade->scaleid = $this->scale[3]->id;
689         $grade->timecreated = mktime();
690         $grade->timemodified = mktime();
691         $grade->information = '7 of 17 grade_grades';
693         $grade->id = $DB->insert_record('grade_grades', $grade);
694         $this->grade_grades[6] = $grade;
696         $grade = new stdClass();
697         $grade->itemid = $this->grade_items[2]->id;
698         $grade->userid = 2;
699         $grade->rawgrade = 3;
700         $grade->finalgrade = 2;
701         $grade->scaleid = $this->scale[3]->id;
702         $grade->timecreated = mktime();
703         $grade->timemodified = mktime();
704         $grade->information = '8 of 17 grade_grades';
706         $grade->id = $DB->insert_record('grade_grades', $grade);
707         $this->grade_grades[] = $grade;
709         $grade = new stdClass();
710         $grade->itemid = $this->grade_items[2]->id;
711         $grade->userid = 3;
712         $grade->rawgrade = 1;
713         $grade->finalgrade = 3;
714         $grade->scaleid = $this->scale[3]->id;
715         $grade->timecreated = mktime();
716         $grade->timemodified = mktime();
717         $grade->information = '9 of 17 grade_grades';
719         $grade->id = $DB->insert_record('grade_grades', $grade);
720         $this->grade_grades[] = $grade;
722         // Grades for grade_item 7
724         $grade = new stdClass();
725         $grade->itemid = $this->grade_items[6]->id;
726         $grade->userid = 1;
727         $grade->rawgrade = 97;
728         $grade->finalgrade = 69;
729         $grade->timecreated = mktime();
730         $grade->timemodified = mktime();
731         $grade->information = '10 of 17 grade_grades';
733         $grade->id = $DB->insert_record('grade_grades', $grade);
734         $this->grade_grades[] = $grade;
736         $grade = new stdClass();
737         $grade->itemid = $this->grade_items[6]->id;
738         $grade->userid = 2;
739         $grade->rawgrade = 49;
740         $grade->finalgrade = 87;
741         $grade->timecreated = mktime();
742         $grade->timemodified = mktime();
743         $grade->information = '11 of 17 grade_grades';
745         $grade->id = $DB->insert_record('grade_grades', $grade);
746         $this->grade_grades[] = $grade;
748         $grade = new stdClass();
749         $grade->itemid = $this->grade_items[6]->id;
750         $grade->userid = 3;
751         $grade->rawgrade = 67;
752         $grade->finalgrade = 94;
753         $grade->timecreated = mktime();
754         $grade->timemodified = mktime();
755         $grade->information = '12 of 17 grade_grades';
757         $grade->id = $DB->insert_record('grade_grades', $grade);
758         $this->grade_grades[] = $grade;
760         // Grades for grade_item 8
762         $grade = new stdClass();
763         $grade->itemid = $this->grade_items[7]->id;
764         $grade->userid = 2;
765         $grade->rawgrade = 3;
766         $grade->finalgrade = 3;
767         $grade->timecreated = mktime();
768         $grade->timemodified = mktime();
769         $grade->information = '13 of 17 grade_grades';
771         $grade->id = $DB->insert_record('grade_grades', $grade);
772         $this->grade_grades[] = $grade;
774         $grade = new stdClass();
775         $grade->itemid = $this->grade_items[7]->id;
776         $grade->userid = 3;
777         $grade->rawgrade = 6;
778         $grade->finalgrade = 6;
779         $grade->timecreated = mktime();
780         $grade->timemodified = mktime();
781         $grade->information = '14 of 17 grade_grades';
783         $grade->id = $DB->insert_record('grade_grades', $grade);
784         $this->grade_grades[] = $grade;
786         // Grades for grade_item 9
788         $grade = new stdClass();
789         $grade->itemid = $this->grade_items[8]->id;
790         $grade->userid = 1;
791         $grade->rawgrade = 20;
792         $grade->finalgrade = 20;
793         $grade->timecreated = mktime();
794         $grade->timemodified = mktime();
795         $grade->information = '15 of 17 grade_grades';
797         $grade->id = $DB->insert_record('grade_grades', $grade);
798         $this->grade_grades[] = $grade;
800         $grade = new stdClass();
801         $grade->itemid = $this->grade_items[8]->id;
802         $grade->userid = 2;
803         $grade->rawgrade = 50;
804         $grade->finalgrade = 50;
805         $grade->timecreated = mktime();
806         $grade->timemodified = mktime();
807         $grade->information = '16 of 17 grade_grades';
809         $grade->id = $DB->insert_record('grade_grades', $grade);
810         $this->grade_grades[] = $grade;
812         $grade = new stdClass();
813         $grade->itemid = $this->grade_items[8]->id;
814         $grade->userid = 3;
815         $grade->rawgrade = 100;
816         $grade->finalgrade = 100;
817         $grade->timecreated = mktime();
818         $grade->timemodified = mktime();
819         $grade->information = '17 of 17 grade_grades';
821         $grade->id = $DB->insert_record('grade_grades', $grade);
822         $this->grade_grades[] = $grade;
823     }
825     /**
826      * Load grade_outcome data into the database, and adds the corresponding objects to this class' variable.
827      */
828     function load_grade_outcomes() {
829         global $DB;
831         //this method is called once for each test method. Avoid adding things to $this->grade_outcomes multiple times
832         $this->grade_outcomes = array();
834         // Calculation for grade_item 1
835         $grade_outcome = new stdClass();
836         $grade_outcome->fullname = 'Team work';
837         $grade_outcome->shortname = 'Team work';
838         $grade_outcome->fullname = 'Team work outcome';
839         $grade_outcome->timecreated = mktime();
840         $grade_outcome->timemodified = mktime();
841         $grade_outcome->scaleid = $this->scale[2]->id;
843         $grade_outcome->id = $DB->insert_record('grade_outcomes', $grade_outcome);
844         $this->grade_outcomes[] = $grade_outcome;
846         // Calculation for grade_item 2
847         $grade_outcome = new stdClass();
848         $grade_outcome->fullname = 'Complete circuit board';
849         $grade_outcome->shortname = 'Complete circuit board';
850         $grade_outcome->fullname = 'Complete circuit board';
851         $grade_outcome->timecreated = mktime();
852         $grade_outcome->timemodified = mktime();
853         $grade_outcome->scaleid = $this->scale[3]->id;
855         $grade_outcome->id = $DB->insert_record('grade_outcomes', $grade_outcome);
856         $this->grade_outcomes[] = $grade_outcome;
858         // Calculation for grade_item 3
859         $grade_outcome = new stdClass();
860         $grade_outcome->fullname = 'Debug Java program';
861         $grade_outcome->shortname = 'Debug Java program';
862         $grade_outcome->fullname = 'Debug Java program';
863         $grade_outcome->timecreated = mktime();
864         $grade_outcome->timemodified = mktime();
865         $grade_outcome->scaleid = $this->scale[4]->id;
867         $grade_outcome->id = $DB->insert_record('grade_outcomes', $grade_outcome);
868         $this->grade_outcomes[] = $grade_outcome;
869     }
871 /**
872  * No unit tests here
873  */