def questions() -> List[survey.Question]:
q1 = survey.NumericQuestion(1, 'numeric 1', 5, 25)
q2 = survey.MultipleChoiceQuestion(2, ' Multiple Question 2', ['a', 'b'])
q3 = survey.CheckboxQuestion(3, ' Checkbox Question 3', ['X', 'Y'])
q4 = survey.YesNoQuestion(4, 'YesNoQuestion 4')
q5 = survey.NumericQuestion(1, 'numeric 5', 15, 250)
q6 = survey.MultipleChoiceQuestion(2, ' Multiple Question 6', ['a', 'b'])
q7 = survey.CheckboxQuestion(3, ' Checkbox Question 7', ['X', 'Y'])
q8 = survey.YesNoQuestion(4, 'YesNoQuestion 8')
return [q1, q2, q3, q4]
def test_str_multiples(self):
question = survey.MultipleChoiceQuestion(
1, "this is a question",
['option 1', 'option 2', 'option 3', 'option 4'])
assert "this is a question: possible answers are (1) option 1 " \
"(2) option 2 (3) option 3 (4) option 4 , " \
"(pick one)" == str(question)
def test_string(self) -> None:
q = survey.MultipleChoiceQuestion(1, "species?",
["human", 'bug', 'owl'])
s = str(q)
assert q.text in s
assert "human" in s
assert "owl" in s
def questions() -> List[survey.Question]:
return [
survey.MultipleChoiceQuestion(1, 'why?', ['a', 'b', 'c', 'd']),
survey.NumericQuestion(2, 'what?', -2, 4),
survey.YesNoQuestion(3, 'really?'),
survey.CheckboxQuestion(4, 'how?', ['a', 'b', 'c', 'd'])
]
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_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.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_multiple_choice(self):
m = survey.MultipleChoiceQuestion(0, "just choose", ["A", "B", "C"])
assert m.id == 0
assert m.text == 'just choose'
assert 'just choose' in str(m)
assert 'A' in str(m)
assert 'B' in str(m)
assert 'C' in str(m)
assert m.get_similarity(FakeAnswer2("X"), FakeAnswer2("X")) == 1.0
assert m.get_similarity(FakeAnswer2("X"), FakeAnswer2("Y")) == 0.0
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_grouper_class_grouping_get_groups_() -> None:
c1 = course.Course('CSC148')
s1 = course.Student(1, 'Ali')
s2 = course.Student(2, 'Kat')
s3 = course.Student(3, 'Dorsa')
s4 = course.Student(4, 'Sophia')
s5 = course.Student(5, 'Momo')
s6 = course.Student(6, 'Joseph')
c1.enroll_students([s1, s2, s3, s4, s5, s6])
a1 = grouper.AlphaGrouper(2)
q1 = survey.MultipleChoiceQuestion(1, 'What is your choice?',
['A', 'B', 'C'])
sur1 = survey.Survey([q1])
a1.make_grouping(c1, sur1)
assert len(a1.make_grouping(c1, sur1).get_groups()) == 3
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_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_multiple_choice(self):
q1 = survey.MultipleChoiceQuestion(0, "just choose", ["A", "B", "C"])
assert not q1.validate_answer(survey.Answer(1))
assert not q1.validate_answer(survey.Answer("E"))
assert not q1.validate_answer(survey.Answer(True))
assert not q1.validate_answer(survey.Answer(False))
assert not q1.validate_answer(survey.Answer(4))
assert not q1.validate_answer(survey.Answer(["A", "B", "C"]))
assert q1.validate_answer(survey.Answer("A"))
assert q1.validate_answer(survey.Answer("B"))
assert q1.validate_answer(survey.Answer("C"))
assert not survey.Answer(1).is_valid(q1)
assert not survey.Answer("E").is_valid(q1)
assert not survey.Answer(True).is_valid(q1)
assert not survey.Answer(False).is_valid(q1)
assert not survey.Answer(["A", "B", "C"]).is_valid(q1)
assert survey.Answer("A").is_valid(q1)
assert survey.Answer("B").is_valid(q1)
assert survey.Answer("C").is_valid(q1)
class TestSurvey:
q1 = survey.MultipleChoiceQuestion(1, "species?", ["human"])
q5 = survey.YesNoQuestion(5, "are you human?")
q3 = survey.CheckboxQuestion(3, "type?", ["fae"])
q4 = survey.NumericQuestion(4, "number of legs?", 1, 5)
q2 = survey.Question(2, "are you human?")
qs = [q1, q4, q3, q2, q3, q5] # list of questions
questions = [q1, q4, q3, q5]
def test_survey_properties(self) -> None:
s = survey.Survey(self.qs)
assert len(s) == 5
for q in self.qs:
assert q in s
def test_get_questions(self) -> None:
s = survey.Survey(self.questions)
descr = s.get_questions()
assert self.q1 in descr
assert self.q2 not in descr
assert self.q3 in descr
assert self.q4 in descr
assert self.q5 in descr
def test_set_weight(self) -> None:
s = survey.Survey(self.questions)
assert s.set_weight(2, self.q1)
assert s.set_weight(5, self.q5)
assert s.set_weight(-1, self.q3)
assert not s.set_weight(2, self.q2)
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_grouper_greedygrouper() -> None:
c1 = course.Course('CSC148')
s1 = course.Student(1, 'Ali')
s2 = course.Student(2, 'Kat')
s3 = course.Student(3, 'Dorsa')
s4 = course.Student(4, 'Sophia')
s5 = course.Student(5, 'Momo')
s6 = course.Student(6, 'Joseph')
c1.enroll_students([s1, s2, s3, s4, s5, s6])
a1 = grouper.GreedyGrouper(2)
q1 = survey.MultipleChoiceQuestion(1, 'What is your choice?',
['A', 'B', 'C'])
a = survey.Answer('A')
b = survey.Answer('B')
c = survey.Answer('C')
s1.set_answer(q1, a)
s2.set_answer(q1, b)
s3.set_answer(q1, c)
s4.set_answer(q1, a)
s5.set_answer(q1, b)
s6.set_answer(q1, c)
sur1 = survey.Survey([q1])
assert a1.make_grouping(c1, sur1).get_groups()[0].get_members()[0] == s1
assert a1.make_grouping(c1, sur1).get_groups()[2].get_members()[1] == s6
def test_survey_multiplechoice_question_get_similarity() -> None:
question = survey.MultipleChoiceQuestion(1, 'ABC?', ['A', 'B', 'C'])
assert question.get_similarity(survey.Answer('A'), survey.Answer('A'))\
== 1.0
assert question.get_similarity(survey.Answer('A'), survey.Answer('B'))\
== 0.0
def test_survey_multiplechoice_question_validate_answer() -> None:
question = survey.MultipleChoiceQuestion(1, 'ABC?', ['A', 'B', 'C'])
assert question.validate_answer(survey.Answer('A'))
assert not question.validate_answer(survey.Answer('G'))
def test_survey_multiplechoice_question__str__() -> None:
question1 = survey.MultipleChoiceQuestion(1, 'Who are you?',
['A', 'B', 'C'])
assert '1' and 'Who are you?' and 'A' and 'B' and 'C' in str(question1)
def test_mcq_properties(self) -> None:
q = survey.MultipleChoiceQuestion(1, "species?",
["human", 'bug', 'owl'])
assert q.id == 1
assert q.text == 'species?'
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]]
class TestGrouper:
q1 = survey.MultipleChoiceQuestion(1, "species?", ["human", 'bug', 'owl'])
q2 = survey.YesNoQuestion(2, "are you human?")
q3 = survey.CheckboxQuestion(3, "type?", ["chaotic", "evil", "neutral"])
q4 = survey.NumericQuestion(4, "number of legs?", 1, 8)
s = survey.Survey([q1, q2, q3, q4])
c = course.Course("Learning 101")
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_course_all_answered(self) -> None:
self.c.enroll_students(self.answer_questions())
assert self.c.all_answered(self.s)
def test_score_students(self) -> None:
self.c.enroll_students(self.answer_questions())
assert self.s.score_students(self.answer_questions()) \
== 0.34761904761904766
assert self.s.score_students(self.answer_questions()[:3]) \
== 0.3055555555555555
assert self.s.score_students(self.answer_questions()[2:4]) \
== 0.26785714285714285
def test_alpha_grouper(self) -> None:
self.c.enroll_students(self.answer_questions())
g = grouper.AlphaGrouper(3)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 2
assert gps[1].get_members()[1].id == 34
assert len(gps[1].get_members()) == 2
g = grouper.AlphaGrouper(2)
gps = g.make_grouping(self.c, self.s).get_groups()
assert gps[1].get_members()[1].id == 25 # number incorrect
assert len(gps) == 3
h = []
for group in gps:
h.extend(group.get_members())
for student in self.c.students:
assert student in h
def test_score_grouping(self) -> None:
self.c.enroll_students(self.answer_questions())
g = grouper.AlphaGrouper(3)
gps = g.make_grouping(self.c, self.s)
assert self.s.score_grouping(gps) == 0.3125
self.c.enroll_students(self.answer_questions())
g2 = grouper.GreedyGrouper(3)
gps2 = g2.make_grouping(self.c, self.s)
assert self.s.score_grouping(gps2) == 0.5892857142857143
def test_random_grouper(self) -> None:
self.c.enroll_students(self.answer_questions())
g = grouper.RandomGrouper(3)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 2
assert len(gps[1].get_members()) == 2
g = grouper.RandomGrouper(2)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 3
h = []
for group in gps:
h.extend(group.get_members())
for student in self.c.students:
assert student in h
def test_greedy_grouper(self) -> None:
self.c.enroll_students(self.answer_questions())
g = grouper.GreedyGrouper(3)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 2
assert gps[1].get_members()[1].id == 89
assert len(gps[1].get_members()) == 2
g = grouper.GreedyGrouper(2)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 3
assert gps[1].get_members()[1].id == 34
h = []
for group in gps:
h.extend(group.get_members())
for student in self.c.students:
assert student in h
def test_window_grouper(self) -> None:
self.c.enroll_students(self.answer_questions())
g = grouper.WindowGrouper(3)
gps = g.make_grouping(self.c, self.s).get_groups()
assert len(gps) == 2
assert gps[0].get_members()[1] == 9 # number incorrect
assert len(gps[1].get_members()) == 2
h = []
for group in gps:
h.extend(group.get_members())
for student in self.c.students:
assert student in h
def MCQuestion():
return survey.MultipleChoiceQuestion(1, "dinner", ["a", "b"])
