class ProblemTest(unittest.TestCase): def setUp(self): self.q = "Question" self.a = "Answer" self.p = Problem(self.q,self.a) def test_get_question(self): self.assertEqual(self.p.get_question(),self.q) def test_get_answer(self): self.assertEqual(self.p.get_answer(),self.a) def test_set_question(self): self.p.set_question("New Question") self.assertEqual(self.p.get_question(),"New Question") def test_set_answer(self): self.p.set_answer("New Answer") self.assertEqual(self.p.get_answer(),"New Answer") def test_check_answer(self): self.assertTrue(self.p.check_answer(self.a)) self.assertFalse(self.p.check_answer("not the answer")) def test_as_string(self): test_string = "Problem|Question|Answer|" self.assertEqual(self.p.as_string(),test_string) def test_copy(self): copy = self.p.copy() self.assertFalse(self.p is copy) self.assertEqual(self.p.as_string(),copy.as_string())
class ProblemSetTest(unittest.TestCase): def setUp(self): self.name = "Problem_Set" self.pset = ProblemSet(self.name) self.pset.test_fill_quotes() self.pset.test_fill_math(10) self.pset.test_fill(10) self.problemA = Problem("Question A", "Answer A") self.problemB = Problem("Question B", "Answer B") self.problemC = Problem("Question C", "Answer C") def test_get_name(self): self.assertEqual(self.name, self.pset.get_name()) def test_set_name(self): self.pset.set_name("My Problem Set") self.assertEqual("My Problem Set", self.pset.get_name()) def test_add_problem(self): self.pset.add_problem(self.problemA) self.assertEqual(self.pset.get_problem(self.pset.get_length() - 1), self.problemA) def test_find_problem(self): self.assertEqual(self.pset.find_problem(self.problemA), -1) self.pset.add_problem(self.problemA) self.pset.add_problem(self.problemB) self.pset.add_problem(self.problemC) ind_probA = self.pset.find_problem(self.problemA) ind_probB = self.pset.find_problem(self.problemB) ind_probC = self.pset.find_problem(self.problemC) self.assertEqual(self.pset.get_problem(ind_probA), self.problemA) self.assertEqual(self.pset.get_problem(ind_probB), self.problemB) self.assertEqual(self.pset.get_problem(ind_probC), self.problemC) def test_remove_problem(self): self.assertEqual(self.pset.remove_problem(self.problemA), -1) p = self.pset.get_problem(0) self.assertEqual(self.pset.remove_problem(p), 0) self.assertEqual(self.pset.find_problem(p), -1) def test_replace_problem(self): p = self.pset.get_problem(0) self.pset.replace_problem(0, self.problemA) self.assertEqual(self.pset.find_problem(p), -1) self.assertEqual(self.pset.find_problem(self.problemA), 0) def test_insert_problem(self): p = self.pset.get_problem(5) self.pset.insert_problem(5, self.problemA) self.assertEqual(self.pset.get_problem(5), self.problemA) self.assertEqual(self.pset.get_problem(6), p) def test_swap_problem(self): self.assertEqual(self.pset.swap_problem(-1, 1), -1) self.assertEqual(self.pset.swap_problem(0, 0), -1) self.assertEqual(self.pset.swap_problem(1, -1), -1) p0 = self.pset.get_problem(0) #problem in position zero orginally p1 = self.pset.get_problem(1) #problem in position one orginally self.assertEqual(self.pset.swap_problem(0, 1), 0) self.assertEqual(self.pset.get_problem(0), p1) #p1 should be in pos 0 self.assertEqual(self.pset.get_problem(1), p0) #p0 should be in pos 1 def test_move_problem(self): #dst > org ind_org = 0 ind_dst = 10 prob_org = self.pset.get_problem(ind_org) prob_dst = self.pset.get_problem(ind_dst) self.assertEqual(self.pset.move_problem(ind_org, ind_dst), 0) self.assertEqual(self.pset.get_problem(ind_dst), prob_org) self.assertEqual(self.pset.get_problem(ind_dst - 1), prob_dst) #dst < org ind_org = 12 ind_dst = 1 prob_org = self.pset.get_problem(ind_org) prob_dst = self.pset.get_problem(ind_dst) self.assertEqual(self.pset.move_problem(ind_org, ind_dst), 0) self.assertEqual(self.pset.get_problem(ind_dst), prob_org) self.assertEqual(self.pset.get_problem(ind_dst + 1), prob_dst) def test_pop_problem(self): pset_length = self.pset.get_length() last_problem = self.pset.get_problem(pset_length - 1) self.pset.pop_problem() self.assertEqual(self.pset.find_problem(last_problem), -1) self.assertEqual(self.pset.get_length(), pset_length - 1) def test_copy(self): pset_copy = self.pset.copy() self.assertFalse(pset_copy == self.pset) self.assertEqual(pset_copy.as_string(), self.pset.as_string()) def test_consolidate(self): p1 = ProblemSet("", self.problemA, self.problemB) p2 = ProblemSet("", self.problemB, self.problemC) p3 = ProblemSet("", self.problemC, self.problemA) test_string = p1.as_string().rstrip() + p2.as_string().rstrip( ) + p3.as_string() p1.consolidate(p2, p3) self.assertEqual(p1.as_string(), test_string) def test_check_index(self): test = ProblemSet("", self.problemA, self.problemB, self.problemC) self.assertFalse(test.check_index(-1)) self.assertFalse(test.check_index(test.get_length())) self.assertTrue(test.check_index(0)) self.assertTrue(test.check_index(test.get_length() - 1)) def test_as_string(self): ps = ProblemSet("ProblemSet") ps.add_problem(self.problemA) ps.add_problem(self.problemB) ps.add_problem(self.problemC) comp_str = "ProblemSet" + "\n" + self.problemA.as_string() + "\n" comp_str += self.problemB.as_string() + "\n" + self.problemC.as_string( ) + "\n" self.assertEqual(ps.as_string(), comp_str) def test_save_load(self): self.pset.save("deleteme") load_set = ProblemSet() load_set.load("deleteme") self.assertEqual(self.pset.as_string(), load_set.as_string()) def test_txt(self): self.pset.as_text_file("tester")
class ExamTest(unittest.TestCase): def setUp(self): self.name = "Exam" self.exam = Exam(self.name) self.exam.test_fill_quotes() #self.exam.save("setup") self.problemA = Problem("Question A", "Answer A") self.problemB = Problem("Question B", "Answer B") self.problemC = Problem("Question C", "Answer C") def tearDown(self): del self.exam del self.problemA del self.problemB del self.problemC def test_get_name(self): self.assertEqual(self.name, self.exam.get_name()) def test_set_name(self): self.exam.set_name("MyExam") self.assertEqual("MyExam", self.exam.get_name()) def test_find_problem(self): self.assertEqual(self.exam.find_problem(self.problemA), -1) self.exam.add_problem(self.problemA, 1) self.exam.add_problem(self.problemB, 1) self.exam.add_problem(self.problemC, 1) indA = self.exam.find_problem(self.problemA) indB = self.exam.find_problem(self.problemB) indC = self.exam.find_problem(self.problemC) self.assertEqual( self.exam.get_problem(indA).as_string(), self.problemA.as_string()) self.assertEqual( self.exam.get_problem(indB).as_string(), self.problemB.as_string()) self.assertEqual( self.exam.get_problem(indC).as_string(), self.problemC.as_string()) def test_remove_problem(self): self.assertEqual(self.exam.remove_problem(self.problemA), -1) p = self.exam.get_problem(0) self.assertEqual(self.exam.remove_problem(p), 0) self.assertEqual(self.exam.find_problem(p), -1) def test_replace_problem(self): p = self.exam.get_problem(0) self.assertTrue(self.exam.check_index(0)) self.assertEqual(self.exam.replace_problem(0, self.problemA, 1), 0) self.assertEqual(self.exam.find_problem(p), -1) self.assertEqual(self.exam.find_problem(self.problemA), 0) def test_insert_problem(self): p = self.exam.get_problem(5) self.exam.insert_problem(5, self.problemA, 1) self.assertEqual(self.exam.get_problem(5), self.problemA) self.assertEqual(self.exam.get_problem(6), p) def test_swap_problem(self): self.assertEqual(self.exam.swap_problem(-1, 1), -1) self.assertEqual(self.exam.swap_problem(0, 0), -1) self.assertEqual(self.exam.swap_problem(1, -1), -1) p0 = self.exam.get_problem(0) #problem in position zero orginally p1 = self.exam.get_problem(1) #problem in position one orginally self.assertEqual(self.exam.swap_problem(0, 1), 0) self.assertEqual(self.exam.get_problem(0), p1) #p1 should be in pos 0 self.assertEqual(self.exam.get_problem(1), p0) #p0 should be in pos 1 def test_move_problem(self): #dst > org ind_org = 0 ind_dst = 5 prob_org = self.exam.get_problem(ind_org) prob_dst = self.exam.get_problem(ind_dst) self.assertEqual(self.exam.move_problem(ind_org, ind_dst), 0) self.assertEqual(self.exam.get_problem(ind_dst), prob_org) self.assertEqual(self.exam.get_problem(ind_dst - 1), prob_dst) #dst < org ind_org = 5 ind_dst = 1 prob_org = self.exam.get_problem(ind_org) prob_dst = self.exam.get_problem(ind_dst) self.assertEqual(self.exam.move_problem(ind_org, ind_dst), 0) self.assertEqual(self.exam.get_problem(ind_dst), prob_org) self.assertEqual(self.exam.get_problem(ind_dst + 1), prob_dst) def test_pop_problem(self): exam_length = self.exam.get_length() last_problem = self.exam.get_problem(exam_length - 1) self.exam.pop_problem() self.assertEqual(self.exam.find_problem(last_problem), -1) self.assertEqual(self.exam.get_length(), exam_length - 1) def test_copy(self): exam_copy = self.exam.copy() self.assertFalse(exam_copy == self.exam) self.assertEqual(exam_copy.as_string(), self.exam.as_string()) def test_check_index(self): self.assertFalse(self.exam.check_index(-1)) self.assertFalse(self.exam.check_index(self.exam.get_length())) self.assertTrue(self.exam.check_index(0)) self.assertTrue(self.exam.check_index(self.exam.get_length() - 1)) def test_as_string(self): ex = Exam("Exam", [1, 1, 1], ProblemSet("", self.problemA, self.problemB, self.problemC)) points = ' '.join([str(i) for i in ex.get_points()]) comp_str = "Exam" + "\n" + points + '\n' + self.problemA.as_string( ) + "\n" comp_str += self.problemB.as_string() + "\n" + self.problemC.as_string( ) + "\n" self.assertEqual(ex.as_string(), comp_str) def test_save_load(self): self.exam.save("deleteme") load_set = Exam() load_set.load("deleteme") self.assertEqual(self.exam.as_string(), load_set.as_string()) def test_consolidate(self): test = Exam() #test is easy if we eliminate the name otherwise we have to do a lot of str manip self.exam.set_name("") test.consolidate(self.exam, self.exam, self.exam) test_string = '\n' + ' '.join( [str(i) for i in (self.exam.get_points() * 3)]) test_string += super(Exam, self.exam).as_string().rstrip() * 3 + '\n' self.assertEqual(test.as_string(), test_string) def test_txt(self): #self.exam.as_text_file("tester") pass