Index: lams_central/src/java/org/lamsfoundation/lams/web/QuestionsController.java
===================================================================
diff -u -r52f835246c157f47eed9df1d47f9e7bb0c16315d -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_central/src/java/org/lamsfoundation/lams/web/QuestionsController.java	(.../QuestionsController.java)	(revision 52f835246c157f47eed9df1d47f9e7bb0c16315d)
+++ lams_central/src/java/org/lamsfoundation/lams/web/QuestionsController.java	(.../QuestionsController.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -3,6 +3,7 @@
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStream;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Set;
 import java.util.TreeSet;
@@ -109,7 +110,7 @@
 
 	InputStream uploadedFileStream = new FileInputStream(file);
 
-	Question[] questions;
+	Collection<Question> questions;
 	if (packageName.endsWith(".xml")) {
 	    questions = QuestionParser.parseQTIFile(uploadedFileStream, null, limitType);
 
Index: lams_central/src/java/org/lamsfoundation/lams/web/qb/ImsQtiController.java
===================================================================
diff -u -r970744e51617c0614313597e042767b43f5a7326 -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_central/src/java/org/lamsfoundation/lams/web/qb/ImsQtiController.java	(.../ImsQtiController.java)	(revision 970744e51617c0614313597e042767b43f5a7326)
+++ lams_central/src/java/org/lamsfoundation/lams/web/qb/ImsQtiController.java	(.../ImsQtiController.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -168,7 +168,17 @@
 		    if (question.getAnswers() != null) {
 			TreeSet<QbOption> optionList = new TreeSet<>();
 			int orderId = 0;
+			float maxScore = 0;
+
 			for (Answer answer : question.getAnswers()) {
+			    if (answer.getScore() != null && answer.getScore() > maxScore) {
+				maxScore = answer.getScore();
+			    }
+			}
+
+			questionMark = Double.valueOf(Math.ceil(maxScore)).intValue();
+
+			for (Answer answer : question.getAnswers()) {
 			    String answerText = QuestionParser.processHTMLField(answer.getText(), false,
 				    contentFolderID, question.getResourcesFolderPath());
 			    if ((correctAnswer != null) && correctAnswer.equals(answerText)) {
@@ -186,16 +196,14 @@
 			    option.setFeedback(answer.getFeedback());
 			    option.setQbQuestion(qbQuestion);
 
-			    if ((answer.getScore() != null) && (answer.getScore() > 0) && (correctAnswer == null)) {
-				if (questionMark == null) {
-				    // whatever the correct answer holds, it becomes the question score
-				    questionMark = Double.valueOf(Math.ceil(answer.getScore())).intValue();
+			    // cast exact score to scale 0-1
+			    if (answer.getScore() != null && answer.getScore() > 0) {
+				if (correctAnswer == null && answer.getScore() == maxScore) {
+				    correctAnswer = answerText;
 				}
-				// 100% goes to the correct answer
-				option.setMaxMark(1);
-				correctAnswer = answerText;
-			    } else {
-				option.setMaxMark(0);
+				float score = Double.valueOf(Math.round(answer.getScore() / maxScore * 100.0) / 100.0)
+					.floatValue();
+				option.setMaxMark(score);
 			    }
 
 			    optionList.add(option);
Index: lams_central/web/questions/questionChoice.jsp
===================================================================
diff -u -r0f295260a6f4f68d391ed74f3a7967fbf841af90 -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_central/web/questions/questionChoice.jsp	(.../questionChoice.jsp)	(revision 0f295260a6f4f68d391ed74f3a7967fbf841af90)
+++ lams_central/web/questions/questionChoice.jsp	(.../questionChoice.jsp)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -59,27 +59,12 @@
 			});
 			
 			if (anyQuestionsSelected) {
-				var form = $("#questionForm");
-				if (returnURL == '') {
-					form.css('visibility', 'hidden');
-					window.opener.saveQTI(form[0].outerHTML, 'questionForm', callerID);
-					// needs to be called twice for Chrome to close pop up window
-					window.close();
-					window.close();
-				} else {
-					// this code is not really used at the moment, but it's available
-					$.ajax({
-						type: "POST",
-						url: returnURL,
-						data: form.serializeArray(),
-						success: function(response) {
-							window.opener.location.reload();
-							// needs to be called twice for Chrome to close pop up window
-							window.close();
-							window.close();
-						}
-					});
-				}
+				var form = $("#questionForm").css('visibility', 'hidden');
+				window.opener.saveQTI(form[0].outerHTML, 'questionForm', callerID);
+				// needs to be called twice for Chrome to close pop up window
+				window.close();
+				window.close();
+
 			} else {
 				$('#errorArea').show();
 			}
@@ -117,7 +102,7 @@
 			$('#selectAll').click(function(){
 				var checked = $(this).is(':checked');
 				
-				$('.question').attr('checked', checked);
+				$('.question').attr('checked', checked).prop('checked', checked);
 				$('.questionAttribute').attr('disabled', checked ? null : 'disabled');
 				if (checked) {
 					$('#errorArea').hide('slow');
Index: lams_common/src/java/org/lamsfoundation/lams/qb/model/QbOption.java
===================================================================
diff -u -r2188972474f8d186d6811e3dea2e4136be669335 -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_common/src/java/org/lamsfoundation/lams/qb/model/QbOption.java	(.../QbOption.java)	(revision 2188972474f8d186d6811e3dea2e4136be669335)
+++ lams_common/src/java/org/lamsfoundation/lams/qb/model/QbOption.java	(.../QbOption.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -2,7 +2,6 @@
 
 import java.io.Serializable;
 
-import javax.persistence.Cacheable;
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
Index: lams_common/src/java/org/lamsfoundation/lams/questions/Question.java
===================================================================
diff -u -r71ecf7fae19f2c5bb42f613c3a72b062b145767e -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_common/src/java/org/lamsfoundation/lams/questions/Question.java	(.../Question.java)	(revision 71ecf7fae19f2c5bb42f613c3a72b062b145767e)
+++ lams_common/src/java/org/lamsfoundation/lams/questions/Question.java	(.../Question.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -145,11 +145,11 @@
     }
 
     public Integer getScore() {
-        return score;
+	return score;
     }
 
     public void setScore(Integer mark) {
-        this.score = mark;
+	this.score = mark;
     }
 
     @Override
@@ -162,12 +162,9 @@
 	if (this == obj) {
 	    return true;
 	}
-	if (obj == null) {
+	if ((obj == null) || !(obj instanceof Question)) {
 	    return false;
 	}
-	if (!(obj instanceof Question)) {
-	    return false;
-	}
 	Question other = (Question) obj;
 	if (text == null) {
 	    if (other.text != null) {
Index: lams_common/src/java/org/lamsfoundation/lams/questions/QuestionParser.java
===================================================================
diff -u -r0f295260a6f4f68d391ed74f3a7967fbf841af90 -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_common/src/java/org/lamsfoundation/lams/questions/QuestionParser.java	(.../QuestionParser.java)	(revision 0f295260a6f4f68d391ed74f3a7967fbf841af90)
+++ lams_common/src/java/org/lamsfoundation/lams/questions/QuestionParser.java	(.../QuestionParser.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -28,7 +28,9 @@
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -41,12 +43,17 @@
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathFactory;
 
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
+import org.lamsfoundation.lams.qb.QbUtils;
 import org.lamsfoundation.lams.util.UploadFileUtil;
 import org.lamsfoundation.lams.util.WebUtil;
+import org.lamsfoundation.lams.util.XMLUtil;
 import org.lamsfoundation.lams.util.zipfile.ZipFileUtil;
 import org.lamsfoundation.lams.util.zipfile.ZipFileUtilException;
 import org.w3c.dom.Document;
@@ -70,42 +77,35 @@
     // can be anything
     private static final String TEMP_PACKAGE_NAME_PREFIX = "QTI_PACKAGE_";
     private static final Pattern IMAGE_PATTERN = Pattern.compile("\\[IMAGE: ([^\\]]+)\\]");
+    private static XPath xPath = XPathFactory.newInstance().newXPath();
 
     public static final String UUID_LABEL_PREFIX = "lams-qb-uuid-";
 
     /**
      * Extracts questions from IMS QTI zip file.
      */
-    public static Question[] parseQTIPackage(InputStream packageFileStream, Set<String> limitType)
+    public static Collection<Question> parseQTIPackage(InputStream packageFileStream, Set<String> limitType)
 	    throws SAXParseException, IOException, SAXException, ParserConfigurationException, ZipFileUtilException {
 	List<Question> result = new ArrayList<>();
 
 	// unique folder name
 	String tempPackageName = TEMP_PACKAGE_NAME_PREFIX + System.currentTimeMillis();
 	String tempPackageDirPath = ZipFileUtil.expandZip(packageFileStream, tempPackageName);
-	try {
+	try (packageFileStream) {
 	    List<File> resourceFiles = QuestionParser.getQTIResourceFiles(tempPackageDirPath);
 	    if (resourceFiles.isEmpty()) {
 		log.warn("No resource files found in QTI package");
 	    } else {
 		// extract from every XML file; usually there is just one
 		for (File resourceFile : resourceFiles) {
-		    FileInputStream xmlFileStream = new FileInputStream(resourceFile);
-		    Question[] fileQuestions = null;
-		    try {
-			fileQuestions = QuestionParser.parseQTIFile(xmlFileStream, tempPackageDirPath, limitType);
-		    } finally {
-			xmlFileStream.close();
+		    try (FileInputStream xmlFileStream = new FileInputStream(resourceFile)) {
+			Collection<Question> fileQuestions = QuestionParser.parseQTIFile(xmlFileStream,
+				tempPackageDirPath, limitType);
+			result.addAll(fileQuestions);
 		    }
-		    if (fileQuestions != null) {
-			Collections.addAll(result, fileQuestions);
-		    }
 		}
 	    }
 	} finally {
-	    // clean up
-	    packageFileStream.close();
-
 	    // if there are any images attached, do not delete the exploded ZIP
 	    // unfortunately, in this case it stays there until OS does temp dir clean up
 	    boolean tempFolderStillNeeded = false;
@@ -122,251 +122,264 @@
 	    }
 	}
 
-	return result.toArray(Question.QUESTION_ARRAY_TYPE);
+	return result;
     }
 
     /**
      * Extracts questions from IMS QTI xml file.
      */
-    public static Question[] parseQTIFile(InputStream xmlFileStream, String resourcesFolderPath, Set<String> limitType)
-	    throws ParserConfigurationException, SAXException, IOException {
-	List<Question> result = new ArrayList<>();
+    public static Collection<Question> parseQTIFile(InputStream xmlFileStream, String resourcesFolderPath,
+	    Set<String> limitType) throws ParserConfigurationException, SAXException, IOException {
+	List<Question> questions = new ArrayList<>();
 	DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
 	Document doc = docBuilder.parse(xmlFileStream);
 
+	// in theory in a single QTI package v1 and v2 items can be mixed
 	NodeList questionItems = doc.getElementsByTagName("item");
-	// yes, a label here for convenience
-	questionLoop: for (int questionItemIndex = 0; questionItemIndex < questionItems
-		.getLength(); questionItemIndex++) {
+	for (int questionItemIndex = 0; questionItemIndex < questionItems.getLength(); questionItemIndex++) {
 	    Element questionItem = (Element) questionItems.item(questionItemIndex);
-	    NodeList questionItemTypes = questionItem.getElementsByTagName("qmd_itemtype");
-	    String questionItemType = questionItemTypes.getLength() > 0
-		    ? ((Text) questionItemTypes.item(0).getChildNodes().item(0)).getData()
-		    : null;
-	    Question question = new Question();
-	    // check if it is "matching" question type
-	    if ("Matching".equalsIgnoreCase(questionItemType)
-		    && !QuestionParser.isQuestionTypeAcceptable(Question.QUESTION_TYPE_MATCHING, limitType, question)) {
-		continue;
+	    Question question = QuestionParser.parseQTIItemVesion1(questionItem, resourcesFolderPath, limitType);
+	    if (question != null) {
+		questions.add(question);
 	    }
-	    String questionTitle = questionItem.getAttribute("title");
-	    question.setTitle(questionTitle);
-	    String questionLabel = questionItem.getAttribute("label");
-	    if (StringUtils.isNotBlank(questionLabel)) {
-		question.setLabel(questionLabel);
+	}
+
+	questionItems = doc.getElementsByTagName("assessmentItem");
+	for (int questionItemIndex = 0; questionItemIndex < questionItems.getLength(); questionItemIndex++) {
+	    Element questionItem = (Element) questionItems.item(questionItemIndex);
+	    Question question = QuestionParser.parseQTIItemVesion2(questionItem, resourcesFolderPath, limitType);
+	    if (question != null) {
+		questions.add(question);
 	    }
+	}
 
-	    Map<String, Answer> answerMap = new TreeMap<>();
-	    Map<String, Answer> matchAnswerMap = null;
-	    boolean textBasedQuestion = false;
+	return questions;
+    }
 
-	    Element presentation = (Element) questionItem.getElementsByTagName("presentation").item(0);
-	    NodeList presentationChildrenList = presentation.getChildNodes();
-	    // cumberstone parsing, but there is no other way using this API
-	    for (int presentationChildIndex = 0; presentationChildIndex < presentationChildrenList
-		    .getLength(); presentationChildIndex++) {
-		Node presentationChild = presentationChildrenList.item(presentationChildIndex);
-		// here is where question data is stored
-		if ("material".equals(presentationChild.getNodeName())) {
-		    String questionText = QuestionParser.parseMaterialElement(presentationChild, question,
-			    resourcesFolderPath);
-		    if (questionText.trim().startsWith("<!--")) {
-			// do not support Algorithmic question type
-			continue questionLoop;
-		    }
-		    question.setText(questionText);
-		} else if ("response_lid".equals(presentationChild.getNodeName())) {
-		    if (question.getAnswers() == null) {
-			boolean multipleAnswersAllowed = "multiple"
-				.equalsIgnoreCase(((Element) presentationChild).getAttribute("rcardinality"));
-			NodeList answerList = ((Element) presentationChild).getElementsByTagName("response_label");
-			// parse answers
-			for (int answerIndex = 0; answerIndex < answerList.getLength(); answerIndex++) {
-			    Element answerElement = (Element) answerList.item(answerIndex);
-			    Element materialElement = (Element) answerElement.getElementsByTagName("material").item(0);
-			    String answerText = QuestionParser.parseMaterialElement(materialElement, question,
-				    resourcesFolderPath);
+    public static Question parseQTIItemVesion1(Element questionItem, String resourcesFolderPath,
+	    Set<String> limitType) {
+	NodeList questionItemTypes = questionItem.getElementsByTagName("qmd_itemtype");
+	String questionItemType = questionItemTypes.getLength() > 0
+		? ((Text) questionItemTypes.item(0).getChildNodes().item(0)).getData()
+		: null;
+	Question question = new Question();
+	// check if it is "matching" question type
+	if ("Matching".equalsIgnoreCase(questionItemType)
+		&& !QuestionParser.isQuestionTypeAcceptable(Question.QUESTION_TYPE_MATCHING, limitType, question)) {
+	    return null;
+	}
+	String questionTitle = questionItem.getAttribute("title");
+	question.setTitle(questionTitle);
+	String questionLabel = questionItem.getAttribute("label");
+	if (StringUtils.isNotBlank(questionLabel)) {
+	    question.setLabel(questionLabel);
+	}
 
-			    // if there are answers different thatn true/false,
-			    // it is Multiple Choice or Multiple Answers
-			    if ((question.getType() == null) && !"true".equalsIgnoreCase(answerText)
-				    && !"false".equalsIgnoreCase(answerText)
-				    && !QuestionParser
-					    .isQuestionTypeAcceptable(
-						    multipleAnswersAllowed ? Question.QUESTION_TYPE_MULTIPLE_RESPONSE
-							    : Question.QUESTION_TYPE_MULTIPLE_CHOICE,
-						    limitType, question)) {
-				continue questionLoop;
-			    }
+	Map<String, Answer> answerMap = new TreeMap<>();
+	Map<String, Answer> matchAnswerMap = null;
+	boolean textBasedQuestion = false;
 
-			    Answer answer = new Answer();
-			    answer.setText(answerText);
-			    if (question.getAnswers() == null) {
-				question.setAnswers(new ArrayList<Answer>());
-			    }
-			    question.getAnswers().add(answer);
+	Element presentation = (Element) questionItem.getElementsByTagName("presentation").item(0);
+	NodeList presentationChildrenList = presentation.getChildNodes();
+	// cumberstone parsing, but there is no other way using this API
+	for (int presentationChildIndex = 0; presentationChildIndex < presentationChildrenList
+		.getLength(); presentationChildIndex++) {
+	    Node presentationChild = presentationChildrenList.item(presentationChildIndex);
+	    // here is where question data is stored
+	    if ("material".equals(presentationChild.getNodeName())) {
+		String questionText = QuestionParser.parseMaterialElement(presentationChild, question,
+			resourcesFolderPath);
+		if (questionText.trim().startsWith("<!--")) {
+		    // do not support Algorithmic question type
+		    return null;
+		}
+		question.setText(questionText);
+	    } else if ("response_lid".equals(presentationChild.getNodeName())) {
+		if (question.getAnswers() == null) {
+		    boolean multipleAnswersAllowed = "multiple"
+			    .equalsIgnoreCase(((Element) presentationChild).getAttribute("rcardinality"));
+		    NodeList answerList = ((Element) presentationChild).getElementsByTagName("response_label");
+		    // parse answers
+		    for (int answerIndex = 0; answerIndex < answerList.getLength(); answerIndex++) {
+			Element answerElement = (Element) answerList.item(answerIndex);
+			Element materialElement = (Element) answerElement.getElementsByTagName("material").item(0);
+			String answerText = QuestionParser.parseMaterialElement(materialElement, question,
+				resourcesFolderPath);
 
-			    // for other metadata parts to find Answer object
-			    String answerId = answerElement.getAttribute("ident");
-			    answerMap.put(answerId, answer);
+			// if there are answers different thatn true/false,
+			// it is Multiple Choice or Multiple Answers
+			if ((question.getType() == null) && !"true".equalsIgnoreCase(answerText)
+				&& !"false".equalsIgnoreCase(answerText)
+				&& !QuestionParser
+					.isQuestionTypeAcceptable(
+						multipleAnswersAllowed ? Question.QUESTION_TYPE_MULTIPLE_RESPONSE
+							: Question.QUESTION_TYPE_MULTIPLE_CHOICE,
+						limitType, question)) {
+			    return null;
 			}
 
-			// if there are only true/false answers, set the question type
-			if ((question.getType() == null) && (question.getAnswers() != null)
-				&& (question.getAnswers().size() == 2) && !multipleAnswersAllowed
-				&& !QuestionParser.isQuestionTypeAcceptable(Question.QUESTION_TYPE_TRUE_FALSE,
-					limitType, question)) {
-			    continue questionLoop;
+			Answer answer = new Answer();
+			answer.setText(answerText);
+			if (question.getAnswers() == null) {
+			    question.setAnswers(new ArrayList<Answer>());
 			}
+			question.getAnswers().add(answer);
+
+			// for other metadata parts to find Answer object
+			String answerId = answerElement.getAttribute("ident");
+			answerMap.put(answerId, answer);
 		    }
 
-		    if (Question.QUESTION_TYPE_MATCHING.equals(question.getType())) {
-			if (question.getMatchAnswers() == null) {
-			    // the parsed answers are actually the second part of matching
-			    // move collections accordingly
-			    question.setMatchAnswers(question.getAnswers());
-			    question.setAnswers(new ArrayList<Answer>());
+		    // if there are only true/false answers, set the question type
+		    if ((question.getType() == null) && (question.getAnswers() != null)
+			    && (question.getAnswers().size() == 2) && !multipleAnswersAllowed && !QuestionParser
+				    .isQuestionTypeAcceptable(Question.QUESTION_TYPE_TRUE_FALSE, limitType, question)) {
+			return null;
+		    }
+		}
 
-			    matchAnswerMap = answerMap;
-			    answerMap = new TreeMap<>();
-			}
+		if (Question.QUESTION_TYPE_MATCHING.equals(question.getType())) {
+		    if (question.getMatchAnswers() == null) {
+			// the parsed answers are actually the second part of matching
+			// move collections accordingly
+			question.setMatchAnswers(question.getAnswers());
+			question.setAnswers(new ArrayList<Answer>());
 
-			NodeList responseLidChildrenList = presentationChild.getChildNodes();
-			for (int responseLidChildIndex = 0; responseLidChildIndex < responseLidChildrenList
-				.getLength(); responseLidChildIndex++) {
-			    // parse answers for first part of matching
-			    Node responseLidChild = responseLidChildrenList.item(responseLidChildIndex);
-			    if ("material".equals(responseLidChild.getNodeName())) {
-				String answerText = QuestionParser.parseMaterialElement(responseLidChild, question,
-					resourcesFolderPath);
+			matchAnswerMap = answerMap;
+			answerMap = new TreeMap<>();
+		    }
 
-				Answer answer = new Answer();
-				answer.setText(answerText);
-				question.getAnswers().add(answer);
+		    NodeList responseLidChildrenList = presentationChild.getChildNodes();
+		    for (int responseLidChildIndex = 0; responseLidChildIndex < responseLidChildrenList
+			    .getLength(); responseLidChildIndex++) {
+			// parse answers for first part of matching
+			Node responseLidChild = responseLidChildrenList.item(responseLidChildIndex);
+			if ("material".equals(responseLidChild.getNodeName())) {
+			    String answerText = QuestionParser.parseMaterialElement(responseLidChild, question,
+				    resourcesFolderPath);
 
-				String answerId = ((Element) presentationChild).getAttribute("ident");
-				answerMap.put(answerId, answer);
-			    }
+			    Answer answer = new Answer();
+			    answer.setText(answerText);
+			    question.getAnswers().add(answer);
+
+			    String answerId = ((Element) presentationChild).getAttribute("ident");
+			    answerMap.put(answerId, answer);
 			}
 		    }
-		} else if ("response_str".equals(presentationChild.getNodeName())) {
-		    // Essay or Fill-in-Blank question types
-		    textBasedQuestion = true;
 		}
+	    } else if ("response_str".equals(presentationChild.getNodeName())) {
+		// Essay or Fill-in-Blank question types
+		textBasedQuestion = true;
 	    }
+	}
 
-	    // extract score and feedback
-	    Map<String, String> feedbackMap = new TreeMap<>();
-	    if (textBasedQuestion || !answerMap.isEmpty()) {
-		NodeList answerMetadatas = questionItem.getElementsByTagName("respcondition");
-		// if no answers at all, it is Essay type
-		if ((answerMetadatas.getLength() == 0) && (question.getType() == null) && textBasedQuestion
-			&& !QuestionParser.isQuestionTypeAcceptable(Question.QUESTION_TYPE_ESSAY, limitType,
-				question)) {
-		    continue questionLoop;
-		}
-		for (int answerMetadataIndex = 0; answerMetadataIndex < answerMetadatas
-			.getLength(); answerMetadataIndex++) {
-		    Element answerMetadata = (Element) answerMetadatas.item(answerMetadataIndex);
-		    NodeList scoreReference = answerMetadata.getElementsByTagName("varequal");
-		    // find where given metadata part references to
-		    String answerId = scoreReference.getLength() > 0
-			    ? ((Text) scoreReference.item(0).getChildNodes().item(0)).getData()
-			    : null;
-		    if (answerId == null) {
-			// no answers at all, so it is Essay type
-			if ((question.getType() == null) && textBasedQuestion && !QuestionParser
-				.isQuestionTypeAcceptable(Question.QUESTION_TYPE_ESSAY, limitType, question)) {
-			    continue questionLoop;
-			}
-		    } else {
-			if ((question.getType() == null) && textBasedQuestion && !QuestionParser
-				.isQuestionTypeAcceptable(Question.QUESTION_TYPE_FILL_IN_BLANK, limitType, question)) {
-			    continue questionLoop;
-			}
+	// extract score and feedback
+	Map<String, String> feedbackMap = new TreeMap<>();
+	if (textBasedQuestion || !answerMap.isEmpty()) {
+	    NodeList answerMetadatas = questionItem.getElementsByTagName("respcondition");
+	    // if no answers at all, it is Essay type
+	    if ((answerMetadatas.getLength() == 0) && (question.getType() == null) && textBasedQuestion
+		    && !QuestionParser.isQuestionTypeAcceptable(Question.QUESTION_TYPE_ESSAY, limitType, question)) {
+		return null;
+	    }
+	    for (int answerMetadataIndex = 0; answerMetadataIndex < answerMetadatas
+		    .getLength(); answerMetadataIndex++) {
+		Element answerMetadata = (Element) answerMetadatas.item(answerMetadataIndex);
+		NodeList scoreReference = answerMetadata.getElementsByTagName("varequal");
+		// find where given metadata part references to
+		String answerId = scoreReference.getLength() > 0
+			? ((Text) scoreReference.item(0).getChildNodes().item(0)).getData()
+			: null;
+		if (answerId == null) {
+		    // no answers at all, so it is Essay type
+		    if ((question.getType() == null) && textBasedQuestion && !QuestionParser
+			    .isQuestionTypeAcceptable(Question.QUESTION_TYPE_ESSAY, limitType, question)) {
+			return null;
+		    }
+		} else {
+		    if ((question.getType() == null) && textBasedQuestion && !QuestionParser
+			    .isQuestionTypeAcceptable(Question.QUESTION_TYPE_FILL_IN_BLANK, limitType, question)) {
+			return null;
+		    }
 
-			Answer answer = null;
-			if (textBasedQuestion) {
-			    // for Fill-in-Blank answer parsing can be done only here
-			    answer = new Answer();
-			    answer.setText(answerId);
-			    if (question.getAnswers() == null) {
-				question.setAnswers(new ArrayList<Answer>());
-			    }
-			    question.getAnswers().add(answer);
+		    Answer answer = null;
+		    if (textBasedQuestion) {
+			// for Fill-in-Blank answer parsing can be done only here
+			answer = new Answer();
+			answer.setText(answerId);
+			if (question.getAnswers() == null) {
+			    question.setAnswers(new ArrayList<Answer>());
 			}
-			// extract score
-			Element setVarElement = (Element) answerMetadata.getElementsByTagName("setvar").item(0);
-			String score = ((Text) setVarElement.getChildNodes().item(0)).getData();
-			if (!StringUtils.isBlank(score)) {
-			    if (Question.QUESTION_TYPE_MATCHING.equals(question.getType())) {
-				// map matching answers to each other, plus set the score
-				if (setVarElement.getAttribute("varname").endsWith("_Correct")) {
-				    Answer matchAnswer = matchAnswerMap.get(answerId);
-				    answerId = ((Element) scoreReference.item(0)).getAttribute("respident");
-				    answer = answerMap.get(answerId);
-				    answer.setScore(Float.parseFloat(score));
+			question.getAnswers().add(answer);
+		    }
+		    // extract score
+		    Element setVarElement = (Element) answerMetadata.getElementsByTagName("setvar").item(0);
+		    String score = ((Text) setVarElement.getChildNodes().item(0)).getData();
+		    if (!StringUtils.isBlank(score)) {
+			if (Question.QUESTION_TYPE_MATCHING.equals(question.getType())) {
+			    // map matching answers to each other, plus set the score
+			    if (setVarElement.getAttribute("varname").endsWith("_Correct")) {
+				Answer matchAnswer = matchAnswerMap.get(answerId);
+				answerId = ((Element) scoreReference.item(0)).getAttribute("respident");
+				answer = answerMap.get(answerId);
+				answer.setScore(Float.parseFloat(score));
 
-				    if (question.getMatchMap() == null) {
-					question.setMatchMap(new TreeMap<Integer, Integer>());
-				    }
-				    Integer answerIndex = question.getAnswers().indexOf(answer);
-				    Integer matchAnswerIndex = question.getMatchAnswers().indexOf(matchAnswer);
-				    question.getMatchMap().put(answerIndex, matchAnswerIndex);
+				if (question.getMatchMap() == null) {
+				    question.setMatchMap(new TreeMap<Integer, Integer>());
 				}
-			    } else {
-				if (answer == null) {
-				    // for all types except Matching and Fill-in-Blank
-				    answer = answerMap.get(answerId);
-				}
-				answer.setScore(Float.parseFloat(score));
+				Integer answerIndex = question.getAnswers().indexOf(answer);
+				Integer matchAnswerIndex = question.getMatchAnswers().indexOf(matchAnswer);
+				question.getMatchMap().put(answerIndex, matchAnswerIndex);
 			    }
+			} else {
+			    if (answer == null) {
+				// for all types except Matching and Fill-in-Blank
+				answer = answerMap.get(answerId);
+			    }
+			    answer.setScore(Float.parseFloat(score));
 			}
+		    }
 
-			// extract question and answer feedback references
-			NodeList feedbacks = answerMetadata.getElementsByTagName("displayfeedback");
-			for (int feedbackIndex = 0; feedbackIndex < feedbacks.getLength(); feedbackIndex++) {
-			    Element feedbackElement = (Element) feedbacks.item(feedbackIndex);
-			    String feedbackId = feedbackElement.getAttribute("linkrefid");
-			    // check if it is not a question feedback
-			    if (!feedbackId.endsWith("_ALL")) {
-				feedbackMap.put(feedbackId, answerId);
-			    }
+		    // extract question and answer feedback references
+		    NodeList feedbacks = answerMetadata.getElementsByTagName("displayfeedback");
+		    for (int feedbackIndex = 0; feedbackIndex < feedbacks.getLength(); feedbackIndex++) {
+			Element feedbackElement = (Element) feedbacks.item(feedbackIndex);
+			String feedbackId = feedbackElement.getAttribute("linkrefid");
+			// check if it is not a question feedback
+			if (!feedbackId.endsWith("_ALL")) {
+			    feedbackMap.put(feedbackId, answerId);
 			}
 		    }
 		}
 	    }
+	}
 
-	    // extract question and answer feedbacks
-	    NodeList feedbacks = questionItem.getElementsByTagName("itemfeedback");
-	    for (int feedbackIndex = 0; feedbackIndex < feedbacks.getLength(); feedbackIndex++) {
-		Element feedbackElement = (Element) feedbacks.item(feedbackIndex);
-		Node materialElement = feedbackElement.getElementsByTagName("material").item(0);
-		String feedbackText = QuestionParser.parseMaterialElement(materialElement, question,
-			resourcesFolderPath);
-		if (!StringUtils.isBlank(feedbackText)) {
-		    String feedbackType = feedbackElement.getAttribute("view");
-		    // it is a question feedback
-		    if ("All".equalsIgnoreCase(feedbackType)) {
-			question.setFeedback(feedbackText);
-		    } else {
-			// it is an answer feedback
-			String feedbackId = feedbackElement.getAttribute("ident");
-			String answerId = feedbackMap.get(feedbackId);
-			if (answerId != null) {
-			    Answer answer = answerMap.get(answerId);
-			    if (answer != null) {
-				answer.setFeedback(feedbackText);
-			    }
+	// extract question and answer feedbacks
+	NodeList feedbacks = questionItem.getElementsByTagName("itemfeedback");
+	for (int feedbackIndex = 0; feedbackIndex < feedbacks.getLength(); feedbackIndex++) {
+	    Element feedbackElement = (Element) feedbacks.item(feedbackIndex);
+	    Node materialElement = feedbackElement.getElementsByTagName("material").item(0);
+	    String feedbackText = QuestionParser.parseMaterialElement(materialElement, question, resourcesFolderPath);
+	    if (!StringUtils.isBlank(feedbackText)) {
+		String feedbackType = feedbackElement.getAttribute("view");
+		// it is a question feedback
+		if ("All".equalsIgnoreCase(feedbackType)) {
+		    question.setFeedback(feedbackText);
+		} else {
+		    // it is an answer feedback
+		    String feedbackId = feedbackElement.getAttribute("ident");
+		    String answerId = feedbackMap.get(feedbackId);
+		    if (answerId != null) {
+			Answer answer = answerMap.get(answerId);
+			if (answer != null) {
+			    answer.setFeedback(feedbackText);
 			}
 		    }
 		}
 	    }
-
-	    result.add(question);
 	}
 
-	return result.toArray(Question.QUESTION_ARRAY_TYPE);
+	return question;
     }
 
     /**
@@ -492,6 +505,285 @@
 	return result.toArray(Question.QUESTION_ARRAY_TYPE);
     }
 
+    public static Question parseQTIItemVesion2(Element questionItem, String resourcesFolderPath,
+	    Set<String> limitType) {
+	String questionType = null;
+
+	Element responseDeclarationElement = XMLUtil.findChild(questionItem, "responseDeclaration");
+	Element itemBodyElement = XMLUtil.findChild(questionItem, "itemBody");
+	if (itemBodyElement == null) {
+	    // pretty much every item needs a body
+	    return null;
+	}
+
+	// existence of these elements depends on question type
+	Element choiceInteractionElement = null;
+	List<Element> simpleChoiceElements = null;
+	Element matchInteractionElement = null;
+	Element gapMatchInteractionElement = null;
+	Element textEntryInteractionElement = null;
+	Element extendedTextInteractionElement = null;
+
+	try {
+	    choiceInteractionElement = (Element) xPath.compile(".//choiceInteraction").evaluate(itemBodyElement,
+		    XPathConstants.NODE);
+	    simpleChoiceElements = XMLUtil.findChildren(choiceInteractionElement, "simpleChoice");
+	    matchInteractionElement = (Element) xPath.compile(".//matchInteraction").evaluate(itemBodyElement,
+		    XPathConstants.NODE);
+	    gapMatchInteractionElement = (Element) xPath.compile(".//gapMatchInteraction").evaluate(itemBodyElement,
+		    XPathConstants.NODE);
+	    textEntryInteractionElement = (Element) xPath.compile(".//textEntryInteraction").evaluate(itemBodyElement,
+		    XPathConstants.NODE);
+	    extendedTextInteractionElement = (Element) xPath.compile(".//extendedTextInteraction")
+		    .evaluate(itemBodyElement, XPathConstants.NODE);
+	} catch (Exception e) {
+	    log.error("Error while searching for interaction elements in item body in QTI XML file", e);
+	}
+
+	// try to figure out question type
+	if (responseDeclarationElement != null) {
+	    String cardinality = responseDeclarationElement.getAttribute("cardinality");
+	    String baseType = responseDeclarationElement.getAttribute("baseType");
+	    if ("single".equals(cardinality)) {
+		switch (baseType) {
+		    case "identifier":
+			if (choiceInteractionElement == null) {
+			    return null;
+			}
+
+			// pretty naive detection - what if true/false are in another language or yes/no
+			if (simpleChoiceElements != null && simpleChoiceElements.size() == 2
+				&& simpleChoiceElements.stream().map(e -> e.getTextContent())
+					.allMatch(t -> t.equalsIgnoreCase("true") || t.equalsIgnoreCase("false"))) {
+			    questionType = Question.QUESTION_TYPE_TRUE_FALSE;
+			} else {
+			    questionType = Question.QUESTION_TYPE_MULTIPLE_CHOICE;
+			}
+			break;
+		    case "string":
+			if (extendedTextInteractionElement == null) {
+			    if (textEntryInteractionElement == null) {
+				return null;
+			    }
+			    questionType = Question.QUESTION_TYPE_FILL_IN_BLANK;
+			} else {
+			    questionType = Question.QUESTION_TYPE_ESSAY;
+			}
+
+			break;
+		}
+	    } else if ("multiple".equals(cardinality)) {
+		switch (baseType) {
+		    case "identifier":
+			if (choiceInteractionElement == null) {
+			    return null;
+			}
+			questionType = Question.QUESTION_TYPE_MULTIPLE_RESPONSE;
+			break;
+		    case "directedPair":
+			if (matchInteractionElement == null) {
+			    return null;
+			}
+			questionType = Question.QUESTION_TYPE_MATCHING;
+			break;
+		}
+	    }
+	}
+
+	// check if question type is acceptable
+	Question question = new Question();
+	if (!QuestionParser.isQuestionTypeAcceptable(questionType, limitType, question)) {
+	    return null;
+	}
+	String questionTitle = questionItem.getAttribute("title");
+	question.setTitle(questionTitle);
+
+	// further processing of answers and score
+	switch (questionType) {
+	    case Question.QUESTION_TYPE_MULTIPLE_CHOICE:
+	    case Question.QUESTION_TYPE_MULTIPLE_RESPONSE:
+	    case Question.QUESTION_TYPE_TRUE_FALSE: {
+		Element correctResponseElement = XMLUtil.findChild(responseDeclarationElement, "correctResponse");
+		List<Element> correctResponseValueElements = XMLUtil.findChildren(correctResponseElement, "value");
+		Map<String, Float> correctResponses = new HashMap<>();
+
+		// figure out default score for answers
+		float defaultScore = 1F;
+		Element scoreMappingElement = XMLUtil.findChild(responseDeclarationElement, "mapping");
+		if (scoreMappingElement != null) {
+		    String defaultScoreAttribute = scoreMappingElement.getAttribute("defaultValue");
+		    if (StringUtils.isNotBlank(defaultScoreAttribute)) {
+			defaultScore = Float.valueOf(defaultScoreAttribute);
+		    }
+		}
+
+		// check which answers are correct
+		for (Element correctResponseValue : correctResponseValueElements) {
+		    correctResponses.put(correctResponseValue.getTextContent(), defaultScore);
+		}
+
+		// each answer can have own score
+		if (scoreMappingElement != null) {
+		    List<Element> scoreMappingEntryElements = XMLUtil.findChildren(scoreMappingElement, "mapEntry");
+		    for (Element scoreMappingEntry : scoreMappingEntryElements) {
+			String correctAnswerEntry = scoreMappingEntry.getAttribute("mapKey");
+			if (StringUtils.isBlank(correctAnswerEntry)
+				|| !correctResponses.containsKey(correctAnswerEntry)) {
+			    continue;
+			}
+			String mappedValue = scoreMappingEntry.getAttribute("mappedValue");
+			if (StringUtils.isNotBlank(mappedValue)) {
+			    correctResponses.put(correctAnswerEntry, Float.valueOf(mappedValue));
+			}
+		    }
+		}
+
+		List<Answer> answers = new ArrayList<>();
+		for (Element simpleChoiceElement : simpleChoiceElements) {
+		    Answer answer = new Answer();
+		    answer.setText(simpleChoiceElement.getTextContent());
+		    String identifier = simpleChoiceElement.getAttribute("identifier");
+		    // either set exact score or the default one
+		    Float score = correctResponses.get(identifier);
+		    answer.setScore(score == null ? defaultScore : score);
+		    String feedback = XMLUtil.getChildElementValue(simpleChoiceElement, "feebackInline", null);
+		    answer.setFeedback(feedback);
+		    answers.add(answer);
+		}
+		question.setAnswers(answers);
+		question.setScore(1);
+	    }
+		break;
+	    case Question.QUESTION_TYPE_MATCHING: {
+		Element correctResponseElement = XMLUtil.findChild(responseDeclarationElement, "correctResponse");
+		List<Element> correctResponseValueElements = XMLUtil.findChildren(correctResponseElement, "value");
+		Map<String, Float> correctResponses = new HashMap<>();
+		// figure out default score for answers
+		float defaultScore = 0F;
+		Element scoreMappingElement = XMLUtil.findChild(responseDeclarationElement, "mapping");
+		if (scoreMappingElement != null) {
+		    String defaultScoreAttribute = scoreMappingElement.getAttribute("defaultValue");
+		    if (StringUtils.isNotBlank(defaultScoreAttribute)) {
+			defaultScore = Float.valueOf(defaultScoreAttribute);
+		    }
+		}
+
+		// check which answers are correct
+		for (Element correctResponseValue : correctResponseValueElements) {
+		    correctResponses.put(correctResponseValue.getTextContent(), defaultScore);
+		}
+		// each answer can have own score
+		if (scoreMappingElement != null) {
+		    List<Element> scoreMappingEntryElements = XMLUtil.findChildren(scoreMappingElement, "mapEntry");
+		    for (Element scoreMappingEntry : scoreMappingEntryElements) {
+			String correctAnswerEntry = scoreMappingEntry.getAttribute("mapKey");
+			if (StringUtils.isBlank(correctAnswerEntry)
+				|| !correctResponses.containsKey(correctAnswerEntry)) {
+			    continue;
+			}
+			String mappedValue = scoreMappingEntry.getAttribute("mappedValue");
+			if (StringUtils.isNotBlank(mappedValue)) {
+			    correctResponses.put(correctAnswerEntry, Float.valueOf(mappedValue));
+			}
+		    }
+		}
+
+		// there should be exactly two sets of answers in XML doc
+		List<Answer> answers = new ArrayList<>();
+		List<Answer> matchAnswers = new ArrayList<>();
+		Map<String, Integer> answerMap = new HashMap<>();
+		List<Element> matchSetElements = XMLUtil.findChildren(matchInteractionElement, "simpleMatchSet");
+
+		List<Element> answerElements = XMLUtil.findChildren(matchSetElements.get(0), "simpleAssociableChoice");
+		int answerIndex = 0;
+		for (Element answerElement : answerElements) {
+		    Answer answer = new Answer();
+		    answer.setText(answerElement.getTextContent());
+		    String identifier = answerElement.getAttribute("identifier");
+		    answerMap.put(identifier, answerIndex);
+		    answers.add(answer);
+		    answerIndex++;
+		}
+		question.setAnswers(answers);
+
+		List<Element> matchAnswersElements = XMLUtil.findChildren(matchSetElements.get(1),
+			"simpleAssociableChoice");
+		answerIndex = 0;
+		for (Element matchAnswerElement : matchAnswersElements) {
+		    Answer answer = new Answer();
+		    answer.setText(matchAnswerElement.getTextContent());
+		    String identifier = matchAnswerElement.getAttribute("identifier");
+		    answerMap.put(identifier, answerIndex);
+		    matchAnswers.add(answer);
+		    answerIndex++;
+		}
+		question.setMatchAnswers(matchAnswers);
+
+		Map<Integer, Integer> matchMap = new HashMap<>();
+		for (Element correctResponseValue : correctResponseValueElements) {
+		    String correctResponse = correctResponseValue.getTextContent();
+		    // either set exact score or the default one
+		    Float score = correctResponses.get(correctResponse);
+		    String[] correctResponseParts = correctResponse.split(" ");
+		    answerIndex = answerMap.get(correctResponseParts[0]);
+		    answers.get(answerIndex).setScore(score == null ? defaultScore : score);
+		    int matchAnswerIndex = answerMap.get(correctResponseParts[1]);
+		    matchMap.put(answerIndex, matchAnswerIndex);
+		}
+		question.setMatchMap(matchMap);
+	    }
+		break;
+	    case Question.QUESTION_TYPE_FILL_IN_BLANK: {
+		Element scoreMappingElement = XMLUtil.findChild(responseDeclarationElement, "mapping");
+		List<Element> scoreMappingEntryElements = XMLUtil.findChildren(scoreMappingElement, "mapEntry");
+		String defaultScoreAttribute = scoreMappingElement.getAttribute("defaultValue");
+		Float defaultScore = 0F;
+		if (StringUtils.isNotBlank(defaultScoreAttribute)) {
+		    defaultScore = Float.valueOf(defaultScoreAttribute);
+		}
+		Map<Float, Answer> scoreMapping = new TreeMap<>();
+		for (Element scoreMappingEntry : scoreMappingEntryElements) {
+		    String correctAnswerEntry = scoreMappingEntry.getAttribute("mapKey");
+		    if (StringUtils.isBlank(correctAnswerEntry)) {
+			continue;
+		    }
+		    String mappedValue = scoreMappingEntry.getAttribute("mappedValue");
+		    Float score = StringUtils.isBlank(mappedValue) ? defaultScore : Float.valueOf(mappedValue);
+		    Answer answer = scoreMapping.get(score);
+		    if (answer == null) {
+			answer = new Answer();
+			answer.setText("");
+			answer.setScore(score);
+			scoreMapping.put(score, answer);
+		    }
+
+		    answer.setText(answer.getText() + correctAnswerEntry.strip() + QbUtils.VSA_ANSWER_DELIMITER);
+		}
+
+		question.setAnswers(List.copyOf(scoreMapping.values()));
+	    }
+		break;
+	}
+
+	// remove answer elements from body
+	Element[] elementsToRemove = new Element[] { choiceInteractionElement, matchInteractionElement,
+		gapMatchInteractionElement, textEntryInteractionElement, extendedTextInteractionElement };
+	for (Element elementToRemove : elementsToRemove) {
+	    if (elementToRemove != null) {
+		elementToRemove.getParentNode().removeChild(elementToRemove);
+	    }
+	}
+	boolean imagesReplaced = QuestionParser.replaceImages(itemBodyElement);
+	if (imagesReplaced) {
+	    question.setResourcesFolderPath(resourcesFolderPath);
+	}
+	// it rips off HTML tags
+	String description = itemBodyElement.getTextContent().trim();
+	question.setText(description);
+
+	return question;
+    }
+
     /**
      * Adapts QTI form field for Tools to use. Some Tools do not accept HTML, so it gets converted to plain text. Also
      * image placeholders get resolved here.
@@ -673,4 +965,57 @@
 
 	return result.toString();
     }
+
+    private static boolean replaceImages(Element element) {
+	if (element == null) {
+	    return false;
+	}
+	NodeList imageNodes = null;
+	try {
+	    imageNodes = (NodeList) xPath.compile(".//img|.//object[@data]").evaluate(element, XPathConstants.NODESET);
+	} catch (Exception e) {
+	    log.error("Error while replacing images for QTI", e);
+	    return false;
+	}
+
+	boolean imageReplaced = false;
+
+	for (int nodeIndex = 0; nodeIndex < imageNodes.getLength(); nodeIndex++) {
+	    Element imageElement = (Element) imageNodes.item(nodeIndex);
+	    String fileName = imageElement.getAttribute("src");
+	    if (StringUtils.isBlank(fileName)) {
+		String objectType = imageElement.getAttribute("type");
+		if (objectType != null && objectType.startsWith("image")) {
+		    fileName = imageElement.getAttribute("data");
+		}
+	    }
+	    if (StringUtils.isBlank(fileName)) {
+		continue;
+	    }
+	    String width = imageElement.getAttribute("width");
+	    String height = imageElement.getAttribute("height");
+	    String classAttr = imageElement.getAttribute("class");
+
+	    StringBuilder imageText = new StringBuilder();
+	    imageText.append("[IMAGE: ").append(fileName);
+	    if (StringUtils.isNotBlank(width)) {
+		imageText.append("| width=\"" + width + "\"");
+	    }
+	    if (StringUtils.isNotBlank(height)) {
+		imageText.append("| height=\"" + height + "\"");
+	    }
+	    if (StringUtils.isNotBlank(classAttr)) {
+		imageText.append("| class=\"" + classAttr + "\"");
+	    }
+	    imageText.append("]");
+
+	    Node imageTextNode = element.getOwnerDocument().createTextNode(imageText.toString());
+
+	    imageElement.getParentNode().replaceChild(imageTextNode, imageElement);
+
+	    imageReplaced = true;
+	}
+
+	return imageReplaced;
+    }
 }
\ No newline at end of file
Index: lams_common/src/java/org/lamsfoundation/lams/questions/QuestionWordParser.java
===================================================================
diff -u -r970744e51617c0614313597e042767b43f5a7326 -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_common/src/java/org/lamsfoundation/lams/questions/QuestionWordParser.java	(.../QuestionWordParser.java)	(revision 970744e51617c0614313597e042767b43f5a7326)
+++ lams_common/src/java/org/lamsfoundation/lams/questions/QuestionWordParser.java	(.../QuestionWordParser.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -6,6 +6,7 @@
 import java.io.InputStream;
 import java.io.StringReader;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -74,9 +75,9 @@
     /**
      * Extracts questions from IMS QTI zip file.
      */
-    public static Question[] parseWordFile(InputStream uploadedFileStream, String fileName, Set<String> limitType)
-	    throws XPathExpressionException, ZipFileUtilException, TransformerConfigurationException, IOException,
-	    SAXException, TikaException, ParserConfigurationException {
+    public static Collection<Question> parseWordFile(InputStream uploadedFileStream, String fileName,
+	    Set<String> limitType) throws XPathExpressionException, ZipFileUtilException,
+	    TransformerConfigurationException, IOException, SAXException, TikaException, ParserConfigurationException {
 	final String TEMP_IMAGE_FOLDER = ZipFileUtil.prepareTempDirectory(fileName);
 	TikaInputStream input = TikaInputStream.get(uploadedFileStream);
 	OOXMLParser tikaParser = new OOXMLParser();
@@ -381,7 +382,7 @@
 	    questions.add(question);
 	}
 
-	return questions.toArray(Question.QUESTION_ARRAY_TYPE);
+	return questions;
     }
 
     private static String readNextLine(LSSerializer serializer, NodeList nodes, int counter) {
Index: lams_common/src/java/org/lamsfoundation/lams/util/XMLUtil.java
===================================================================
diff -u -rb765f567ba3ca9ca048b434d243d94d865ef363c -rd5eba3675f4c182807df0fcb34727ce506206098
--- lams_common/src/java/org/lamsfoundation/lams/util/XMLUtil.java	(.../XMLUtil.java)	(revision b765f567ba3ca9ca048b434d243d94d865ef363c)
+++ lams_common/src/java/org/lamsfoundation/lams/util/XMLUtil.java	(.../XMLUtil.java)	(revision d5eba3675f4c182807df0fcb34727ce506206098)
@@ -21,18 +21,8 @@
      * Otherwise returns defaultValue.
      */
     public static String getChildElementValue(Element parentElement, String childElementName, String defaultValue) {
-	if (parentElement == null || childElementName == null) {
-	    return defaultValue;
-	}
-	List<Element> foundElements = XMLUtil.findChildren(parentElement, childElementName);
-	if (foundElements.size() == 0) {
-	    return defaultValue;
-	}
-	if (foundElements.size() == 1) {
-	    return foundElements.get(0).getTextContent();
-	}
-	throw new InvalidParameterException(
-		"There is more than one element with name \"" + childElementName + "\" in its parent");
+	Element childElement = XMLUtil.findChild(parentElement, childElementName);
+	return childElement == null ? defaultValue : childElement.getTextContent();
     }
 
     /**
@@ -145,4 +135,22 @@
 	}
 	return result;
     }
+
+    /**
+     * Finds immediate child of a given element with given name.
+     */
+    public static Element findChild(Element parentElement, String childElementName) {
+	if (parentElement == null || childElementName == null) {
+	    return null;
+	}
+	List<Element> foundElements = XMLUtil.findChildren(parentElement, childElementName);
+	if (foundElements.size() == 0) {
+	    return null;
+	}
+	if (foundElements.size() == 1) {
+	    return foundElements.get(0);
+	}
+	throw new InvalidParameterException(
+		"There is more than one element with name \"" + childElementName + "\" in its parent");
+    }
 }
\ No newline at end of file