Merge pull request #429 from maheshgudi/shuffle_testcases

Shuffle testcases

10 files changed, 267 insertions, 59 deletions

diff --git a/yaksh/evaluator_tests/test_simple_question_types.py b/yaksh/evaluator_tests/test_simple_question_types.py
index b86a9d8..cbf2abd 100644
--- a/yaksh/evaluator_tests/test_simple_question_types.py
+++ b/yaksh/evaluator_tests/test_simple_question_types.py
@@ -4,49 +4,56 @@ from django.utils import timezone
 import pytz
 from yaksh.models import User, Profile, Question, Quiz, QuestionPaper,\
     QuestionSet, AnswerPaper, Answer, Course, IntegerTestCase, FloatTestCase,\
-    StringTestCase
+    StringTestCase, McqTestCase
 
 
 def setUpModule():
-    # create user profile
+    # Create user profile
+    # Create User 1
     user = User.objects.create_user(username='demo_user_100',
                                     password='demo',
                                     email='demo@test.com')
+
     Profile.objects.create(user=user, roll_number=1,
                            institute='IIT', department='Aerospace',
                            position='Student')
+    # Create User 2
+    user2 = User.objects.create_user(username='demo_user_101',
+                                    password='demo',
+                                    email='demo@test.com')
 
-    # create a course
+    Profile.objects.create(user=user2, roll_number=2,
+                           institute='IIT', department='Aerospace',
+                           position='Student')
+    
+    # Create a course
     course = Course.objects.create(name="Python Course 100",
                                    enrollment="Enroll Request", creator=user)
 
-    quiz = Quiz.objects.create(start_date_time=datetime(2015, 10, 9, 10, 8, 15, 0,
-                                                        tzinfo=pytz.utc),
-                               end_date_time=datetime(2199, 10, 9, 10, 8, 15, 0,
-                                                      tzinfo=pytz.utc),
+    quiz = Quiz.objects.create(start_date_time=datetime\
+                                               (2015, 10, 9, 10, 8, 15, 0,
+                                                tzinfo=pytz.utc),
+                               end_date_time=datetime\
+                                              (2199, 10, 9, 10, 8, 15, 0,
+                                                tzinfo=pytz.utc),
                                duration=30, active=True, attempts_allowed=1,
-                               time_between_attempts=0, description='demo quiz 100',
-                               pass_criteria=0,
+                               time_between_attempts=0, pass_criteria=0,
+                               description='demo quiz 100',
                                instructions="Demo Instructions"
                                )
     question_paper = QuestionPaper.objects.create(quiz=quiz,
                                                   total_marks=1.0)
 
-    answerpaper = AnswerPaper.objects.create(user=user, user_ip='101.0.0.1',
-                                             start_time=timezone.now(), 
-                                             question_paper=question_paper,
-                                             end_time=timezone.now()
-                                              +timedelta(minutes=5),
-                                             attempt_number=1,
-                                             course=course
-                                             )
-
+    
 def tearDownModule():
   User.objects.get(username="demo_user_100").delete()
+  User.objects.get(username="demo_user_101").delete()
 
 class IntegerQuestionTestCases(unittest.TestCase):
     @classmethod
     def setUpClass(self):
+        # Creating Course
+        self.course = Course.objects.get(name="Python Course 100")
         # Creating Quiz
         self.quiz = Quiz.objects.get(description="demo quiz 100")
         # Creating Question paper
@@ -65,9 +72,16 @@ class IntegerQuestionTestCases(unittest.TestCase):
         self.question1.save()
 
         #Creating answerpaper
-        self.answerpaper = AnswerPaper.objects.get(question_paper\
-                                                   =self.question_paper)
-        self.answerpaper.attempt_number = 1
+
+        self.answerpaper = AnswerPaper.objects.create(user=self.user,
+                                            user_ip='101.0.0.1',
+                                            start_time=timezone.now(), 
+                                            question_paper=self.question_paper,
+                                            end_time=timezone.now()
+                                                     +timedelta(minutes=5),
+                                            attempt_number=1,
+                                            course=self.course
+                                             )
         self.answerpaper.questions.add(self.question1)
         self.answerpaper.save()
         # For question 
@@ -80,6 +94,7 @@ class IntegerQuestionTestCases(unittest.TestCase):
     @classmethod
     def tearDownClass(self):
       self.question1.delete()
+      self.answerpaper.delete()
 
     def test_validate_regrade_integer_correct_answer(self):
         # Given
@@ -158,6 +173,8 @@ class IntegerQuestionTestCases(unittest.TestCase):
 class StringQuestionTestCases(unittest.TestCase):
     @classmethod
     def setUpClass(self):
+        # Creating Course
+        self.course = Course.objects.get(name="Python Course 100")
         # Creating Quiz
         self.quiz = Quiz.objects.get(description="demo quiz 100")
         # Creating Question paper
@@ -182,9 +199,16 @@ class StringQuestionTestCases(unittest.TestCase):
         self.question2.save()
 
         #Creating answerpaper
-        self.answerpaper = AnswerPaper.objects.get(question_paper\
-                                                   =self.question_paper)
-        self.answerpaper.attempt_number = 1
+        
+        self.answerpaper = AnswerPaper.objects.create(user=self.user,
+                                            user_ip='101.0.0.1',
+                                            start_time=timezone.now(), 
+                                            question_paper=self.question_paper,
+                                            end_time=timezone.now()
+                                                     +timedelta(minutes=5),
+                                            attempt_number=1,
+                                            course=self.course
+                                             )
         self.answerpaper.questions.add(*[self.question1, self.question2])
         self.answerpaper.save()
 
@@ -207,6 +231,7 @@ class StringQuestionTestCases(unittest.TestCase):
     def tearDownClass(self):
       self.question1.delete()
       self.question2.delete()
+      self.answerpaper.delete()
 
     def test_validate_regrade_case_insensitive_string_correct_answer(self):
         # Given
@@ -346,6 +371,8 @@ class StringQuestionTestCases(unittest.TestCase):
 class FloatQuestionTestCases(unittest.TestCase):
     @classmethod
     def setUpClass(self):
+        # Creating Course
+        self.course = Course.objects.get(name="Python Course 100")
         # Creating Quiz
         self.quiz = Quiz.objects.get(description="demo quiz 100")
         # Creating Question paper
@@ -362,9 +389,16 @@ class FloatQuestionTestCases(unittest.TestCase):
         self.question1.save()
 
         #Creating answerpaper
-        self.answerpaper = AnswerPaper.objects.get(question_paper\
-                                                   =self.question_paper)
-        self.answerpaper.attempt_number = 1
+        
+        self.answerpaper = AnswerPaper.objects.create(user=self.user,
+                                            user_ip='101.0.0.1',
+                                            start_time=timezone.now(), 
+                                            question_paper=self.question_paper,
+                                            end_time=timezone.now()
+                                                     +timedelta(minutes=5),
+                                            attempt_number=1,
+                                            course=self.course
+                                             )
         self.answerpaper.questions.add(self.question1)
         self.answerpaper.save()
         # For question 
@@ -378,6 +412,7 @@ class FloatQuestionTestCases(unittest.TestCase):
     @classmethod
     def tearDownClass(self):
       self.question1.delete()
+      self.answerpaper.delete()
 
     def test_validate_regrade_float_correct_answer(self):
         # Given
@@ -450,3 +485,105 @@ class FloatQuestionTestCases(unittest.TestCase):
         self.assertTrue(details[0])
         self.assertEqual(self.answer.marks, 1)
         self.assertTrue(self.answer.correct)
+class MCQQuestionTestCases(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        #Creating User
+        self.user = User.objects.get(username='demo_user_100')
+        self.user2 = User.objects.get(username='demo_user_101')
+        self.user_ip = '127.0.0.1'
+
+        #Creating Course
+        self.course = Course.objects.get(name="Python Course 100")
+        # Creating Quiz
+        self.quiz = Quiz.objects.get(description="demo quiz 100")
+        # Creating Question paper
+        self.question_paper = QuestionPaper.objects.get(quiz=self.quiz)
+        self.question_paper.shuffle_testcases = True
+        self.question_paper.save()
+        #Creating Question
+        self.question1 = Question.objects.create(summary='mcq1', points=1,
+                                                 type='code', user=self.user,
+                                                 )
+        self.question1.language = 'python'
+        self.question1.type = "mcq"
+        self.question1.test_case_type = 'Mcqtestcase'
+        self.question1.description = 'Which option is Correct?'
+        self.question1.save()
+
+        # For questions
+        self.mcq_based_testcase_1 = McqTestCase(question=self.question1,
+                                                options="Correct",
+                                                correct=True,
+                                                type='mcqtestcase',
+                                                )
+        self.mcq_based_testcase_1.save()
+
+        self.mcq_based_testcase_2 = McqTestCase(question=self.question1,
+                                                options="Incorrect",
+                                                correct=False,
+                                                type='mcqtestcase',
+                                                )
+        self.mcq_based_testcase_2.save()
+
+        self.mcq_based_testcase_3 = McqTestCase(question=self.question1,
+                                                options="Incorrect",
+                                                correct=False,
+                                                type='mcqtestcase',
+                                                )
+        self.mcq_based_testcase_3.save()
+
+        self.mcq_based_testcase_4 = McqTestCase(question=self.question1,
+                                                options="Incorrect",
+                                                correct=False,
+                                                type='mcqtestcase',
+                                                )
+        self.mcq_based_testcase_4.save()
+
+        self.question_paper.fixed_questions.add(self.question1)
+
+        self.answerpaper = self.question_paper.make_answerpaper(
+                                           user=self.user, ip=self.user_ip,
+                                           attempt_num=1,
+                                           course_id=self.course.id
+                                           )
+
+        # Answerpaper for user 2
+        self.answerpaper2 = self.question_paper.make_answerpaper(
+                                            user=self.user2, ip=self.user_ip,
+                                            attempt_num=1,
+                                            course_id=self.course.id
+                                            )
+    @classmethod
+    def tearDownClass(self):
+      self.question1.delete()
+      self.answerpaper.delete()
+      self.answerpaper2.delete()
+
+    def test_shuffle_test_cases(self):
+        # Given
+        # When
+
+        user_testcase = self.question1.get_ordered_test_cases(
+                                        self.answerpaper
+                                        )
+        order1 = [tc.id for tc in user_testcase]
+        user2_testcase = self.question1.get_ordered_test_cases(
+                                        self.answerpaper2
+                                        )
+        order2 = [tc.id for tc in user2_testcase]
+        self.question_paper.shuffle_testcases = False
+        self.question_paper.save()
+        answerpaper3 = self.question_paper.make_answerpaper(
+                              user=self.user2, ip=self.user_ip,
+                              attempt_num=self.answerpaper.attempt_number+1,
+                              course_id=self.course.id
+                              )
+        not_ordered_testcase = self.question1.get_ordered_test_cases(
+                                              answerpaper3
+                                              )
+        get_test_cases = self.question1.get_test_cases()
+        # Then
+        self.assertNotEqual(order1, order2)
+        self.assertEqual(get_test_cases, not_ordered_testcase)
+        answerpaper3.delete()
diff --git a/yaksh/forms.py b/yaksh/forms.py
index 258a1ee..e53eda3 100644
--- a/yaksh/forms.py
+++ b/yaksh/forms.py
@@ -308,7 +308,7 @@ class UploadFileForm(forms.Form):
 class QuestionPaperForm(forms.ModelForm):
     class Meta:
         model = QuestionPaper
-        fields = ['shuffle_questions']
+        fields = ['shuffle_questions', 'shuffle_testcases']
 
 
 class LessonForm(forms.ModelForm):
diff --git a/yaksh/models.py b/yaksh/models.py
index f065190..ecc0fc4 100644
--- a/yaksh/models.py
+++ b/yaksh/models.py
@@ -815,8 +815,10 @@ class Question(models.Model):
 
     min_time =  models.IntegerField("time in minutes", default=0)
 
+    #Solution for the question.
     solution = models.TextField(blank=True)
 
+
     def consolidate_answer_data(self, user_answer, user=None):
         question_data = {}
         metadata = {}
@@ -928,6 +930,17 @@ class Question(models.Model):
 
         return test_case
 
+    def get_ordered_test_cases(self, answerpaper):
+        try:
+            order = TestCaseOrder.objects.get(answer_paper=answerpaper,
+                                              question = self
+                                              ).order.split(",")
+            return [self.get_test_case(id=int(tc_id))
+                    for tc_id in order
+                    ]
+        except TestCaseOrder.DoesNotExist:
+            return self.get_test_cases()
+
     def get_maximum_test_case_weight(self, **kwargs):
         max_weight = 0.0
         for test_case in self.get_test_cases():
@@ -1134,6 +1147,11 @@ class QuestionPaper(models.Model):
     # Sequence or Order of fixed questions
     fixed_question_order = models.CharField(max_length=255, blank=True)
 
+    # Shuffle testcase order.
+    shuffle_testcases = models.BooleanField("Shuffle testcase for each user",
+                                             default=True
+                                            )
+
     objects = QuestionPaperManager()
 
     def get_question_bank(self):
@@ -1197,7 +1215,20 @@ class QuestionPaper(models.Model):
             ans_paper.save()
             questions = self._get_questions_for_answerpaper()
             ans_paper.questions.add(*questions)
-            question_ids = [str(que.id) for que in questions]
+            question_ids = []
+            for question in questions:
+                question_ids.append(str(question.id))
+                if self.shuffle_testcases and \
+                    question.type in ["mcq", "mcc"]:
+                    testcases = question.get_test_cases()
+                    random.shuffle(testcases)
+                    testcases_ids = ",".join([str(tc.id) for tc in testcases]
+                                             )
+                    testcases_order = TestCaseOrder.objects.create(
+                                    answer_paper=ans_paper,
+                                    question=question,
+                                    order=testcases_ids)
+
             ans_paper.questions_order = ",".join(question_ids)
             ans_paper.save()
             ans_paper.questions_unanswered.add(*questions)
@@ -1829,7 +1860,7 @@ class AnswerPaper(models.Model):
                .format(u.first_name, u.last_name, q.description)
 
 
-################################################################################
+##############################################################################
 class AssignmentUploadManager(models.Manager):
 
     def get_assignments(self, qp, que_id=None, user_id=None):
@@ -1851,7 +1882,7 @@ class AssignmentUploadManager(models.Manager):
         return assignment_files, file_name
 
 
-################################################################################
+##############################################################################
 class AssignmentUpload(models.Model):
     user = models.ForeignKey(User)
     assignmentQuestion = models.ForeignKey(Question)
@@ -1860,7 +1891,7 @@ class AssignmentUpload(models.Model):
     objects = AssignmentUploadManager()
 
 
-###############################################################################
+##############################################################################
 class TestCase(models.Model):
     question = models.ForeignKey(Question, blank=True, null=True)
     type = models.CharField(max_length=24, choices=test_case_types, null=True)
@@ -1978,3 +2009,19 @@ class FloatTestCase(TestCase):
         return u'Testcase | Correct: {0} | Error Margin: +or- {1}'.format(
                 self.correct, self.error_margin
                 )
+
+
+##############################################################################
+class TestCaseOrder(models.Model):
+    """Testcase order contains a set of ordered test cases for a given question
+        for each user.
+    """
+
+    # Answerpaper of the user.
+    answer_paper = models.ForeignKey(AnswerPaper, related_name="answer_paper")
+
+    # Question in an answerpaper.
+    question = models.ForeignKey(Question)
+
+    #Order of the test case for a question.
+    order = models.TextField()
diff --git a/yaksh/static/yaksh/js/add_question.js b/yaksh/static/yaksh/js/add_question.js
index 346991a..0f02aab 100644
--- a/yaksh/static/yaksh/js/add_question.js
+++ b/yaksh/static/yaksh/js/add_question.js
@@ -126,8 +126,9 @@ function textareaformat()
 	document.getElementById('my').innerHTML = document.getElementById('id_description').value ;
 	document.getElementById('rend_solution').innerHTML = document.getElementById('id_solution').value ;
 
+    var question_type = document.getElementById('id_type').value
     if (document.getElementById('id_grade_assignment_upload').checked ||
-        document.getElementById('id_type').value == 'upload'){
+        question_type == 'upload'){
         $("#id_grade_assignment_upload").prop("disabled", false);
     }
     else{
diff --git a/yaksh/templates/yaksh/design_questionpaper.html b/yaksh/templates/yaksh/design_questionpaper.html
index 1656e2b..d982d27 100644
--- a/yaksh/templates/yaksh/design_questionpaper.html
+++ b/yaksh/templates/yaksh/design_questionpaper.html
@@ -192,10 +192,14 @@ select
 
     <div class="tab-pane" id="finish">
         <center>
-            <h5>Almost finished creating your question paper</h5>
+            <h5><u>Almost finished creating your question paper</u></h5>
             <label style="float: none;">
                 {{ qpaper_form.shuffle_questions }}
-                <span>Auto shuffle.</span>
+                <span>Shuffle questions' order for each student</span>
+            </label> <br><br>
+            <label style="float: none;">
+                {{ qpaper_form.shuffle_testcases }}
+                <span>Shuffle MCQ/MCC options for each student</span>
             </label> <br><br>
             <input class ="btn primary large" type="submit" name="save" id="save" value="Save question paper">
             <br>
diff --git a/yaksh/templates/yaksh/user_data.html b/yaksh/templates/yaksh/user_data.html
index 45867d2..ce2533e 100644
--- a/yaksh/templates/yaksh/user_data.html
+++ b/yaksh/templates/yaksh/user_data.html
@@ -74,8 +74,7 @@ User IP address: {{ paper.user_ip }}
                         {% endif %}
                     {% endfor %}
 
-            {% elif question.type == "integer" or question.type == "string"
-               or question.type == "float" %}
+            {% elif question.type == "integer" or question.type == "string" or question.type == "float" %}
                 <h5> <u>Correct Answer:</u></h5>
                     {% for testcase in question.get_test_cases %}
                     <strong>{{ testcase.correct|safe }}</strong>
diff --git a/yaksh/templates/yaksh/view_answerpaper.html b/yaksh/templates/yaksh/view_answerpaper.html
index 410b578..971ef77 100644
--- a/yaksh/templates/yaksh/view_answerpaper.html
+++ b/yaksh/templates/yaksh/view_answerpaper.html
@@ -34,7 +34,7 @@
     Start time: {{ paper.start_time }} <br/>
     End time : {{ paper.end_time }} <br/>
     Percentage obtained: {{ paper.percent }}% <br/>
-    {% if paper.passed == 0 %}
+    {% if paper.passed %}
     Status : <b style="color: red;"> Failed </b><br/>
     {% else %}
     Status : <b style="color: green;"> Passed </b><br/>
@@ -55,7 +55,8 @@
             <h5><u>Question:</u></h5> <strong>{{ question.description|safe }}</strong>
             {% if question.type == "mcq" or question.type == "mcc" %}
                 <h5> <u>Choices:</u></h5>
-                {% for testcase in question.get_test_cases %}
+                {% get_ordered_testcases question paper as testcases %}
+                {% for testcase in testcases %}
                 {% if testcase.correct %}
                    <br/>
                    <strong>{{ forloop.counter }}. {{ testcase.options|safe }}</strong>
diff --git a/yaksh/templatetags/custom_filters.py b/yaksh/templatetags/custom_filters.py
index 3c2c6fd..fa0802f 100644
--- a/yaksh/templatetags/custom_filters.py
+++ b/yaksh/templatetags/custom_filters.py
@@ -62,3 +62,8 @@ def module_completion_percent(course, module, user):
 @register.simple_tag
 def course_completion_percent(course, user):
     return course.percent_completed(user)
+
+
+@register.simple_tag
+def get_ordered_testcases(question, answerpaper):
+	return question.get_ordered_test_cases(answerpaper)
\ No newline at end of file
diff --git a/yaksh/test_models.py b/yaksh/test_models.py
index cd4279b..a0ccd49 100644
--- a/yaksh/test_models.py
+++ b/yaksh/test_models.py
@@ -113,6 +113,7 @@ def tearDownModule():
     Lesson.objects.all().delete()
     LearningUnit.objects.all().delete()
     LearningModule.objects.all().delete()
+    AnswerPaper.objects.all().delete()
 
 
 ###############################################################################
@@ -625,8 +626,9 @@ class QuestionPaperTestCases(unittest.TestCase):
     @classmethod
     def setUpClass(self):
         self.course = Course.objects.get(name="Python Course")
+        self.user= User.objects.get(username='creator')
         # All active questions
-        self.questions = Question.objects.filter(active=True)
+        self.questions = Question.objects.filter(active=True, user=self.user)
         self.quiz = Quiz.objects.get(description="demo quiz 1")
 
         # create question paper with only fixed questions
@@ -848,7 +850,7 @@ class AnswerPaperTestCases(unittest.TestCase):
         )
         self.qtn_paper_with_single_question.save()
 
-        all_questions = Question.objects.all()
+        all_questions = Question.objects.filter(user=self.user).order_by("id")
         self.questions = all_questions[0:3]
         self.start_time = timezone.now()
         self.end_time = self.start_time + timedelta(minutes=20)
@@ -874,6 +876,9 @@ class AnswerPaperTestCases(unittest.TestCase):
         self.answerpaper.attempt_number = already_attempted + 1
         self.answerpaper.save()
         self.answerpaper.questions.add(*self.questions)
+        self.answerpaper.questions_order = ",".join(
+                            [str(q.id) for q in self.questions]
+                            )
         self.answerpaper.questions_unanswered.add(*self.questions)
         self.answerpaper.save()
         # answers for the Answer Paper
@@ -928,17 +933,17 @@ class AnswerPaperTestCases(unittest.TestCase):
 
         self.question1.language = 'python'
         self.question1.test_case_type = 'standardtestcase'
-        self.question1.summary = "Question1"
+        self.question1.summary = "Q1"
         self.question1.save()
         self.question2.language = 'python'
         self.question2.type = 'mcq'
         self.question2.test_case_type = 'mcqtestcase'
-        self.question2.summary = "Question2"
+        self.question2.summary = "Q2"
         self.question2.save()
         self.question3.language = 'python'
         self.question3.type = 'mcc'
         self.question3.test_case_type = 'mcqtestcase'
-        self.question3.summary = "Question3"
+        self.question3.summary = "Q3"
         self.question3.save()
         self.assertion_testcase = StandardTestCase(
             question=self.question1,
@@ -1097,7 +1102,8 @@ class AnswerPaperTestCases(unittest.TestCase):
         details = self.answerpaper.regrade(self.question3.id)
 
         # Then
-        self.answer = self.answerpaper.answers.filter(question=self.question3).last()
+        self.answer = self.answerpaper.answers.filter(
+                            question=self.question3).last()
         self.assertTrue(details[0])
         self.assertEqual(self.answer.marks, 0)
         self.assertFalse(self.answer.correct)
@@ -1237,9 +1243,9 @@ class AnswerPaperTestCases(unittest.TestCase):
         """ Test Answer Paper"""
         self.assertEqual(self.answerpaper.user.username, 'creator')
         self.assertEqual(self.answerpaper.user_ip, self.ip)
-        questions = self.answerpaper.get_questions()
+        questions = [q.id for q in self.answerpaper.get_questions()]
         num_questions = len(questions)
-        self.assertSequenceEqual(list(questions), list(self.questions))
+        self.assertEqual(set(questions), set([q.id for q in self.questions]))
         self.assertEqual(num_questions, 3)
         self.assertEqual(self.answerpaper.question_paper, self.question_paper)
         self.assertEqual(self.answerpaper.start_time, self.start_time)
@@ -1250,7 +1256,7 @@ class AnswerPaperTestCases(unittest.TestCase):
         self.assertEqual(self.answerpaper.questions_left(), 3)
         # Test current_question() method of Answer Paper
         current_question = self.answerpaper.current_question()
-        self.assertEqual(current_question.summary, "Question1")
+        self.assertEqual(current_question.summary, "Q1")
         # Test completed_question() method of Answer Paper
 
         question = self.answerpaper.add_completed_question(self.question1.id)
@@ -1259,14 +1265,14 @@ class AnswerPaperTestCases(unittest.TestCase):
 
         # Test next_question() method of Answer Paper
         current_question = self.answerpaper.current_question()
-        self.assertEqual(current_question.summary, "Question2")
+        self.assertEqual(current_question.summary, "Q2")
 
         # When
         next_question_id = self.answerpaper.next_question(current_question.id)
 
         # Then
         self.assertTrue(next_question_id is not None)
-        self.assertEqual(next_question_id.summary, "Question3")
+        self.assertEqual(next_question_id.summary, "Q3")
 
         # Given, here question is already answered
         current_question_id = self.question1.id
@@ -1276,7 +1282,7 @@ class AnswerPaperTestCases(unittest.TestCase):
 
         # Then
         self.assertTrue(next_question_id is not None)
-        self.assertEqual(next_question_id.summary, "Question2")
+        self.assertEqual(next_question_id.summary, "Q2")
 
         # Given, wrong question id
         current_question_id = 12
@@ -1286,7 +1292,7 @@ class AnswerPaperTestCases(unittest.TestCase):
 
         # Then
         self.assertTrue(next_question_id is not None)
-        self.assertEqual(next_question_id.summary, "Question1")
+        self.assertEqual(next_question_id.summary, "Q1")
 
         # Given, last question in the list
         current_question_id = self.question3.id
@@ -1297,7 +1303,7 @@ class AnswerPaperTestCases(unittest.TestCase):
         # Then
         self.assertTrue(next_question_id is not None)
 
-        self.assertEqual(next_question_id.summary, "Question1")
+        self.assertEqual(next_question_id.summary, "Q1")
 
         # Test get_questions_answered() method
         # When
@@ -1312,8 +1318,11 @@ class AnswerPaperTestCases(unittest.TestCase):
 
         # Then
         self.assertEqual(questions_unanswered.count(), 2)
-        self.assertSequenceEqual(questions_unanswered,
-                                 [self.questions[1], self.questions[2]])
+        self.assertEqual(set([q.id for q in questions_unanswered]),
+                                 set([self.questions[1].id,
+                                      self.questions[2].id]
+                                     )
+                        )
 
         # Test completed_question and next_question
         # When all questions are answered
@@ -1325,7 +1334,7 @@ class AnswerPaperTestCases(unittest.TestCase):
         # Then
         self.assertEqual(self.answerpaper.questions_left(), 1)
         self.assertIsNotNone(current_question)
-        self.assertEqual(current_question.summary, "Question3")
+        self.assertEqual(current_question.summary, "Q3")
 
         # When
         current_question = self.answerpaper.add_completed_question(
@@ -1335,7 +1344,7 @@ class AnswerPaperTestCases(unittest.TestCase):
         # Then
         self.assertEqual(self.answerpaper.questions_left(), 0)
         self.assertIsNotNone(current_question)
-        self.assertTrue(current_question == self.answerpaper.questions.all()[0])
+        self.assertTrue(current_question == self.answerpaper.get_all_ordered_questions()[0])
 
         # When
         next_question_id = self.answerpaper.next_question(current_question_id)
@@ -1426,7 +1435,9 @@ class CourseTestCases(unittest.TestCase):
         self.student2 = User.objects.get(username="demo_user3")
         self.quiz1 = Quiz.objects.get(description='demo quiz 1')
         self.quiz2 = Quiz.objects.get(description='demo quiz 2')
-        self.questions = Question.objects.filter(active=True)
+        self.questions = Question.objects.filter(active=True,
+                                                 user=self.creator
+                                                 )
         self.modules = LearningModule.objects.filter(creator=self.creator)
 
         # create courses with disabled enrollment
diff --git a/yaksh/views.py b/yaksh/views.py
index 011b417..27a07d2 100644
--- a/yaksh/views.py
+++ b/yaksh/views.py
@@ -616,7 +616,10 @@ def show_question(request, question, paper, error_message=None, notification=Non
             if question.type == "code" else
             'You have already attempted this question'
         )
-    test_cases = question.get_test_cases()
+    if question.type in ['mcc', 'mcq']:
+        test_cases = question.get_ordered_test_cases(paper)
+    else:
+        test_cases = question.get_test_cases()
     files = FileUpload.objects.filter(question_id=question.id, hide=False)
     course = Course.objects.get(id=course_id)
     module = course.learning_module.get(id=module_id)