コード例 #1
0
 /**
  * Helper method used by {@link export_to_xml()}. Handle the data for one question text.
  * @param array $xml the bit of the XML representing one question text.
  * @param qformat_xml $format the importer/exporter object.
  * @return stack_question_test the question test.
  */
 protected function import_xml_qtest($xml, qformat_xml $format)
 {
     $number = $format->getpath($xml, array('#', 'testcase', 0, '#'), null, false, 'Missing testcase number in the XML.');
     $inputs = array();
     if (isset($xml['#']['testinput'])) {
         foreach ($xml['#']['testinput'] as $inputxml) {
             $name = $format->getpath($inputxml, array('#', 'name', 0, '#'), '');
             $value = $format->getpath($inputxml, array('#', 'value', 0, '#'), '');
             $inputs[$name] = $value;
         }
     }
     $testcase = new stack_question_test($inputs);
     if (isset($xml['#']['expected'])) {
         foreach ($xml['#']['expected'] as $expectedxml) {
             $name = $format->getpath($expectedxml, array('#', 'name', 0, '#'), '');
             $expectedscore = $format->getpath($expectedxml, array('#', 'expectedscore', 0, '#'), '');
             $expectedpenalty = $format->getpath($expectedxml, array('#', 'expectedpenalty', 0, '#'), '');
             $expectedanswernote = $format->getpath($expectedxml, array('#', 'expectedanswernote', 0, '#'), '');
             $testcase->add_expected_result($name, new stack_potentialresponse_tree_state(1, true, $expectedscore, $expectedpenalty, '', array($expectedanswernote)));
         }
     }
     return array($number, $testcase);
 }
コード例 #2
0
 /**
  * Process a single question into an array
  * @param SimpleXMLElement $assessmentitem
  * @return the question as an array
  */
 protected function questiontoformfrom($assessmentitem)
 {
     // Set this to false to enable a range of conversions.
     $strictimport = true;
     $errors = array();
     $question = new stdClass();
     $question->qtype = 'stack';
     $question->name = (string) $assessmentitem->MetaData->dctitle->selection;
     $question->variantsselectionseed = '';
     $question->defaultmark = 1;
     $question->length = 1;
     // Note, new tags for [[input:ans1]] and validation are converted below, after inputs.
     $question->questiontext = (string) $assessmentitem->questionCasValues->questionStem->castext;
     $question->questiontextformat = FORMAT_HTML;
     // Always blank on import - we assume PRT feedback is embedded in the question.
     $question->specificfeedback = array('text' => '', 'format' => FORMAT_HTML, 'files' => array());
     $question->generalfeedback = (string) $assessmentitem->questionCasValues->workedSolution->castext;
     $question->generalfeedbackformat = FORMAT_HTML;
     $question->questionvariables = $this->convert_keyvals((string) $assessmentitem->questionCasValues->questionVariables->rawKeyVals);
     $newnote = (string) $assessmentitem->questionCasValues->questionNote->castext;
     if (strlen($newnote) > 255) {
         $question->questiontext .= "Question note too long on import:\n\n" . $newnote;
         $question->questionnote = "ERROR on import: question note too long.  See question text.";
     } else {
         $question->questionnote = $newnote;
     }
     // Question level options.
     $itemoptions = array();
     foreach ($assessmentitem->ItemOptions->stackoption as $stackoptionxml) {
         $name = (string) $stackoptionxml->name;
         $value = $this->convert_bools((string) $stackoptionxml->selected);
         $itemoptions[$name] = $value;
     }
     // Not all the STACK 2 options are used.  Some are thrown away.
     $question->questionsimplify = $itemoptions['Simplify'];
     // Bug in STACK 2 exporter: Penalty is not written...
     if (array_key_exists('Penalty', $itemoptions)) {
         $question->penalty = $itemoptions['Penalty'];
     } else {
         $question->penalty = 0.1;
     }
     $question->assumepositive = $itemoptions['AssumePos'];
     if ('(none)' == $itemoptions['MultiplicationSign']) {
         $itemoptions['MultiplicationSign'] = 'none';
     }
     $question->multiplicationsign = $itemoptions['MultiplicationSign'];
     $question->sqrtsign = $itemoptions['SqrtSign'];
     $question->complexno = $itemoptions['ComplexNo'];
     $question->inversetrig = 'cos-1';
     $question->matrixparens = '[';
     $question->prtcorrect = array('text' => $itemoptions['FeedbackGenericCorrect'], 'format' => FORMAT_HTML, 'files' => array());
     $question->prtpartiallycorrect = array('text' => $itemoptions['FeedbackGenericPCorrect'], 'format' => FORMAT_HTML, 'files' => array());
     $question->prtincorrect = array('text' => $itemoptions['FeedbackGenericIncorrect'], 'format' => FORMAT_HTML, 'files' => array());
     // Input elements.
     $inputtypemapping = array('Algebraic Input' => 'algebraic', 'True/False' => 'boolean', 'Textarea' => 'textarea', 'Single Character' => 'singlechar', 'Matrix' => 'matrix');
     $questionparts = array();
     foreach ($assessmentitem->questionparts->questionpart as $questionpartxml) {
         $questionpart = array();
         $inputtype = (string) $questionpartxml->inputType->selection;
         if (array_key_exists($inputtype, $inputtypemapping)) {
             $questionpart['type'] = $inputtypemapping[$inputtype];
         } else {
             if ($strictimport) {
                 $errors[] = 'Tried to set an input type named ' . $inputtype . ' for input ' . (string) $questionpartxml->name . ' in question ' . $question->name . '.  This has not yet been implemented in STACK 3.';
             } else {
                 $questionpart['type'] = 'algebraic';
             }
         }
         $inputoptions = array();
         foreach ($questionpartxml->stackoption as $stackoptionxml) {
             $name = (string) $stackoptionxml->name;
             $value = $this->convert_bools((string) $stackoptionxml->selected);
             $inputoptions[$name] = $value;
         }
         $questionpart['modelans'] = (string) $questionpartxml->teachersAns->casString;
         if (strlen($questionpart['modelans']) > 255) {
             $question->questionvariables .= "\n/*Automatically added by the importer*/";
             $question->questionvariables .= "\nlonganswer" . $name . ':' . $questionpart['modelans'] . "\n";
             $questionpart['modelans'] = 'longanswer' . $name;
         }
         $questionpart['boxsize'] = (string) $questionpartxml->boxsize;
         $questionpart['insertstars'] = $inputoptions['insertStars'];
         $questionpart['syntaxhint'] = (string) $questionpartxml->syntax;
         $questionpart['forbidwords'] = (string) $questionpartxml->forbiddenWords->Forbid;
         $questionpart['allowwords'] = '';
         $questionpart['forbidfloat'] = $inputoptions['forbidFloats'];
         // Export error: STACK 2 exporter does not seem to export these correctly.
         if (array_key_exists('lowestTerms', $inputoptions)) {
             $questionpart['requirelowestterms'] = (bool) $inputoptions['lowestTerms'];
         } else {
             $questionpart['requirelowestterms'] = true;
         }
         $questionpart['checkanswertype'] = $inputoptions['sameType'];
         $questionpart['strictsyntax'] = $inputoptions['formalSyntax'];
         // STACK 2 exporter does not seem to export these correctly anyway!
         $questionpart['mustverify'] = 1;
         $questionpart['showvalidation'] = 1;
         $questionpart['options'] = '';
         $name = (string) $questionpartxml->name;
         $questionparts[$name] = $questionpart;
     }
     $inputnames = array();
     foreach ($questionparts as $anskey => $questionpart) {
         $inputnames[] = $anskey;
         foreach ($questionpart as $key => $val) {
             $questionkey = $anskey . $key;
             $question->{$questionkey} = $val;
         }
     }
     // Change the input tags for the new versions.
     $question->questiontext = $this->convert_questiontext($question->questiontext, $inputnames);
     $question->specificfeedback['text'] = $this->fix_maths_delimiters($question->specificfeedback['text']);
     $question->generalfeedback = $this->fix_maths_delimiters($question->generalfeedback);
     $question->prtcorrect['text'] = $this->fix_maths_delimiters($question->prtcorrect['text']);
     $question->prtpartiallycorrect['text'] = $this->fix_maths_delimiters($question->prtpartiallycorrect['text']);
     $question->prtincorrect['text'] = $this->fix_maths_delimiters($question->prtincorrect['text']);
     // Potential response trees.
     $potentialresponsetrees = array();
     foreach ($assessmentitem->PotentialResponseTrees->PotentialResponseTree as $prtxml) {
         $name = (string) $prtxml->prtname;
         // STACK adds this for export purposes, because it can't cope with PRTs which are just a number.
         $name = str_replace('PotResTree_', '', $name);
         if (strlen($name) > 32) {
             if ($strictimport) {
                 $errors[] = 'The PRT name "' . $name . '" exceeds 32 characters and is too long.';
             }
             $name = substr($name, 0, 31);
         }
         $prt = array();
         $prt['value'] = (int) $prtxml->questionValue;
         $prt['autosimplify'] = $this->convert_bools((string) $prtxml->autoSimplify);
         $prt['feedbackvariables'] = $this->convert_keyvals((string) $prtxml->feedbackVariables);
         $potentialresponses = array();
         $autonumber = 0;
         foreach ($prtxml->PotentialResponses->PR as $prxml) {
             $id = (string) $prxml['id'];
             $pr = array();
             $pr['answertest'] = (string) $prxml->answerTest;
             if ('Equal_Com_Ass' == trim($pr['answertest'])) {
                 $pr['answertest'] = 'EqualComAss';
             }
             $pr['tans'] = (string) $prxml->teachersAns;
             if (strlen($pr['tans']) > 255) {
                 $prt['feedbackvariables'] .= "\n/*Automatically added by the importer*/";
                 $prt['feedbackvariables'] .= "\nlongexpr" . $autonumber . ':' . $pr['tans'] . "\n";
                 $autonumber += 1;
                 $pr['tans'] = 'longexpr' . $autonumber;
             }
             $pr['sans'] = (string) $prxml->studentAns;
             if (strlen($pr['sans']) > 255) {
                 $prt['feedbackvariables'] .= "\n/*Automatically added by the importer*/";
                 $prt['feedbackvariables'] .= "\nlongexpr" . $autonumber . ':' . $pr['sans'] . "\n";
                 $autonumber += 1;
                 $pr['sans'] = 'longexpr' . $autonumber;
             }
             $pr['testoptions'] = (string) $prxml->testoptions;
             if (strlen($pr['testoptions']) > 255) {
                 $prt['feedbackvariables'] .= "\n/*Automatically added by the importer*/";
                 $prt['feedbackvariables'] .= "\nlongexpr" . $autonumber . ':' . $pr['testoptions'] . "\n";
                 $autonumber += 1;
                 $pr['testoptions'] = 'longexpr' . $autonumber;
             }
             $pr['quiet'] = (string) $prxml->quietAnsTest;
             foreach (array('true', 'false') as $branchname) {
                 $branch = $this->getnextPR($branchname, $prxml);
                 foreach ($branch as $key => $val) {
                     if ('answernote' == $key and '' == trim($val)) {
                         $ids = (string) ($id + 1);
                         $val = $name . '-' . $ids . '-';
                         if ('true' == $branchname) {
                             $val .= 'T';
                         } else {
                             $val .= 'F';
                         }
                     }
                     $pr[$branchname . $key] = $val;
                 }
             }
             $potentialresponses[$id] = $pr;
         }
         $numericalfields = array('truescore', 'falsescore', 'truepenalty', 'falsepenalty');
         foreach ($potentialresponses as $prname => $pr) {
             foreach ($pr as $key => $val) {
                 $prt[$key][$prname] = $val;
                 if (in_array($key, $numericalfields) and '' != $val) {
                     // Tidy up numerical values.
                     $val = trim($val);
                     if (substr($val, 0, 1) == '.') {
                         $val = '0' . $val;
                     }
                     if (!($this->convert_floats($val) === (string) $val)) {
                         if ($strictimport) {
                             $errors[] = 'Tried to set a numerical field "' . $key . '" in potential response tree "' . $prname . '" in question "' . $question->name . '". with the illegal value "' . $val . '". This must be a float. ';
                         } else {
                             $prt[$key][$prname] = $this->convert_floats($val);
                         }
                     }
                 }
             }
         }
         $potentialresponsetrees[$name] = $prt;
     }
     $prtnames = array();
     foreach ($potentialresponsetrees as $name => $prt) {
         // STACK 3 (moodle forms?) can't cope with PRT names which are only a number.  So prepend "prt".
         $newname = $this->convert_prt_name($name);
         $prtnames[$name] = $newname;
         foreach ($prt as $key => $val) {
             $question->{$newname . $key} = $val;
         }
     }
     // Change the input tags for the new versions.
     // Single PRT questions are treated as a special case.
     if (1 == count($prtnames)) {
         foreach ($prtnames as $oldname => $newname) {
             $question->questiontext = str_replace('<PRTfeedback>' . $oldname . '</PRTfeedback>', '', $question->questiontext);
             $question->specificfeedback = array('text' => "<p>[[feedback:{$newname}]]</p>", 'format' => FORMAT_HTML, 'files' => array());
         }
     } else {
         foreach ($prtnames as $oldname => $newname) {
             $question->questiontext = str_replace('<PRTfeedback>' . $oldname . '</PRTfeedback>', "[[feedback:{$newname}]]", $question->questiontext);
         }
     }
     // Question tests.
     $itemtests = array();
     if ($assessmentitem->ItemTests) {
         $question->testcases[0] = null;
         foreach ($assessmentitem->ItemTests->test as $testxml) {
             $inputs = array();
             $prts = array();
             foreach ($testxml->children() as $col) {
                 $key = (string) $col->key;
                 $val = (string) $col->value;
                 if ('IE_' == substr($key, 0, 3)) {
                     $inputs[substr($key, 3)] = $val;
                 }
                 if ('PRT_' == substr($key, 0, 4)) {
                     // Knock off PR_PotResTree_.
                     if ('NONE' == $val) {
                         $val = 'NULL';
                     }
                     $key = $this->convert_prt_name(substr($key, 15));
                     if (strlen($key) > 32) {
                         $key = substr($key, 0, 31);
                     }
                     $prts[$key] = $val;
                 }
             }
             $qtest = new stack_question_test($inputs);
             foreach ($prts as $key => $val) {
                 $qtest->add_expected_result($key, new stack_potentialresponse_tree_state(1, true, 0, 0.1, '', array($val)));
             }
             $question->testcases[] = $qtest;
         }
         unset($question->testcases[0]);
     }
     return array($question, $errors);
 }
コード例 #3
0
    public function test_xml_import()
    {
        $xml = '<!-- question: 0  -->
  <question type="stack">
    <name>
      <text>test-0</text>
    </name>
    <questiontext format="html">
      <text>What is $1+1$? [[input:ans1]] [[validation:ans1]]</text>
    </questiontext>
    <generalfeedback format="html">
      <text></text>
    </generalfeedback>
    <defaultgrade>1</defaultgrade>
    <penalty>0.3333333</penalty>
    <hidden>0</hidden>
    <questionvariables>
      <text></text>
    </questionvariables>
    <specificfeedback format="html">
      <text>[[feedback:firsttree]]</text>
    </specificfeedback>
    <questionnote>
      <text></text>
    </questionnote>
    <questionsimplify>1</questionsimplify>
    <assumepositive>0</assumepositive>
    <prtcorrect format="html">
      <text><![CDATA[<p>Correct answer, well done.</p>]]></text>
    </prtcorrect>
    <prtpartiallycorrect format="html">
      <text><![CDATA[<p>Your answer is partially correct.</p>]]></text>
    </prtpartiallycorrect>
    <prtincorrect format="html">
      <text><![CDATA[<p>Incorrect answer.</p>]]></text>
    </prtincorrect>
    <multiplicationsign>dot</multiplicationsign>
    <sqrtsign>1</sqrtsign>
    <complexno>i</complexno>
    <inversetrig>cos-1</inversetrig>
    <matrixparens>[</matrixparens>
    <variantsselectionseed></variantsselectionseed>
    <input>
      <name>ans1</name>
      <type>algebraic</type>
      <tans>2</tans>
      <boxsize>5</boxsize>
      <strictsyntax>1</strictsyntax>
      <insertstars>0</insertstars>
      <syntaxhint></syntaxhint>
      <forbidwords></forbidwords>
      <allowwords></allowwords>
      <forbidfloat>1</forbidfloat>
      <requirelowestterms>0</requirelowestterms>
      <checkanswertype>0</checkanswertype>
      <mustverify>1</mustverify>
      <showvalidation>1</showvalidation>
      <options></options>
    </input>
    <prt>
      <name>firsttree</name>
      <value>1</value>
      <autosimplify>1</autosimplify>
      <feedbackvariables>
        <text></text>
      </feedbackvariables>
      <node>
        <name>0</name>
        <answertest>EqualComAss</answertest>
        <sans>ans1</sans>
        <tans>2</tans>
        <testoptions></testoptions>
        <quiet>0</quiet>
        <truescoremode>=</truescoremode>
        <truescore>1</truescore>
        <truepenalty>0</truepenalty>
        <truenextnode>-1</truenextnode>
        <trueanswernote>firsttree-1-T</trueanswernote>
        <truefeedback format="html">
          <text></text>
        </truefeedback>
        <falsescoremode>=</falsescoremode>
        <falsescore>0</falsescore>
        <falsepenalty>0</falsepenalty>
        <falsenextnode>-1</falsenextnode>
        <falseanswernote>firsttree-1-F</falseanswernote>
        <falsefeedback format="html">
          <text></text>
        </falsefeedback>
      </node>
    </prt>
    <deployedseed>12345</deployedseed>
    <qtest>
      <testcase>1</testcase>
      <testinput>
        <name>ans1</name>
        <value>2</value>
      </testinput>
      <expected>
        <name>firsttree</name>
        <expectedscore>1</expectedscore>
        <expectedpenalty>0</expectedpenalty>
        <expectedanswernote>firsttree-1-T</expectedanswernote>
      </expected>
    </qtest>
  </question>
';
        $xmldata = xmlize($xml);
        $importer = new qformat_xml();
        $q = $importer->try_importing_using_qtypes($xmldata['question'], null, null, 'stack');
        $expectedq = new stdClass();
        $expectedq->qtype = 'stack';
        $expectedq->name = 'test-0';
        $expectedq->questiontext = 'What is $1+1$? [[input:ans1]] [[validation:ans1]]';
        $expectedq->questiontextformat = FORMAT_HTML;
        $expectedq->generalfeedback = '';
        $expectedq->generalfeedbackformat = FORMAT_HTML;
        $expectedq->defaultmark = 1;
        $expectedq->length = 1;
        $expectedq->penalty = 0.3333333;
        $expectedq->questionvariables = '';
        $expectedq->specificfeedback = array('text' => '[[feedback:firsttree]]', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->questionnote = '';
        $expectedq->questionsimplify = 1;
        $expectedq->assumepositive = 0;
        $expectedq->prtcorrect = array('text' => '<p>Correct answer, well done.</p>', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->prtpartiallycorrect = array('text' => '<p>Your answer is partially correct.</p>', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->prtincorrect = array('text' => '<p>Incorrect answer.</p>', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->multiplicationsign = 'dot';
        $expectedq->sqrtsign = 1;
        $expectedq->complexno = 'i';
        $expectedq->inversetrig = 'cos-1';
        $expectedq->matrixparens = '[';
        $expectedq->variantsselectionseed = '';
        $expectedq->ans1type = 'algebraic';
        $expectedq->ans1modelans = 2;
        $expectedq->ans1boxsize = 5;
        $expectedq->ans1strictsyntax = 1;
        $expectedq->ans1insertstars = 0;
        $expectedq->ans1syntaxhint = '';
        $expectedq->ans1forbidwords = '';
        $expectedq->ans1allowwords = '';
        $expectedq->ans1forbidfloat = 1;
        $expectedq->ans1requirelowestterms = 0;
        $expectedq->ans1checkanswertype = 0;
        $expectedq->ans1mustverify = 1;
        $expectedq->ans1showvalidation = 1;
        $expectedq->ans1options = '';
        $expectedq->firsttreevalue = 1;
        $expectedq->firsttreeautosimplify = 1;
        $expectedq->firsttreefeedbackvariables = '';
        $expectedq->firsttreeanswertest[0] = 'EqualComAss';
        $expectedq->firsttreesans[0] = 'ans1';
        $expectedq->firsttreetans[0] = '2';
        $expectedq->firsttreetestoptions[0] = '';
        $expectedq->firsttreequiet[0] = 0;
        $expectedq->firsttreetruescoremode[0] = '=';
        $expectedq->firsttreetruescore[0] = 1;
        $expectedq->firsttreetruepenalty[0] = 0;
        $expectedq->firsttreetruenextnode[0] = -1;
        $expectedq->firsttreetrueanswernote[0] = 'firsttree-1-T';
        $expectedq->firsttreetruefeedback[0] = array('text' => '', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->firsttreefalsescoremode[0] = '=';
        $expectedq->firsttreefalsescore[0] = 0;
        $expectedq->firsttreefalsepenalty[0] = 0;
        $expectedq->firsttreefalsenextnode[0] = -1;
        $expectedq->firsttreefalseanswernote[0] = 'firsttree-1-F';
        $expectedq->firsttreefalsefeedback[0] = array('text' => '', 'format' => FORMAT_HTML, 'files' => array());
        $expectedq->deployedseeds = array('12345');
        $qtest = new stack_question_test(array('ans1' => '2'));
        $qtest->add_expected_result('firsttree', new stack_potentialresponse_tree_state(1, true, 1, 0, '', array('firsttree-1-T')));
        $expectedq->testcases[1] = $qtest;
        $this->assert(new question_check_specified_fields_expectation($expectedq), $q);
        $this->assertEquals($expectedq->deployedseeds, $q->deployedseeds);
        // Redundant, but gives better fail messages.
        $this->assertEquals($expectedq->testcases, $q->testcases);
        // Redundant, but gives better fail messages.
    }
コード例 #4
0
    $mform->set_data($currentdata);
}
// Process the form.
if ($mform->is_cancelled()) {
    unset($urlparams['testcase']);
    redirect($backurl);
} else {
    if ($data = $mform->get_data()) {
        // Process form submission.
        $inputs = array();
        foreach ($question->inputs as $inputname => $notused) {
            $inputs[$inputname] = $data->{$inputname};
        }
        $qtest = new stack_question_test($inputs);
        foreach ($question->prts as $prtname => $notused) {
            $qtest->add_expected_result($prtname, new stack_potentialresponse_tree_state(1, true, $data->{$prtname . 'score'}, $data->{$prtname . 'penalty'}, '', array($data->{$prtname . 'answernote'})));
        }
        question_bank::get_qtype('stack')->save_question_test($questionid, $qtest, $testcase);
        redirect($backurl);
    }
}
// Prepare the display options.
$options = new question_display_options();
$options->readonly = true;
$options->flags = question_display_options::HIDDEN;
$options->suppressruntestslink = true;
// Display the page.
echo $OUTPUT->header();
// Show the question read-only.
echo $quba->render_question($slot, $options);
// Display the question variables.
コード例 #5
0
 /**
  * @return qtype_stack_question the question from the test0.xml file.
  */
 public static function get_stack_question_data_test0()
 {
     question_bank::load_question_definition_classes('stack');
     $qdata = new stdClass();
     test_question_maker::initialise_question_data($qdata);
     $qdata->qtype = 'stack';
     $qdata->name = 'test-0';
     $qdata->questiontext = 'What is $1+1$? [[input:ans1]]
                             [[validation:ans1]]';
     $qdata->generalfeedback = '';
     $qdata->options = new stdClass();
     $qdata->options->id = 0;
     $qdata->options->questionvariables = '';
     $qdata->options->specificfeedback = '[[feedback:firsttree]]';
     $qdata->options->specificfeedbackformat = FORMAT_HTML;
     $qdata->options->questionnote = '';
     $qdata->options->questionsimplify = 1;
     $qdata->options->assumepositive = 0;
     $qdata->options->prtcorrect = self::DEFAULT_CORRECT_FEEDBACK;
     $qdata->options->prtcorrectformat = FORMAT_HTML;
     $qdata->options->prtpartiallycorrect = self::DEFAULT_PARTIALLYCORRECT_FEEDBACK;
     $qdata->options->prtpartiallycorrectformat = FORMAT_HTML;
     $qdata->options->prtincorrect = self::DEFAULT_INCORRECT_FEEDBACK;
     $qdata->options->prtincorrectformat = FORMAT_HTML;
     $qdata->options->multiplicationsign = 'dot';
     $qdata->options->sqrtsign = 1;
     $qdata->options->complexno = 'i';
     $qdata->options->inversetrig = 'cos-1';
     $qdata->options->matrixparens = '[';
     $qdata->options->variantsselectionseed = '';
     $input = new stdClass();
     $input->name = 'ans1';
     $input->id = 0;
     $input->questionid = 0;
     $input->type = 'algebraic';
     $input->tans = '2';
     $input->boxsize = 5;
     $input->strictsyntax = 1;
     $input->insertstars = 0;
     $input->syntaxhint = '';
     $input->forbidwords = '';
     $input->allowwords = '';
     $input->forbidfloat = 1;
     $input->requirelowestterms = 0;
     $input->checkanswertype = 0;
     $input->mustverify = 1;
     $input->showvalidation = 1;
     $input->options = '';
     $qdata->inputs['ans1'] = $input;
     $prt = new stdClass();
     $prt->name = 'firsttree';
     $prt->id = '0';
     $prt->questionid = '0';
     $prt->value = 1;
     $prt->autosimplify = 1;
     $prt->feedbackvariables = '';
     $prt->firstnodename = '0';
     $node = new stdClass();
     $node->id = 0;
     $node->questionid = 0;
     $node->prtname = 'firsttree';
     $node->nodename = '0';
     $node->answertest = 'EqualComAss';
     $node->sans = 'ans1';
     $node->tans = '2';
     $node->testoptions = '';
     $node->quiet = 0;
     $node->truescoremode = '=';
     $node->truescore = 1;
     $node->truepenalty = 0;
     $node->truenextnode = -1;
     $node->trueanswernote = 'firsttree-1-T';
     $node->truefeedback = '';
     $node->truefeedbackformat = FORMAT_HTML;
     $node->falsescoremode = '=';
     $node->falsescore = 0;
     $node->falsepenalty = 0;
     $node->falsenextnode = -1;
     $node->falseanswernote = 'firsttree-1-F';
     $node->falsefeedback = '';
     $node->falsefeedbackformat = FORMAT_HTML;
     $prt->nodes['0'] = $node;
     $qdata->prts['firsttree'] = $prt;
     $qdata->deployedseeds = array('12345');
     $qtest = new stack_question_test(array('ans1' => '2'));
     $qtest->add_expected_result('firsttree', new stack_potentialresponse_tree_state(1, true, 1, 0, '', array('firsttree-1-T')));
     $qdata->testcases[1] = $qtest;
     return $qdata;
 }