def criterions():
c1 = criterion.HomogeneousCriterion()
c2 = criterion.HeterogeneousCriterion()
c3 = criterion.LonelyMemberCriterion()
d1 = {"Homogeneous": c1, "Heterogeneous": c2, "LonelyMember": c3}
return d1
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 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_super_complicated(self):
students = [course.Student(i, "Shit" + str(i)) for i in range(8)]
q1 = survey.YesNoQuestion(0, "To be, or not to be")
q2 = survey.NumericQuestion(1, "How many times you f**k up", 0, 10000)
q3 = survey.MultipleChoiceQuestion(2, "What's your favorite thing to do", ['A', 'B', 'C', 'D'])
q4 = survey.CheckboxQuestion(3, "How many things you have done", ['A', 'B', 'C', 'D', 'E'])
questions = [q1, q2, q3, q4]
s = survey.Survey(questions)
answers = [True, 1111, 'A', ['A', 'C'],
False, 44, 'C', ['A', 'B', 'C'],
True, 3, 'B', ['A', 'C', 'D'],
True, 56, 'C', ['D', 'C'],
False, 12, 'C', ['E'],
True, 0, 'A', ['A'],
False, 888, 'C', ['A', 'B', 'C', 'D'],
True, 12, 'B', ['A', 'B', 'C', 'D', 'E']]
i = 0
for stu in students:
for q in questions:
stu.set_answer(q, survey.Answer(answers[i]))
i += 1
g = grouper.Grouping()
g.add_group(grouper.Group([students[0], students[1], students[2]]))
g.add_group(grouper.Group([students[3], students[4], students[5]]))
g.add_group(grouper.Group([students[6], students[7]]))
assert fuck_within(s.score_students(students), 0.5175303571428571)
assert fuck_within(s.score_grouping(g), 0.43715925925925925)
s.set_weight(2, q2)
s.set_weight(5, q1)
s.set_weight(6, q3)
s.set_weight(3, q4)
assert fuck_within(s.score_students(students), 1.7600607142857143)
assert fuck_within(s.score_grouping(g), 1.2696888888888889)
s.set_criterion(criterion.HeterogeneousCriterion(), q1)
s.set_criterion(criterion.HeterogeneousCriterion(), q2)
s.set_criterion(criterion.HeterogeneousCriterion(), q3)
s.set_criterion(criterion.HeterogeneousCriterion(), q4)
assert fuck_within(s.score_students(students), 2.2399392857142857)
assert fuck_within(s.score_grouping(g), 2.7303111111111114)
def test_heter_mc(self):
c = criterion.HeterogeneousCriterion()
q = survey.MultipleChoiceQuestion(0, "Shit", ["A", "B", "C"])
a1 = survey.Answer("A")
a2 = survey.Answer("B")
a3 = survey.Answer("C")
assert c.score_answers(q, [a1]) == 0.0, '''single answer should result in 0'''
assert c.score_answers(q, [a1, a2]) == 1
assert fuck_within(c.score_answers(q, [a1, a1, a1]), 0)
assert fuck_within(c.score_answers(q, [a1, a2, a1]), 1 - 0.33333)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a3]), 1 - 0.166666)
def test_score_studs_hetero(self, survey_with_YN_question, students,
YNQuestions):
crit = criterion.HeterogeneousCriterion()
for q in YNQuestions:
for stud in students:
ans = survey.Answer(False)
stud.set_answer(q, ans)
for q in survey_with_YN_question._ques:
survey_with_YN_question.set_criterion(crit, q)
for q in survey_with_YN_question._ques:
survey_with_YN_question.set_weight(0.5, q)
assert pytest.approx(
survey_with_YN_question.score_students(students)) == 0.0
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_score_grouping2(self, survey_with_NUMq, student_odd_ans, NumQ):
gr1 = grouper.Group([student_odd_ans[1], student_odd_ans[2]])
gr2 = grouper.Group([student_odd_ans[0], student_odd_ans[3]])
gr3 = grouper.Group([student_odd_ans[4]])
grouping = grouper.Grouping()
assert grouping.add_group(gr1)
assert grouping.add_group(gr2)
assert grouping.add_group(gr3)
assert survey_with_NUMq.set_criterion(
criterion.HeterogeneousCriterion(), NumQ)
assert survey_with_NUMq.set_weight(0.5, NumQ)
score_gr1 = survey_with_NUMq.score_students(gr1.get_members())
score_gr2 = survey_with_NUMq.score_students(gr2.get_members())
score_gr3 = survey_with_NUMq.score_students(gr3.get_members())
avg = sum([score_gr1, score_gr2, score_gr3]) / 3
assert survey_with_NUMq.score_grouping(grouping) == avg
def test_heter_numeric(self):
c = criterion.HeterogeneousCriterion()
q = survey.NumericQuestion(0, "OH Shit", 2, 8)
a1 = survey.Answer(2)
a2 = survey.Answer(5)
a3 = survey.Answer(7)
assert c.score_answers(q, [a1]) == 0.0, '''single answer should result in 0'''
assert fuck_within(c.score_answers(q, [a1, a2]), 0.5)
assert fuck_within(c.score_answers(q, [a1, a1, a2]), 0.33333333)
assert fuck_within(c.score_answers(q, [a1, a2, a3]), 0.55555555)
# This is to test you throw an exception when one answer is not valid
a4 = survey.Answer(10)
with pytest.raises(criterion.InvalidAnswerError) as info:
c.score_answers(q, [a4])
with pytest.raises(criterion.InvalidAnswerError) as info:
c.score_answers(q, [a1, a2, a4])
assert info
def test_criterion_heterogeneous_score_answers() -> None:
question = survey.YesNoQuestion(1, 'Do you like food?')
answers = [survey.Answer(True), survey.Answer(True), survey.Answer(False)]
criterions = criterion.HeterogeneousCriterion()
assert pytest.approx(criterions.score_answers(question, answers),
5) == 2 / 3
def test_set_criterion(self) -> None:
s = survey.Survey(self.questions)
assert s.set_criterion(criterion.LonelyMemberCriterion(), self.q1)
assert s.set_criterion(criterion.HeterogeneousCriterion(), self.q5)
assert not s.set_criterion(criterion.HomogeneousCriterion(), self.q2)
def test_heterogeneous(self) -> None:
het = criterion.HeterogeneousCriterion()
assert het.score_answers(self.question1, self.answers1) \
== 0.8333333333333334
assert het.score_answers(self.question2, self.answers2) \
== 0.6666666666666667
def test_combination(self):
students = [course.Student(i, "Shit" + str(i)) for i in range(8)]
q1 = survey.YesNoQuestion(0, "To be, or not to be")
q2 = survey.NumericQuestion(1, "How many times you f**k up", 0, 10000)
q3 = survey.MultipleChoiceQuestion(2, "What's your favorite thing to do", ['A', 'B', 'C', 'D'])
q4 = survey.CheckboxQuestion(3, "How many things you have done", ['A', 'B', 'C', 'D', 'E'])
questions = [q1, q2, q3, q4]
s = survey.Survey(questions)
answers = [True, 1111, 'A', ['A', 'C'],
False, 44, 'C', ['A', 'B', 'C'],
True, 3, 'B', ['A', 'C', 'D'],
True, 56, 'C', ['D', 'C'],
False, 12, 'C', ['E'],
True, 0, 'A', ['A'],
False, 888, 'C', ['A', 'B', 'C', 'D'],
True, 12, 'B', ['A', 'B', 'C', 'D', 'E']]
i = 0
for stu in students:
for q in questions:
stu.set_answer(q, survey.Answer(answers[i]))
i += 1
c = course.Course("Asshole101")
c.enroll_students(students)
grouping = grouper.AlphaGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
grouping = grouper.GreedyGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 2, 5], [1, 4, 6], [3, 7]]
grouping = grouper.WindowGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 4, 5], [1, 2, 3], [6, 7]]
s.set_criterion(criterion.HeterogeneousCriterion(), q2)
s.set_weight(2, q1)
s.set_weight(2, q1)
s.set_weight(3, q2)
s.set_weight(55, q4)
grouping = grouper.AlphaGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
grouping = grouper.GreedyGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 2, 6], [1, 3, 7], [4, 5]]
grouping = grouper.WindowGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4], [5, 6, 7]]
s.set_weight(2, q1)
s.set_weight(1, q2)
s.set_weight(5, q3)
s.set_weight(2, q4)
s.set_criterion(criterion.LonelyMemberCriterion(), q1)
s.set_criterion(criterion.LonelyMemberCriterion(), q2)
s.set_criterion(criterion.LonelyMemberCriterion(), q3)
s.set_criterion(criterion.LonelyMemberCriterion(), q4)
grouping = grouper.AlphaGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
grouping = grouper.GreedyGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 2, 5], [1, 4, 6], [3, 7]]
grouping = grouper.WindowGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
# make one of the student's answer invalid
students[0].set_answer(q1, survey.Answer('F**K'))
grouping = grouper.AlphaGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
grouping = grouper.GreedyGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 6], [5, 7]]
grouping = grouper.WindowGrouper(3).make_grouping(c, s)
assert len(grouping) == 3
assert grouping_to_list_of_list(grouping) == [[0, 1, 2], [3, 4, 5], [6, 7]]
def hetero():
return criterion.HeterogeneousCriterion()
def test_score_studs(self, survey_with_NUMq, NumQ, student_odd_ans):
assert survey_with_NUMq.set_criterion(
criterion.HeterogeneousCriterion(), NumQ)
assert survey_with_NUMq.set_weight(1, NumQ)
assert survey_with_NUMq.score_students(student_odd_ans) == 0.0
def test_criterion_heterogeneous_raise_invalidanswererror():
question = survey.NumericQuestion(1, 'Do you like food?', 0, 10)
answer = [survey.Answer(11)]
with pytest.raises(InvalidAnswerError):
criterion.HeterogeneousCriterion().score_answers(question, answer)
def criteria(answers) -> List[criterion.Criterion]:
return [
criterion.HomogeneousCriterion(),
criterion.HeterogeneousCriterion(),
criterion.LonelyMemberCriterion()
]
def test_score_ans(self, questions, answers):
q1 = survey.YesNoQuestion(1, 'hey')
h = criterion.HeterogeneousCriterion()
assert h.score_answers(q1, []) == 1.0