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 test_get_groups(self) -> None:
gping = grouper.Grouping()
assert gping.get_groups() == []
gping.add_group(grouper.Group(TestGroup.members))
gping.add_group(grouper.Group([TestGroup.s5]))
assert gping.get_groups()[1].get_members()[0] == TestGroup.s5
assert gping.get_groups()[0].get_members()[1] == TestGroup.s2
def window_grouping(students_with_answers) -> grouper.Grouping:
grouping = grouper.Grouping()
grouping.add_group(
grouper.Group([students_with_answers[0], students_with_answers[1]]))
grouping.add_group(
grouper.Group([students_with_answers[2], students_with_answers[3]]))
return grouping
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_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 AlphaGrouping_odd_len(student_odd_len):
gr1 = grouper.Group([student_odd_len[1], student_odd_len[2]])
gr2 = grouper.Group([student_odd_len[4], student_odd_len[3]])
gr3 = grouper.Group([student_odd_len[0]])
to_return = grouper.Grouping()
lst = [gr1, gr2, gr3]
for group in lst:
to_return.add_group(group)
return to_return
def test_make_grouping(self, course_with_students_with_answers, survey_,
WindowGrouper1, students):
gr1 = grouper.Group([students[0], students[1]])
gr2 = grouper.Group([students[2], students[3]])
grouping = grouper.Grouping()
assert grouping.add_group(gr1)
assert grouping.add_group(gr2)
funct = WindowGrouper1.make_grouping(course_with_students_with_answers,
survey_)
compare_groupings(grouping, funct)
def test_add_group(self, students):
new_grouping = grouper.Grouping()
group_list = grouper.windows(students, 2)
for group in group_list:
new_grouping.add_group(grouper.Group(group))
assert len(new_grouping) == 3
assert len(new_grouping._groups[len(new_grouping) - 1]) == 2
for group in group_list:
new_grouping.add_group(grouper.Group(group))
assert len(new_grouping) == 3
def test_make_grouping(self, RandomGrouper1, survey_, students,
course_with_students_with_answers):
gr1 = grouper.Group([students[0], students[1]])
gr2 = grouper.Group([students[2], students[3]])
grouping = grouper.Grouping()
grouping.add_group(gr1)
grouping.add_group(gr2)
assert len(grouping) == len(
RandomGrouper1.make_grouping(course_with_students_with_answers,
survey_))
def test_make_grouping1(self, RandomGrouper1, survey_with_NUMq,
student_odd_ans, course_with_student_odd):
gr1 = grouper.Group([student_odd_ans[0], student_odd_ans[1]])
gr2 = grouper.Group([student_odd_ans[2], student_odd_ans[3]])
gr3 = grouper.Group([student_odd_ans[4]])
grouping = grouper.Grouping()
grouping.add_group(gr1)
grouping.add_group(gr2)
grouping.add_group(gr3)
assert len(grouping) == len(
RandomGrouper1.make_grouping(course_with_student_odd,
survey_with_NUMq))
def test_make_grouping(self, student_odd_ans, course_with_student_odd,
GreedyGrouper2, survey_with_NUMq, NumQ):
survey_with_NUMq.set_weight(0.5, NumQ)
survey_with_NUMq.set_criterion(criterion.HomogeneousCriterion(), NumQ)
gr1 = grouper.Group(
[student_odd_ans[0], student_odd_ans[1], student_odd_ans[2]])
gr2 = grouper.Group([student_odd_ans[3], student_odd_ans[4]])
grouping = grouper.Grouping()
grouping.add_group(gr1)
grouping.add_group(gr2)
compare_groupings(
grouping,
GreedyGrouper2.make_grouping(course_with_student_odd,
survey_with_NUMq))
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_str(self, students):
new_grouping = grouper.Grouping()
group_list = grouper.slice_list(students, 2)
for group in group_list:
new_grouping.add_group(grouper.Group(group))
grouping_string = str(new_grouping)
for group in new_grouping.get_groups():
for student in group.get_members():
assert student.name in grouping_string
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_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
def test_add_group(self):
students = [course.Student(i, "Shit" + str(i)) for i in range(10)]
g = grouper.Grouping()
assert g.add_group(grouper.Group([students[0], students[1]]))
assert len(g) == 1
assert len(g.get_groups()) == 1
# you cannot add empty group
assert not g.add_group(grouper.Group([]))
assert len(g) == 1
assert len(g.get_groups()) == 1
# you cannot add group contains students already exist in group
assert not g.add_group(grouper.Group([students[1], students[2]]))
assert len(g) == 1
assert len(g.get_groups()) == 1
# you can add another group
assert g.add_group(grouper.Group([students[2], students[3]]))
assert len(g) == 2
assert len(g.get_groups()) == 2
members = [x.get_members() for x in g.get_groups()]
flat_list = [item for sublist in members for item in sublist]
ids = set([x.id for x in flat_list])
assert ids == {0, 1, 2, 3}
# you can add another group
assert g.add_group(grouper.Group([students[7], students[8]]))
assert len(g) == 3
assert len(g.get_groups()) == 3
members = [x.get_members() for x in g.get_groups()]
flat_list = [item for sublist in members for item in sublist]
ids = set([x.id for x in flat_list])
assert ids == {0, 1, 2, 3, 7, 8}
def groups(students):
group1 = grouper.Group(students[0:3])
group2 = grouper.Group(students[3:6])
group3 = grouper.Group(students[6:10])
return [group1, group2, group3]
def test_get_members(self, students) -> None:
new_group = grouper.Group(students)
group_members = new_group.get_members()
assert id(group_members) != id(new_group._members)
assert new_group.get_members() == group_members
def test_add_group(self) -> None:
gping = grouper.Grouping()
assert gping.add_group(grouper.Group(TestGroup.members))
assert not gping.add_group(grouper.Group(TestGroup.members[:2]))
assert gping.add_group(grouper.Group([TestGroup.s5]))
assert len(gping) == 2
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_get_groups(self, students) -> None:
group = grouper.Group(students[:2])
grouping = grouper.Grouping()
grouping.add_group(group)
assert get_member_ids(grouping) == {frozenset([1, 2])}
def test_len(self, students):
new_grouping = grouper.Grouping()
group_list = grouper.slice_list(students, 2)
for group in group_list:
new_grouping.add_group(grouper.Group(group))
assert len(new_grouping) == 4
def test_contains(self, students) -> None:
new_group = grouper.Group(students)
assert students[0] in new_group
assert students[6] in new_group
new_student = course.Student(12, 'George')
assert new_student not in new_group
def group1(students):
return grouper.Group([students[1], students[0]])
def group2(students):
return grouper.Group([students[2], students[3]])
def test_str(self, students) -> None:
new_group = grouper.Group(students)
assert students[0].name in str(new_group)
assert students[6].name in str(new_group)
def group(students) -> grouper.Group:
return grouper.Group(students)
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_len(self, students) -> None:
new_group = grouper.Group(students)
assert len(new_group) == 7
def test_len_longer_and_add_group(self, empty_grouping, group1):
assert empty_grouping.add_group(group1)
assert empty_grouping.add_group(group1) == False
assert empty_grouping.add_group(grouper.Group([])) == False
assert len(empty_grouping) == 1
