protected function getMapResponseTemplateValidation()
 {
     // Build `value` array for a `valid_response` objects
     $values = [];
     $score = 0;
     foreach ($this->responseDeclaration->getMapping()->getMapEntries() as $mapEntry) {
         /** @var MapEntry $mapEntry */
         $score += $mapEntry->getMappedValue();
         $mapKey = $mapEntry->getMapKey();
         // Map response value and index based from `QtiDirectedPair` Value, try to guess which one is which since they
         // apparently can swap :(
         if (isset($this->stemsMapping[$mapKey->getFirst()]) && isset($this->optionsMapping[$mapKey->getSecond()])) {
             $responseIndex = $this->stemsMapping[$mapKey->getFirst()];
             $responseValue = $this->optionsMapping[$mapKey->getSecond()];
         } else {
             if (isset($this->stemsMapping[$mapKey->getSecond()]) && isset($this->optionsMapping[$mapKey->getFirst()])) {
                 $responseIndex = $this->stemsMapping[$mapKey->getSecond()];
                 $responseValue = $this->optionsMapping[$mapKey->getFirst()];
             } else {
                 throw new MappingException('Fail to match identifiers on `mapKey` attribute from `mapping`');
             }
         }
         // Build values array in the correct order
         if (!isset($values[$responseIndex])) {
             $values[$responseIndex] = [$responseValue];
         } else {
             array_push($values[$responseIndex], $responseValue);
         }
     }
     // Just to make sure we don't screw the order
     ksort($values);
     return ValidationBuilder::build('choicematrix', 'exactMatch', [new ValidResponse($score, $values)]);
 }
 protected function getMatchCorrectTemplateValidation()
 {
     $choicesIndexes = array_flip(array_keys($this->choices));
     $correctResponses = $this->responseDeclaration->getCorrectResponse()->getValues()->getArrayCopy(true);
     $values = [];
     /** @var Value $response */
     foreach ($correctResponses as $response) {
         $identifier = $response->getValue();
         $values[] = strval($choicesIndexes[$identifier]);
     }
     // No alt responses for hotspot interaction
     return ValidationBuilder::build('hotspot', 'exactMatch', [new ValidResponse(1, $values)]);
 }
 protected function getMatchCorrectTemplateValidation()
 {
     // TODO: Validate against mismatch possible responses and correct response
     // Build the `value` object on `valid_response`
     $values = [];
     foreach ($this->responseDeclaration->getCorrectResponse()->getValues() as $v) {
         /** @var Value $v */
         $value = $v->getValue();
         if (!isset($this->orderMapping[$value])) {
             LogService::log('Cannot locate ' . $value . ' in responseDeclaration');
             continue;
         }
         $values[] = $this->orderMapping[$value];
     }
     return ValidationBuilder::build('orderlist', 'exactMatch', [new ValidResponse(1, $values)]);
 }
 protected function getMapResponseTemplateValidation()
 {
     $mapEntryValueMap = [];
     foreach ($this->responseDeclaration->getMapping()->getMapEntries() as $mapEntry) {
         /** @var MapEntry $mapEntry */
         $mapEntryValueMap[] = ['key' => $this->hottextComponents[$mapEntry->getMapKey()], 'score' => $mapEntry->getMappedValue()];
     }
     $combinations = ArrayUtil::combinations($mapEntryValueMap);
     $correctResponses = [];
     foreach ($combinations as $combination) {
         if (count($combination) > 0 && count($combination) <= $this->maxChoices) {
             $score = array_sum(array_column($combination, 'score'));
             $value = array_column($combination, 'key');
             $correctResponses[] = new ValidResponse($score, $value);
         }
     }
     return ValidationBuilder::build('tokenhighlight', 'exactMatch', $correctResponses);
 }
 protected function getMapResponseTemplateValidation()
 {
     $interactionResponses = [];
     /** @var ResponseDeclaration $responseDeclaration */
     foreach ($this->responseDeclarations as $responseIdentifier => $responseDeclaration) {
         $responses = [];
         foreach ($responseDeclaration->getMapping()->getMapEntries()->getArrayCopy(true) as $mapEntry) {
             /** @var MapEntry $mapEntry */
             $responses[] = new ValidResponse($mapEntry->getMappedValue(), [$this->possibleResponses[$responseIdentifier][$mapEntry->getMapKey()]]);
             // Find out if one of them is case sensitive
             if (!$mapEntry->isCaseSensitive()) {
                 LogService::log('Could not support `caseSensitive` attribute for this interaction type. This question validation is always case sensitive');
             }
         }
         $interactionResponses[] = $responses;
     }
     $responses = ArrayUtil::cartesianProductForResponses($interactionResponses);
     return ValidationBuilder::build('clozedropdown', 'exactMatch', $responses);
 }
 protected function getMapResponseTemplateValidation()
 {
     $interactionResponses = [];
     /** @var ResponseDeclaration $responseDeclaration */
     foreach ($this->responseDeclarations as $responseIdentifier => $responseDeclaration) {
         $responses = [];
         foreach ($responseDeclaration->getMapping()->getMapEntries()->getArrayCopy(true) as $mapEntry) {
             /** @var MapEntry $mapEntry */
             $responses[] = new ValidResponse($mapEntry->getMappedValue(), [$mapEntry->getMapKey()]);
             // Find out if one of them is case sensitive
             if ($mapEntry->isCaseSensitive()) {
                 $this->isCaseSensitive = true;
             }
         }
         $interactionResponses[] = $responses;
     }
     $responses = ArrayUtil::cartesianProductForResponses($interactionResponses);
     return ValidationBuilder::build('clozetext', 'exactMatch', $responses);
 }
Пример #7
0
 public function testMcqWithExactMatchValidation()
 {
     $question = $this->buildMcq(['ChoiceA' => 'Melbourne', 'ChoiceB' => 'Sydney', 'ChoiceC' => 'Jakarta']);
     $question->set_stimulus('<strong>Where is Learnosity office in Australia located?</strong>');
     /** @var mcq_validation $validation */
     $validation = ValidationBuilder::build('mcq', 'exactMatch', [new ValidResponse(1, ['ChoiceB'])]);
     $question->set_validation($validation);
     $mcqMapper = new McqMapper();
     /** @var ResponseDeclaration $responseDeclaration */
     /** @var ResponseProcessing $responseProcessing */
     list($interaction, $responseDeclaration, $responseProcessing) = $mcqMapper->convert($question, 'testIdentifier', 'testIdentifierLabel');
     $this->assertTrue($interaction instanceof ChoiceInteraction);
     // Check on the responseDeclaration and responseProcessing objects to be correctly generated
     $this->assertEquals(Constants::RESPONSE_PROCESSING_TEMPLATE_MATCH_CORRECT, $responseProcessing->getTemplate());
     $this->assertEquals(Cardinality::SINGLE, $responseDeclaration->getCardinality());
     $this->assertEquals(BaseType::IDENTIFIER, $responseDeclaration->getBaseType());
     $this->assertNotNull($responseDeclaration->getCorrectResponse());
     $this->assertEquals('ChoiceB', $responseDeclaration->getCorrectResponse()->getValues()->getArrayCopy(true)[0]->getValue());
     $this->assertNull($responseDeclaration->getMapping());
 }
 public function testWithComplexExactMatchValidation()
 {
     $orderlist = $this->buildOrderlist(['ant', 'elephant', 'dog'], 'Order these animal from big to small');
     /** @var orderlist_validation $validation */
     $validation = ValidationBuilder::build('orderlist', 'exactMatch', [new ValidResponse(3, [1, 2, 0]), new ValidResponse(1, [2, 1, 0])]);
     $orderlist->set_validation($validation);
     /** @var orderlist_validation $validation */
     $orderlistMapper = new OrderlistMapper();
     /** @var ResponseDeclaration $responseDeclaration */
     /** @var ResponseProcessing $responseProcessing */
     list($interaction, $responseDeclaration, $responseProcessing) = $orderlistMapper->convert($orderlist, 'testIdentifier', 'testIdentifierLabel');
     /** @var OrderInteraction $interaction */
     $this->assertTrue($interaction instanceof OrderInteraction);
     // Assert response declaration is correct
     /** @var Value[] $correctResponseValues */
     $this->assertEquals(Cardinality::ORDERED, $responseDeclaration->getCardinality());
     $correctResponseValues = $responseDeclaration->getCorrectResponse()->getValues()->getArrayCopy(true);
     $this->assertEquals('CHOICE_1', $correctResponseValues[0]->getValue());
     $this->assertEquals('CHOICE_2', $correctResponseValues[1]->getValue());
     $this->assertEquals('CHOICE_0', $correctResponseValues[2]->getValue());
     $this->assertEquals(Constants::RESPONSE_PROCESSING_TEMPLATE_MATCH_CORRECT, $responseProcessing->getTemplate());
 }
 protected function getMapResponseTemplateValidation()
 {
     $validResponses = [];
     foreach ($this->responseDeclaration->getMapping()->getMapEntries() as $mapEntry) {
         /** @var MapEntry $mapEntry */
         if (!isset($this->options[$mapEntry->getMapKey()])) {
             LogService::log('Invalid choice `' . $mapEntry->getMapKey() . '`');
             continue;
         }
         if ($mapEntry->getMappedValue() < 0) {
             LogService::log('Invalid score ` ' . $mapEntry->getMappedValue() . ' `. Negative score is ignored');
             continue;
         }
         $validResponses[] = new ValidResponse($mapEntry->getMappedValue(), [$mapEntry->getMapKey()]);
     }
     // Handle `multiple` cardinality
     if ($this->responseDeclaration->getCardinality() === Cardinality::MULTIPLE) {
         $combinationChoicesCount = $this->maxChoices === 0 ? count($validResponses) : $this->maxChoices;
         $combinationResponses = ArrayUtil::combinations($validResponses, $combinationChoicesCount);
         $validResponses = ArrayUtil::combineValidResponsesWithSummedScore($combinationResponses);
     }
     return ValidationBuilder::build('mcq', 'exactMatch', $validResponses);
 }
 public function testMultipleResponsesWithValidation()
 {
     $question = $this->buildSimpleChoiceMatrixQuestion();
     /** @var choicematrix_validation $validation */
     $validation = ValidationBuilder::build('choicematrix', 'exactMatch', [new ValidResponse(3, [0, [1, 2]]), new ValidResponse(1, [0, 1])]);
     $question->set_validation($validation);
     $question->set_multiple_responses(true);
     /** @var MatchInteraction $interaction */
     /** @var ResponseDeclaration $responseDeclaration */
     /** @var ResponseProcessing $responseProcessing */
     $mapper = new ChoicematrixMapper();
     list($interaction, $responseDeclaration, $responseProcessing) = $mapper->convert($question, 'testIdentifier', 'testIdentifier');
     $this->assertEquals(6, $interaction->getMaxAssociations());
     $this->assertEquals(1, $interaction->getMinAssociations());
     // Stem count
     /** @var Value[] $correctResponseValues */
     $correctResponseValues = $responseDeclaration->getCorrectResponse()->getValues()->getArrayCopy(true);
     $this->assertDirectPair($correctResponseValues[0]->getValue(), 'STEM_0', 'OPTION_0');
     $this->assertDirectPair($correctResponseValues[1]->getValue(), 'STEM_1', 'OPTION_1');
     $this->assertDirectPair($correctResponseValues[2]->getValue(), 'STEM_1', 'OPTION_2');
     // The validation in `choicematrix` relies on its key to describe the index of stem/option pair
     // Scoring is always set to `1`, with the upper bound is set to the actual valid_response`'s score
     $this->assertNull($responseDeclaration->getMapping());
 }
 protected function getMapResponseTemplateValidation()
 {
     $gapIdentifiersIndexMap = array_flip($this->gapIdentifiers);
     $responseIndexSet = [];
     $responses = [];
     foreach ($this->responseDeclaration->getMapping()->getMapEntries() as $mapEntry) {
         /** @var MapEntry $mapEntry */
         /** @var QtiDirectedPair $mapKey */
         $mapKey = $mapEntry->getMapKey();
         // Map response value and index based from the `mapKey`, try to guess which one is which since they
         // apparently can swap :(
         if (isset($this->possibleResponses[$mapKey->getFirst()]) && isset($gapIdentifiersIndexMap[$mapKey->getSecond()])) {
             $responseValue = $this->possibleResponses[$mapKey->getFirst()];
             $responseIndex = $gapIdentifiersIndexMap[$mapKey->getSecond()];
         } else {
             if (isset($this->possibleResponses[$mapKey->getSecond()]) && isset($gapIdentifiersIndexMap[$mapKey->getFirst()])) {
                 $responseValue = $this->possibleResponses[$mapKey->getSecond()];
                 $responseIndex = $gapIdentifiersIndexMap[$mapKey->getFirst()];
             } else {
                 throw new MappingException('Fail to match identifiers on `mapKey` attribute from `mapping`');
             }
         }
         // Check for duplicated response
         if (!$this->isDuplicatedResponse) {
             if (!isset($responseIndexSet[$responseValue])) {
                 $responseIndexSet[$responseValue] = true;
             } else {
                 $this->isDuplicatedResponse = true;
             }
         }
         // Wrap the identifier => score into an array as the identifier can be duplicated (Duplicated Response)
         // Build ValidResponse object array in the correct order matching the `gap` elements
         $responses[$responseIndex][] = new ValidResponse($mapEntry->getMappedValue(), [$responseValue]);
     }
     $this->assertEachGapHasCorrespondingValidResponses($responses);
     $responses = ArrayUtil::cartesianProductForResponses($responses);
     return ValidationBuilder\ValidationBuilder::build($this->questionTypeName, 'exactMatch', $responses);
 }
 private function buildShorttextWithValidation(array $validResponses)
 {
     $question = new shorttext('shorttext');
     $question->set_placeholder('placeholdertest');
     $question->set_stimulus('<strong>stimulushere</strong>');
     $validation = ValidationBuilder::build('shorttext', 'exactMatch', $validResponses);
     $question->set_validation($validation);
     return $question;
 }