def students() -> List[course.Student]:
return [
course.Student(1, 'Zoro'),
course.Student(2, 'Aaron'),
course.Student(3, 'Gertrude'),
course.Student(4, 'Yvette')
]
def test_course_class_course_get_students() -> None:
s1 = course.Student(1, 'Misha')
s2 = course.Student(2, 'Jenni')
courses = course.Course('CSC148')
courses.enroll_students([s1, s2])
assert courses.get_students() == (s1, s2)
assert not courses.get_students() == (s2, s1)
def test_simple(self):
g = grouper.Group([])
students = [course.Student(i, "Shit" + str(i)) for i in range(10)]
assert g.get_members() == []
assert len(g) == 0
assert students[0] not in g
g = grouper.Group(students)
assert len(g) == 10
for i in range(10):
assert students[i] in g
assert students[i].name in str(g)
assert isinstance(g.get_members(), list)
assert len(g.get_members()) == 10
# mutate shallow copy should not affect original list in Group
members = g.get_members()
members.append(course.Student(100, 'ok'))
assert len(g) == 10
for i in range(10):
assert students[i] in g
assert students[i].name in str(g)
assert isinstance(g.get_members(), list)
assert len(g.get_members()) == 10
def studs_violates() -> List[course.Student]:
return [
course.Student(1, 'Zoro'),
course.Student(2, 'Aaron'),
course.Student(3, 'Gertrude'),
course.Student(4, '')
]
def students_out_of_order():
return [
course.Student(2, 'Zoro'),
course.Student(3, 'Aaron'),
course.Student(1, 'Gertrude'),
course.Student(4, 'Yvette')
]
def answer_questions(self) -> List[course.Student]:
# students
s1 = course.Student(2, "First")
s1.set_answer(self.q1, survey.Answer("owl"))
s1.set_answer(self.q2, survey.Answer(False))
s1.set_answer(self.q3, survey.Answer(["chaotic", "evil"]))
s1.set_answer(self.q4, survey.Answer(1))
s2 = course.Student(25, "Second")
s2.set_answer(self.q1, survey.Answer("bug"))
s2.set_answer(self.q2, survey.Answer(False))
s2.set_answer(self.q3, survey.Answer(["chaotic", "evil", "neutral"]))
s2.set_answer(self.q4, survey.Answer(8))
s3 = course.Student(34, "Third")
s3.set_answer(self.q1, survey.Answer("human"))
s3.set_answer(self.q2, survey.Answer(True))
s3.set_answer(self.q3, survey.Answer(["chaotic", "neutral"]))
s3.set_answer(self.q4, survey.Answer(5))
s4 = course.Student(9, "Fourth")
s4.set_answer(self.q1, survey.Answer("owl"))
s4.set_answer(self.q2, survey.Answer(False))
s4.set_answer(self.q3, survey.Answer(["neutral"]))
s4.set_answer(self.q4, survey.Answer(2))
s5 = course.Student(89, "Last")
s5.set_answer(self.q1, survey.Answer("human"))
s5.set_answer(self.q2, survey.Answer(True))
s5.set_answer(self.q3, survey.Answer(["evil"]))
s5.set_answer(self.q4, survey.Answer(7))
s = [s1, s2, s3, s4, s5]
return s
def test_grouper_class_grouping_add_group_() -> None:
grouping1 = grouper.Grouping()
ted = course.Student(1, "Ted")
fred = course.Student(2, "Fred")
jack = course.Student(3, "Jack")
assert not grouping1.add_group(grouper.Group([]))
assert grouping1.add_group(grouper.Group([ted, fred]))
assert not grouping1.add_group(grouper.Group([ted, jack]))
def test__has_student() -> None:
course1 = course.Course("CSC148")
ted = course.Student(1, "Ted")
fred = course.Student(2, "Fred")
students = [ted, fred]
course1.enroll_students(students)
assert course1._Course__has_student(ted)
assert not course1._Course__has_student(course.Student(3, "Bob"))
def test_course_get_students(self) -> None:
c = course.Course("mental health")
students = [
course.Student(1, "ay"),
course.Student(3, "bee"),
course.Student(2, "sea")
]
c.enroll_students(students)
assert c.get_students()[1].name == 'sea'
def test_sort_students() -> None:
s1 = course.Student(1, "gad")
s2 = course.Student(53, "floof")
s3 = course.Student(9, "gad")
s4 = course.Student(15, "blep")
s5 = course.Student(4, "meep")
ppl = [s1, s2, s3, s4, s5]
assert course.sort_students(ppl, 'id') == [s1, s5, s3, s4, s2]
assert course.sort_students(ppl, 'name') == [s4, s2, s1, s3, s5]
def test_has_answer(self, questions):
s = course.Student(1, 'Bob')
s1 = course.Student(2, 'George')
s2 = course.Student(3, 'Dylan')
s.set_answer(questions[0], survey.Answer('a'))
s1.set_answer(questions[0], survey.Answer('n'))
assert s.has_answer(questions[0]) is True
assert s1.has_answer(questions[0]) is False
assert s2.has_answer(questions[0]) is False
def test_course_complex(self):
c = course.Course("SHIT101")
c.enroll_students([])
# enroll empty list, got empty
assert c.students == []
assert c.get_students() == ()
# add one student
c.enroll_students([course.Student(0, "FUCK0")])
assert len(c.students) == 1
assert [(x.id, x.name) for x in c.students] == [(0, 'FUCK0')]
assert len(c.get_students()) == 1
assert isinstance(c.get_students(), tuple)
assert [(x.id, x.name) for x in c.get_students()] == [(0, 'FUCK0')]
# add same student again should not change anything
c.enroll_students([course.Student(0, "FUCK0")])
assert len(c.students) == 1
assert [(x.id, x.name) for x in c.students] == [(0, 'FUCK0')]
assert len(c.get_students()) == 1
assert isinstance(c.get_students(), tuple)
assert [(x.id, x.name) for x in c.get_students()] == [(0, 'FUCK0')]
# add student with empty name should not change anything
c.enroll_students([course.Student(888, "")])
assert len(c.students) == 1
assert [(x.id, x.name) for x in c.students] == [(0, 'FUCK0')]
assert len(c.get_students()) == 1
assert isinstance(c.get_students(), tuple)
assert [(x.id, x.name) for x in c.get_students()] == [(0, 'FUCK0')]
# add some more
c.enroll_students([course.Student(2, "FUCK2"), course.Student(1, "FUCK1"), course.Student(99, "FUCK99")])
assert len(c.students) == 4
assert len(c.get_students()) == 4
assert isinstance(c.get_students(), tuple)
assert [(x.id, x.name) for x in c.get_students()] == [(0, 'FUCK0'), (1, 'FUCK1'), (2, 'FUCK2'), (99, 'FUCK99')]
# add some more, but contains invalid student, should change nothing
c.enroll_students([course.Student(2, "FUCK2"),
course.Student(0, "FUCK0"),
course.Student(88, "FUCK88"),
course.Student(99, "FUCK99")])
assert len(c.students) == 4
assert len(c.get_students()) == 4
assert isinstance(c.get_students(), tuple)
assert [(x.id, x.name) for x in c.get_students()] == [(0, 'FUCK0'),
(1, 'FUCK1'),
(2, 'FUCK2'),
(99, 'FUCK99')]
def test_course_enroll(self) -> None:
c = course.Course("underwater basket weaving")
assert c.name == 'underwater basket weaving'
assert c.students == []
students = [
course.Student(1, "ay"),
course.Student(3, "bee"),
course.Student(2, "sea")
]
c.enroll_students(students)
assert len(c.students) == len(students)
for s in students:
assert s in c.students
def students() -> List[course.Student]:
return [
course.Student(1, 'Zoro'),
course.Student(2, 'Aaron'),
course.Student(3, 'Gertrude'),
course.Student(4, 'Yvette'),
course.Student(5, 'Alisa'),
course.Student(6, 'Paulina'),
course.Student(7, 'Emily'),
course.Student(7, 'Sophia'),
course.Student(10, 'Jacob'),
course.Student(11, 'Anna')
]
def students():
s1 = course.Student(1, 'A')
s2 = course.Student(2, 'B')
s3 = course.Student(3, 'C')
s4 = course.Student(4, 'D')
s5 = course.Student(5, 'E')
s6 = course.Student(5, 'F')
s7 = course.Student(5, 'G')
s8 = course.Student(5, 'H')
s9 = course.Student(5, 'L')
return [s1, s2, s3, s4, s5]
def test_survey_class_survey_score_students_two_students() -> None:
s1 = course.Student(1, 'Misha')
s2 = course.Student(2, 'Jennifer')
students = [s1, s2]
question1 = survey.NumericQuestion(1, 'Do you like food?', 0, 10)
answer1 = survey.Answer(5)
answer2 = survey.Answer(10)
survey1 = survey.Survey([question1])
criteria = criterion.HeterogeneousCriterion()
weight1 = 3
s1.set_answer(question1, answer1)
s2.set_answer(question1, answer2)
survey1.set_weight(weight1, question1)
survey1.set_criterion(criteria, question1)
assert survey1.score_students(students) == 1.5
def test_window(self):
students = [course.Student(i, "Shit" + str(i)) for i in range(5)]
questions = [survey.NumericQuestion(i, "FUCKNQ" + str(i), 2, 8) for i in range(5)]
s = survey.Survey(questions)
answers = [1, 0, 0, 3, 4, 1, 0, 1, 1, 1, 2, 1, 2, 2, 2, 3, 2, 1, 0, 1, 3, 0, 0, 3, 2]
i = 0
for q in questions:
for stu in students:
stu.set_answer(q, survey.Answer(2 + answers[i]))
i += 1
c = course.Course("Asshole101")
c.enroll_students(students)
grouping1 = grouper.WindowGrouper(1).make_grouping(c, s)
assert len(grouping1) == 5
assert grouping_to_list_of_list(grouping1) == [[0], [1], [2], [3], [4]]
grouping2 = grouper.WindowGrouper(2).make_grouping(c, s)
assert len(grouping2) == 3
assert grouping_to_list_of_list(grouping2) == [[0], [1, 2], [3, 4]]
grouping3 = grouper.WindowGrouper(3).make_grouping(c, s)
assert len(grouping3) == 2
assert grouping_to_list_of_list(grouping3) == [[0, 1, 2], [3, 4]]
grouping5 = grouper.WindowGrouper(5).make_grouping(c, s)
assert len(grouping5) == 1
assert grouping_to_list_of_list(grouping5) == [[0, 1, 2, 3, 4]]
def test_course_class_student_set_answer() -> None:
s1 = course.Student(1, 'Misha')
question = survey.YesNoQuestion(1, 'Do you like food?')
answer = survey.Answer(True)
s1.set_answer(question, answer)
# noinspection PyProtectedMember
assert answer in s1._answers
def students1() -> List[course.Student]:
return [course.Student(1, 'Zoro'),
course.Student(2, 'Aaron'),
course.Student(3, 'Gertrude'),
course.Student(4, 'Yvette'),
course.Student(5, 'George'),
course.Student(6, 'Steph'),
course.Student(7, 'Draymond'),
course.Student(8, 'Andrew')]
def test_complicated(self):
students = [course.Student(i, "Shit" + str(i)) for i in range(3)]
questions1 = [survey.NumericQuestion(i, "FUCKNQ" + str(i), 2, 8) for i in range(5)]
s = survey.Survey(questions1)
assert len(s) == 5
assert questions1[0] in s
assert survey.YesNoQuestion(99, "Yue?") not in s
assert str(s).count("FUCKNQ") >= 5
assert len(s.get_questions()) == 5
assert fuck_compare_lists([x.id for x in s.get_questions()], [0, 1, 2, 3, 4])
answers = [0, 1, 0, 1, 2] * 3
i = 0
for q in questions1:
for stu in students:
stu.set_answer(q, survey.Answer(2 + answers[i]))
i += 1
assert fuck_within(s.score_students(students), 0.8222222)
answers = [1, 0, 0, 3, 4] * 3
i = 0
for q in questions1:
for stu in students:
stu.set_answer(q, survey.Answer(2 + answers[i]))
i += 1
assert fuck_within(s.score_students(students), 0.6666666666666667)
s.set_weight(2, questions1[0])
assert fuck_within(s.score_students(students), 0.8444444444444444)
s.set_criterion(criterion.HeterogeneousCriterion(), questions1[1])
assert fuck_within(s.score_students(students), 0.7777777777777779)
# this should result in InvalidAnswerError
answers = [9, 9, 9, 9, 9] * 3
i = 0
for q in questions1:
for stu in students:
stu.set_answer(q, survey.Answer(2 + answers[i]))
i += 1
assert fuck_within(s.score_students(students), 0)
assert s.score_grouping(grouper.Grouping()) == 0, '''empty grouping result always 1'''
g = grouper.Grouping()
g.add_group(grouper.Group([students[0]]))
g.add_group(grouper.Group([students[1]]))
g.add_group(grouper.Group([students[2]]))
assert s.score_students([students[0]]) == 0
assert s.score_students([students[1]]) == 0
assert s.score_students([students[2]]) == 0
assert s.score_grouping(g) == 0
answers = [1, 0, 0, 3, 4] * 3
i = 0
for q in questions1:
for stu in students:
stu.set_answer(q, survey.Answer(2 + answers[i]))
i += 1
assert s.score_grouping(g) == 1.0
def load_course(data: Dict[str, Any]) -> course.Course:
"""Return a course created using the information in <data>"""
course_name = data['name']
course_ = course.Course(course_name)
students = [course.Student(s_data['id'], s_data['name'])
for s_data in data['students']]
course_.enroll_students(students)
return course_
def test_make_grouping_greedy(self):
new_course = course.Course('CSC148')
q1 = survey.CheckboxQuestion(1, 'Hobbies?',
['Movie', 'Sing', 'Dance', 'Game'])
new_survey = survey.Survey([q1])
students = [course.Student(1, 'Zoro'),
course.Student(2, 'Aaron'),
course.Student(3, 'Gertrude'),
course.Student(4, 'Yvette'),
course.Student(6, 'Steph'),
course.Student(7, 'Draymond'),
course.Student(8, 'Andrew')]
new_course.enroll_students(students)
new_grouper = grouper.GreedyGrouper(2)
new_grouping = new_grouper.make_grouping(new_course, new_survey)
groups = new_grouping.get_groups()
temp_list = []
for i in range(0, len(groups)):
people = groups[i].get_members()
temp_list.extend(people)
if i == (len(groups) - 1):
assert len(groups[i]) <= 2
else:
assert len(groups[i]) == 2
course_students = new_course.get_students()
for student in course_students:
assert student in temp_list
assert len(temp_list) == 7
def test_course_class_course_all_answered() -> None:
s1 = course.Student(1, 'Misha')
courses = course.Course('CSC148')
courses.enroll_students([s1])
question = survey.YesNoQuestion(1, 'Do you like food?')
answer = survey.Answer(True)
s1.set_answer(question, answer)
surveys = survey.Survey([question])
assert courses.all_answered(surveys)
def test_get_answer(self) -> None:
student = course.Student(1, "Hermione")
# set answer
student.set_answer(self.question, self.answer)
student.set_answer(self.question2, self.wrong)
# get answer
assert student.get_answer(self.question) == self.answer
assert student.get_answer(self.question2) == self.wrong
assert student.get_answer(self.question3) is None
def test_has_answer(self) -> None:
student = course.Student(1, "Hermione")
# set answer
student.set_answer(self.question, self.answer)
student.set_answer(self.question2, self.wrong)
# has answer
assert student.has_answer(self.question)
assert not student.has_answer(self.question2)
assert not student.has_answer(self.question3)
def test_weight_crit(self):
stu = course.Student(0, "Shit0")
q = survey.YesNoQuestion(0, "Yue me?")
stu.set_answer(q, survey.Answer(True))
s = survey.Survey([q])
assert s.score_students([stu]) == 1.0
s.set_weight(5, q)
assert s.score_students([stu]) == 5.0
s.set_criterion(criterion.HeterogeneousCriterion(), q)
assert s.score_students([stu]) == 0.0
def test_windowgrouping() -> None:
ted = course.Student(1, "Ted")
fred = course.Student(2, "Fred")
jack = course.Student(3, "Jack")
bob = course.Student(4, "Bob")
course1 = course.Course("CSC148")
course1.enroll_students([ted, fred, jack, bob])
question1 = survey.YesNoQuestion(1, "Really?")
survey1 = survey.Survey([question1])
ted.set_answer(question1, survey.Answer(True))
fred.set_answer(question1, survey.Answer(False))
jack.set_answer(question1, survey.Answer(False))
bob.set_answer(question1, survey.Answer(True))
grouper1 = grouper.WindowGrouper(2)
grouping1 = grouper1.make_grouping(course1, survey1)
assert fred in grouping1.get_groups()[0]
assert jack in grouping1.get_groups()[0]
assert ted in grouping1.get_groups()[1]
assert bob in grouping1.get_groups()[1]
def test_survey_class_survey_score_grouping() -> None:
q1 = survey.NumericQuestion(1, "How many?", 0, 5)
q2 = survey.YesNoQuestion(2, 'Are you okay?')
survey1 = survey.Survey([q1, q2])
ted = course.Student(1, "Ted")
fred = course.Student(2, "Fred")
jack = course.Student(3, "Jack")
bob = course.Student(4, "Bob")
ted.set_answer(q1, survey.Answer(2))
fred.set_answer(q1, survey.Answer(3))
jack.set_answer(q1, survey.Answer(4))
bob.set_answer(q1, survey.Answer(1))
ted.set_answer(q2, survey.Answer(True))
fred.set_answer(q2, survey.Answer(True))
jack.set_answer(q2, survey.Answer(False))
bob.set_answer(q2, survey.Answer(False))
grouping1 = grouper.Grouping()
grouping1.add_group(grouper.Group([ted, fred]))
grouping1.add_group(grouper.Group([jack, bob]))
assert survey1.score_grouping(grouping1) == 0.8
class TestGroup:
s1 = course.Student(1, "gad")
s2 = course.Student(53, "floof")
s3 = course.Student(9, "gad")
s4 = course.Student(15, "blep")
s5 = course.Student(4, "meep")
members = [s1, s2, s3, s4]
def test_group_properties(self) -> None:
g = grouper.Group(self.members)
assert len(g) == 4
assert self.s4 in g
assert self.s5 not in g
assert str(g) == 'gad, floof, gad, blep.'
def test_get_members(self) -> None:
g = grouper.Group(self.members)
assert g.get_members()[2].id == 9
assert len(g.get_members()) == len(g)
def test_survey_class_survey_score_students_raise_invalidanswererror() -> None:
s1 = course.Student(1, 'Misha')
students = [s1]
question1 = survey.NumericQuestion(1, 'Do you like food?', 0, 10)
answer1 = survey.Answer(True)
survey1 = survey.Survey([question1])
criteria = criterion.HomogeneousCriterion()
weight1 = 1
s1.set_answer(question1, answer1)
survey1.set_weight(weight1, question1)
survey1.set_criterion(criteria, question1)
assert survey1.score_students(students) == 0.0
