def test_lonely_numeric(self):
c = criterion.LonelyMemberCriterion()
q = survey.NumericQuestion(0, "OH Shit", 2, 8)
a1 = survey.Answer(2)
a2 = survey.Answer(5)
a3 = survey.Answer(7)
assert q.get_similarity(a1, a1) != 0.0
assert c.score_answers(q, [a1]) == 0.0, '''single answer should result in 0'''
assert c.score_answers(q, [a1, a2]) == 0.0
assert fuck_within(c.score_answers(q, [a1, a1, a1]), 1)
assert fuck_within(c.score_answers(q, [a1, a1, a2, a2]), 1)
assert fuck_within(c.score_answers(q, [a1, a2, a1]), 0)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a3]), 0)
assert fuck_within(c.score_answers(q, [a1, a1, a1, a2, a2]), 1)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a1, a2, a3]), 0)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a1, a2, a3, a3]), 1)
# This is to test you throw an exception when one answer is not valid
a4 = survey.Answer(10)
# first answer is invalid
with pytest.raises(criterion.InvalidAnswerError) as info:
c.score_answers(q, [a4, a1, a2])
assert info
# last answer is invalid
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, 'if you fail this test, maybe your code return too early'
def test_validate_answer(self, CheckQuestion, Checkboxq_ans):
assert CheckQuestion.validate_answer(Checkboxq_ans)
assert CheckQuestion.validate_answer(survey.Answer([])) == False
invalid_ans = survey.Answer(["c"])
assert CheckQuestion.validate_answer(invalid_ans) == False
invalid_ans_non_unique = survey.Answer(["a", "a"])
assert CheckQuestion.validate_answer(invalid_ans_non_unique) == False
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_validate_answer(self) -> None:
q = survey.NumericQuestion(4, "number of legs?", 1, 8)
a1 = survey.Answer(1)
a2 = survey.Answer(8)
a3 = survey.Answer(11)
assert q.validate_answer(a1)
assert q.validate_answer(a2)
assert not q.validate_answer(a3)
def test_similarity(self) -> None:
q = survey.NumericQuestion(4, "number of legs?", 1, 9)
a1 = survey.Answer(1)
a2 = survey.Answer(9)
a3 = survey.Answer(3)
assert q.get_similarity(a1, a2) == 0.0
assert q.get_similarity(a2, a3) == 0.25
assert q.get_similarity(a1, a3) == 0.75
def test_validate_answer(self) -> None:
q = survey.YesNoQuestion(44, "are you human?")
a1 = survey.Answer(True)
a2 = survey.Answer(False)
a3 = survey.Answer("yep")
assert q.validate_answer(a1)
assert q.validate_answer(a2)
assert not q.validate_answer(a3)
def test_score_answer(self, criterions, questions, answers):
c1 = criterions["LonelyMember"]
q1 = questions[1]
a1 = survey.Answer('a')
a2 = survey.Answer('b')
a3 = survey.Answer('a')
assert c1.score_answers(q1, [a1, a2, a3]) == 0.0
assert c1.score_answers(q1, [a1, a3]) == 1.0
def test_get_similarity(self) -> None:
q = survey.YesNoQuestion(44, "are you human?")
a1 = survey.Answer(True)
a2 = survey.Answer(False)
a3 = survey.Answer(False)
assert q.get_similarity(a1, a2) == 0.0
assert q.get_similarity(a2, a3) == 1.0
assert q.get_similarity(a1, a3) == 0.0
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_score_answer(self, criterions, questions, answers):
q1 = survey.MultipleChoiceQuestion(1, 'MC2', ['a', 'b'])
a1 = survey.Answer('a')
a2 = survey.Answer('b')
a3 = survey.Answer('a')
lst_ans = [a1, a2, a3]
c1 = criterions["Heterogeneous"]
assert c1.score_answers(q1, lst_ans) == (1 - 0.33)
def test_validate_answer(self) -> None:
q = survey.CheckboxQuestion(44, "type?",
["chaotic", "evil", "neutral"])
a1 = survey.Answer(["chaotic", "evil"])
a2 = survey.Answer(["evil", "neutral"])
a3 = survey.Answer(["neutral", "good"])
assert q.validate_answer(a1)
assert q.validate_answer(a2)
assert not q.validate_answer(a3)
def test_similarity(self) -> None:
q = survey.CheckboxQuestion(44, "type?",
["chaotic", "evil", "neutral"])
a1 = survey.Answer(["chaotic", "evil"])
a2 = survey.Answer(["evil", "neutral"])
a3 = survey.Answer(["neutral"])
assert q.get_similarity(a1, a2) == 0.3333333333333333
assert q.get_similarity(a2, a3) == 0.5
assert q.get_similarity(a1, a3) == 0.0
def test_criterion_homogeneous_raise_invalidanswererror():
question = survey.NumericQuestion(1, 'Do you like food?', 0, 10)
answer1 = [survey.Answer(11)]
answer2 = [survey.Answer(False)]
answer3 = [survey.Answer(5), survey.Answer(False)]
with pytest.raises(InvalidAnswerError):
criterion.HomogeneousCriterion().score_answers(question, answer1)
criterion.HomogeneousCriterion().score_answers(question, answer2)
criterion.HomogeneousCriterion().score_answers(question, answer3)
def lst_of_studs_with_answers_to_yn(students, YNQuestions):
true = survey.Answer(True)
false = survey.Answer(False)
for q in YNQuestions:
students[0].set_answer(q, true)
student[1].set_answer(q, false)
student[2].set_answer(q, true)
student[4].set_answer(q, false)
return students
def test_similarity(self) -> None:
q = survey.MultipleChoiceQuestion(1, "species?",
["human", 'bug', 'owl'])
a1 = survey.Answer("human")
a2 = survey.Answer("human")
a3 = survey.Answer("owl")
assert q.get_similarity(a1, a2) == 1.0
assert q.get_similarity(a2, a3) == 0.0
assert q.get_similarity(a1, a3) == 0.0
def test_get_similarity(NumQ):
ans1 = survey.Answer(1)
ans2 = survey.Answer(2)
dif = abs(1 - 2)
dif_div = dif / (10 - 1)
one_dif = 1.0 - dif_div
assert NumQ.get_similarity(ans1, ans2) == one_dif
ans10 = survey.Answer(10)
assert NumQ.get_similarity(ans1, ans10) == 0.0
assert NumQ.get_similarity(ans1, ans1) == 1.0
def test_get_similarity(self, questions, answers, students):
q1 = survey.CheckboxQuestion(1, 'C', ['a', 'b', 'c', 'd', 'e', 'f'])
a1 = survey.Answer(['a', 'b', 'c', 'd'])
a2 = survey.Answer(['e', 'b', 'c', 'f'])
a3 = survey.Answer(['a', 'b', 'c', 'd'])
a4 = survey.Answer(['g'])
assert q1.get_similarity(a1, a2) == 0.33
assert q1.get_similarity(a1, a3) == 1.0
assert q1.get_similarity(a1, a4) == 0.0
def test_validate_answer(self) -> None:
q = survey.MultipleChoiceQuestion(1, "species?",
["human", 'bug', 'owl'])
a1 = survey.Answer("human")
a2 = survey.Answer("bug")
a3 = survey.Answer("rip")
assert q.validate_answer(a1) == a1.is_valid(q)
assert q.validate_answer(a1)
assert q.validate_answer(a2)
assert not q.validate_answer(a3)
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_answer(self, criterions, questions, answers):
q1 = survey.MultipleChoiceQuestion(1, 'MC2', ['a', 'b', 'c', 'd'])
a1 = survey.Answer('a')
a2 = survey.Answer('b')
a3 = survey.Answer('a')
a4 = survey.Answer('c')
a5 = survey.Answer('b')
lst_ans = [a1, a2, a3]
lst_ans2 = []
c1 = criterions["Homogeneous"]
assert c1.score_answers(q1, lst_ans) == 0.33
def test_get_similarity(self, questions, answers, students):
q1 = survey.NumericQuestion(1, 'aa', 100, 200)
a1 = survey.Answer(111)
a2 = survey.Answer(98)
a3 = survey.Answer(123)
a4 = survey.Answer(111)
a5 = survey.Answer(201)
assert q1.get_similarity(a1, a4) == 1.0
assert q1.get_similarity(a1, a2) is False
assert q1.get_similarity(a1, a3) == 0.88
assert q1.get_similarity(a1, a5) is False
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_is_valid(self, questions, answers, students):
"""
:param questions:
:param answers:
:param students:
:return:
"""
q1 = questions[0]
q2 = questions[1]
q3 = questions[2]
q4 = questions[3]
a1 = answers[0][0]
a2 = answers[1][1]
a3 = answers[0][2]
a4 = survey.Answer(9)
stu1 = students[0]
stu1.set_answer(q1, a1)
stu2 = students[1]
stu2.set_answer(q2, a2)
stu3 = students[2]
stu3.set_answer(q3, a3)
stu4 = students[3]
stu4.set_answer(q4, a4)
assert a1.is_valid(q1)
assert a2.is_valid(q2)
assert a3.is_valid(q3)
assert a4.is_valid(q4) is False
def test_lonely_mc(self):
c = criterion.LonelyMemberCriterion()
q = survey.MultipleChoiceQuestion(0, "Shit", ["A", "B", "C"])
a1 = survey.Answer("A")
a2 = survey.Answer("B")
a3 = survey.Answer("C")
assert q.get_similarity(a1, a1) != 0.0
assert c.score_answers(q, [a1]) == 0.0, '''single answer should result in 0'''
assert c.score_answers(q, [a1, a2]) == 0.0
assert fuck_within(c.score_answers(q, [a1, a1, a1]), 1)
assert fuck_within(c.score_answers(q, [a1, a1, a2, a2]), 1)
assert fuck_within(c.score_answers(q, [a1, a2, a1]), 0)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a3]), 0)
assert fuck_within(c.score_answers(q, [a1, a1, a1, a2, a2]), 1)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a1, a2, a3]), 0)
assert fuck_within(c.score_answers(q, [a1, a2, a1, a1, a2, a3, a3]), 1)
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 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_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 answers() -> List[List[survey.Answer]]:
a1 = survey.Answer(7)
a2 = survey.Answer('a')
a3 = survey.Answer('X')
a4 = survey.Answer(True)
a5 = survey.Answer(8)
a6 = survey.Answer('b')
a7 = survey.Answer('Y')
a8 = survey.Answer(False)
return [[a1, a2, a3, a4], [a5, a6, a7, a8], [a1, a6, a7, a4],
[a5, a6, a7, a4]]
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]
