def test_case6(self): """Testing similarity function with 2 identical profiles (1)""" dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student4"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) self.assertEqual((f_stu,f_sup),(1,1))
def test_case8(self): """Testing similarity function between 2 less similar profiles """ dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student2"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) expected_fstu = 0.255645 expected_fsup = 0.522043 expected = (round(expected_fstu,6),round(expected_fsup,6)) retrieved = (round(f_stu,6),round(f_sup,6)) self.assertEqual(retrieved,expected)
def test_case5(self): """Testing similarity function with 2 non-similar profiles (0)""" dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student1"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) expected_fstu = 0.1217742 expected_fsup = 0.1416129 expected = (round(expected_fstu,6),round(expected_fsup,6)) retrieved = (round(f_stu,6),round(f_sup,6)) self.assertEqual(retrieved,expected)
class GATest(unittest.TestCase): def setUp(self): self.students, self.supervisors = createRandomData(4, 8, 18) # Generating rank weights for c = 0.5 self.rankWeights = Solution.calcRankWeights() #Creating fitness cache self.dummySolution = Solution() self.fitnessCache = {} for sup in self.supervisors: supervisorKeywords = self.supervisors[sup].getKeywords() for stu in self.students: studentKeywords = self.students[stu].getKeywords() f_stu, f_sup = self.dummySolution.kw_similarity( studentKeywords, supervisorKeywords, self.rankWeights) self.fitnessCache[str((stu, sup))] = (f_stu, f_sup) #Setting up the GA Object self.mutationOp = mutate self.selectionOp = tournamentSelection self.crossoverOp = crossover self.geneticAlgorithm = GeneticAlgorithm( self.students, self.supervisors, self.fitnessCache, self.rankWeights, self.mutationOp, self.crossoverOp, self.selectionOp) #Parameters for GA self.numberOfGenerations = 20 self.populationSize = 10 self.mutationProbability = 0.1 self.swapProbability = 0.3 self.transferProbability = 0.5 #Initializing population self.population = self.geneticAlgorithm.initializePopulation( self.populationSize) self.maxFst = max(self.population, key=lambda x: x.getFst()).getFst() self.minFst = min(self.population, key=lambda x: x.getFst()).getFst() self.maxFsup = max(self.population, key=lambda x: x.getFsup()).getFsup() self.minFsup = min(self.population, key=lambda x: x.getFsup()).getFsup() def test_case1(self): """Testing the initalize population function - size of 10""" pop = self.geneticAlgorithm.initializePopulation(10) result = True for sol in pop: if not (isinstance(sol, Solution)): result = False if len(pop) != 10: result = False self.assertTrue(result) def test_case2(self): """Testing the fast non-dominated sort function""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) fronts = self.geneticAlgorithm.fast_non_dominated_sort(pop) expectedFront0 = [pop[5]] expectedFront1 = [pop[3], pop[4]] expectedFront2 = [pop[0], pop[2], pop[6]] expectedFront3 = [pop[1]] expected = [ expectedFront0, expectedFront1, expectedFront2, expectedFront3 ] result = True for i in range(len(expected)): for sol in expected[i]: if sol not in fronts[i]: result = False self.assertTrue(result) def test_case3(self): """Testing the crowding distance assignment""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) maxFst = max(pop, key=lambda x: x.getFst()).getFst() minFst = min(pop, key=lambda x: x.getFst()).getFst() maxFsup = max(pop, key=lambda x: x.getFsup()).getFsup() minFsup = min(pop, key=lambda x: x.getFsup()).getFsup() self.geneticAlgorithm.crowding_distance_assignment( pop, maxFst, minFst, maxFsup, minFsup) expected = [ float("inf"), 0.9, 0.375, 0.975, float("inf"), float("inf"), 0.525 ] result = [round(sol.crowdingDistance, 5) for sol in pop] self.assertEqual(result, expected) def test_case4(self): """Testing the crowding distance assignment function - when only 1 element in frontier""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) maxFst = max(pop, key=lambda x: x.getFst()).getFst() minFst = min(pop, key=lambda x: x.getFst()).getFst() maxFsup = max(pop, key=lambda x: x.getFsup()).getFsup() minFsup = min(pop, key=lambda x: x.getFsup()).getFsup() self.geneticAlgorithm.crowding_distance_assignment([pop[0]], maxFst, minFst, maxFsup, minFsup) expected = [float("inf")] result = [round(sol.crowdingDistance, 5) for sol in [pop[0]]] self.assertEqual(result, expected) def test_case5(self): """Testing the crowding distance assignment function - when only 2 element in frontier""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) maxFst = max(pop, key=lambda x: x.getFst()).getFst() minFst = min(pop, key=lambda x: x.getFst()).getFst() maxFsup = max(pop, key=lambda x: x.getFsup()).getFsup() minFsup = min(pop, key=lambda x: x.getFsup()).getFsup() self.geneticAlgorithm.crowding_distance_assignment( pop[0:2], maxFst, minFst, maxFsup, minFsup) expected = [float("inf"), float("inf")] result = [round(sol.crowdingDistance, 5) for sol in pop[0:2]] self.assertEqual(result, expected) def test_case6(self): """Testing the crowding distance assignment function - when only 3 element in frontier""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) maxFst = max(pop, key=lambda x: x.getFst()).getFst() minFst = min(pop, key=lambda x: x.getFst()).getFst() maxFsup = max(pop, key=lambda x: x.getFsup()).getFsup() minFsup = min(pop, key=lambda x: x.getFsup()).getFsup() self.geneticAlgorithm.crowding_distance_assignment( pop[0:3], maxFst, minFst, maxFsup, minFsup) expected = [float("inf"), float("inf"), float("inf")] result = [round(sol.crowdingDistance, 5) for sol in pop[0:3]] self.assertEqual(result, expected) def test_case7(self): """Testing the crowding distance assignment function - when only 4 element in frontier""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) maxFst = max(pop, key=lambda x: x.getFst()).getFst() minFst = min(pop, key=lambda x: x.getFst()).getFst() maxFsup = max(pop, key=lambda x: x.getFsup()).getFsup() minFsup = min(pop, key=lambda x: x.getFsup()).getFsup() self.geneticAlgorithm.crowding_distance_assignment( pop[0:4], maxFst, minFst, maxFsup, minFsup) expected = [float("inf"), float("inf"), 0.9, float("inf")] result = [round(sol.crowdingDistance, 5) for sol in pop[0:4]] self.assertEqual(result, expected) def test_case8(self): """Tesitng make new Population function""" fronts = self.geneticAlgorithm.fast_non_dominated_sort(self.population) self.geneticAlgorithm.crowding_distance_assignment( self.population, self.maxFst, self.minFst, self.maxFsup, self.minFsup) newPop = self.geneticAlgorithm.makeNewPopulation( self.population, self.populationSize, self.mutationProbability, self.swapProbability, self.transferProbability) result = True for sol in newPop: if not (isinstance(sol, Solution)): result = False if len(newPop) != ((self.populationSize) + (self.populationSize // 2)): result = False self.assertTrue(result) def test_case9(self): """Testing the calc Spacing Metric function - when 2 elements in frontier""" pop = self.geneticAlgorithm.initializePopulation(2) points = [(25, 0.6), (27, 0.2)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) result = calcSpacing(pop) self.assertEqual(result, 0) def test_case10(self): """Testing the calc Spacing Metric function - when multiple elements in frontier""" pop = self.geneticAlgorithm.initializePopulation(7) points = [(25, 0.6), (27, 0.2), (27, 0.5), (29, 0.8), (30, 0.1), (30, 0.9), (27, 0.5)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) result = calcSpacing(pop) expected = 0.683927116 self.assertAlmostEqual(result, expected, places=5) def test_case11(self): """Testing the calc Spacing Metric function - when 1 element in frontier""" pop = self.geneticAlgorithm.initializePopulation(1) points = [(25, 0.6)] for i, sol in enumerate(pop): sol.setFst(points[i][0]) sol.setFsup(points[i][1]) result = calcSpacing(pop) self.assertEqual(result, 0) def test_case12(self): """Testing the calc Spacing Metric function - when 0 elements in frontier""" pop = self.geneticAlgorithm.initializePopulation(0) result = calcSpacing(pop) self.assertEqual(result, 0)
class MutationTest(unittest.TestCase): def setUp(self): #Creating a list of students and supervisors topicNames, topicPaths, topicIDs, levels = parseFile( "pystsup/test/acm.txt") self.supervisors = {} self.students = {} stuID = "student" supID = "supervisor" stuList1 = [ "MapReduce-based systems", "Multidimensional range search", "Open source software", "Data mining", "Online shopping" ] stuList2 = [ "Heuristic function construction", "Multi-agent systems", "Open source software", "Data mining", "Speech recognition" ] stuList3 = [ "Multi-agent systems", "Speech recognition", "Heuristic function construction", "Data mining", "Object identification" ] stuList4 = [ "Multi-agent systems", "Intelligent agents", "Speech recognition", "Object identification", "Heuristic function construction" ] supList1 = [ "Multi-agent systems", "Intelligent agents", "MapReduce-based systems", "Object identification", "Heuristic function construction" ] supList2 = [ "Open source software", "Data mining", "Speech recognition", "Object identification", "Heuristic function construction" ] supList3 = [ "Multi-agent systems", "Intelligent agents", "Speech recognition", "Object identification", "Heuristic function construction" ] supList = [supList1, supList2, supList3] supQuota = [2, 2, 1] stuList = [stuList1, stuList2, stuList3, stuList4] for i in range(3): toAdd = [] sup_list = {} rank = 0 for kw in supList[i]: rank += 1 sup_list[rank] = [ kw, getPath(kw, topicNames, topicPaths, topicIDs) ] sup = supID + str(i + 1) quota = supQuota[i] supervisorObject = Supervisor(sup, sup_list, quota) self.supervisors[sup] = supervisorObject for i in range(4): toAdd = [] stu_list = {} rank = 0 for kw in stuList[i]: rank += 1 stu_list[rank] = [ kw, getPath(kw, topicNames, topicPaths, topicIDs) ] stu = stuID + str(i + 1) studentObject = Student(stu, stu_list) self.students[stu] = studentObject # Generating rank weights for c = 0.5 self.rankWeights = Solution.calcRankWeights() #Creating fitness cache self.dummySolution = Solution() self.fitnessCache = {} for sup in self.supervisors: supervisorKeywords = self.supervisors[sup].getKeywords() for stu in self.students: studentKeywords = self.students[stu].getKeywords() f_stu, f_sup = self.dummySolution.kw_similarity( studentKeywords, supervisorKeywords, self.rankWeights) self.fitnessCache[str((stu, sup))] = (f_stu, f_sup) # Creating two graphs and solutions self.graph1 = BipartiteGraph() self.graph2 = BipartiteGraph() self.graph1.addEdge("supervisor1", "student2") self.graph1.addEdge("supervisor2", "student4") self.graph1.addEdge("supervisor3", "student1") self.graph1.addEdge("supervisor1", "student3") self.solution1 = Solution(self.graph1) self.graph2.addEdge("supervisor1", "student2") self.graph2.addEdge("supervisor2", "student1") self.graph2.addEdge("supervisor3", "student4") self.graph2.addEdge("supervisor1", "student3") self.solution2 = Solution(self.graph2) def test_case1(self): """Testing mutation function for solution 1""" mutationProbability = 0.3 swapProbability = 0.5 transferProbability = 0.5 solution3 = mutate(self.solution1, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case2(self): """Testing mutation function for solution 1 - only swap operation""" mutationProbability = 0.3 swapProbability = 0.5 transferProbability = 0 solution3 = mutate(self.solution1, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case3(self): """Testing mutation function for solution 1 - only transfer operation""" mutationProbability = 0.3 swapProbability = 0 transferProbability = 0.5 solution3 = mutate(self.solution1, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case4(self): """Testing mutation function for solution 2""" mutationProbability = 0.3 swapProbability = 0.5 transferProbability = 0.3 solution4 = mutate(self.solution2, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution4.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case5(self): """Testing mutation function for a randomly created solution 1""" mutationProbability = 0.3 swapProbability = 0.2 transferProbability = 0.8 solution1 = Solution.generateRandomSolution(self.students, self.supervisors) solution2 = mutate(solution1, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution2.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case6(self): """Testing mutation function for a randomly created solution 2""" mutationProbability = 0.3 swapProbability = 0.7 transferProbability = 0 solution1 = Solution.generateRandomSolution(self.students, self.supervisors) solution2 = mutate(solution1, self.supervisors, mutationProbability, swapProbability, transferProbability) result = solution2.isValid(self.students, self.supervisors) self.assertTrue(result)
class CrossoverTest(unittest.TestCase): def setUp(self): #Creating a list of students and supervisors topicNames, topicPaths, topicIDs, levels = parseFile( "pystsup/test/acm.txt") self.supervisors = {} self.students = {} stuID = "student" supID = "supervisor" stuList1 = [ "MapReduce-based systems", "Multidimensional range search", "Open source software", "Data mining", "Online shopping" ] stuList2 = [ "Heuristic function construction", "Multi-agent systems", "Open source software", "Data mining", "Speech recognition" ] stuList3 = [ "Multi-agent systems", "Speech recognition", "Heuristic function construction", "Data mining", "Object identification" ] stuList4 = [ "Multi-agent systems", "Intelligent agents", "Speech recognition", "Object identification", "Heuristic function construction" ] supList1 = [ "Multi-agent systems", "Intelligent agents", "MapReduce-based systems", "Object identification", "Heuristic function construction" ] supList2 = [ "Open source software", "Data mining", "Speech recognition", "Object identification", "Heuristic function construction" ] supList3 = [ "Multi-agent systems", "Intelligent agents", "Speech recognition", "Object identification", "Heuristic function construction" ] supList = [supList1, supList2, supList3] supQuota = [2, 2, 1] stuList = [stuList1, stuList2, stuList3, stuList4] for i in range(3): toAdd = [] sup_list = {} rank = 0 for kw in supList[i]: rank += 1 sup_list[rank] = [ kw, getPath(kw, topicNames, topicPaths, topicIDs) ] sup = supID + str(i + 1) quota = supQuota[i] supervisorObject = Supervisor(sup, sup_list, quota) self.supervisors[sup] = supervisorObject for i in range(4): toAdd = [] stu_list = {} rank = 0 for kw in stuList[i]: rank += 1 stu_list[rank] = [ kw, getPath(kw, topicNames, topicPaths, topicIDs) ] stu = stuID + str(i + 1) studentObject = Student(stu, stu_list) self.students[stu] = studentObject # Generating rank weights for c = 0.5 self.rankWeights = Solution.calcRankWeights() #Creating fitness cache self.dummySolution = Solution() self.fitnessCache = {} for sup in self.supervisors: supervisorKeywords = self.supervisors[sup].getKeywords() for stu in self.students: studentKeywords = self.students[stu].getKeywords() f_stu, f_sup = self.dummySolution.kw_similarity( studentKeywords, supervisorKeywords, self.rankWeights) self.fitnessCache[str((stu, sup))] = (f_stu, f_sup) # Creating two graphs and solutions self.graph1 = BipartiteGraph() self.graph2 = BipartiteGraph() self.graph1.addEdge("supervisor1", "student2") self.graph1.addEdge("supervisor2", "student4") self.graph1.addEdge("supervisor3", "student1") self.graph1.addEdge("supervisor1", "student3") self.solution1 = Solution(self.graph1) self.graph2.addEdge("supervisor1", "student2") self.graph2.addEdge("supervisor2", "student1") self.graph2.addEdge("supervisor3", "student4") self.graph2.addEdge("supervisor1", "student3") self.solution2 = Solution(self.graph2) # Creating test for simplify function self.graph3 = BipartiteGraph() self.graph3.addEdge("s1", "st1") self.graph3.addEdge("s1", "st4") self.graph3.addEdge("s2", "st1") self.graph3.addEdge("s2", "st2") self.graph3.addEdge("s3", "st3") self.graph3.addEdge("s3", "st5") self.graph3.addEdge("s4", "st3") self.graph3.addEdge("s4", "st5") self.structure3 = {"s1": 2, "s2": 1, "s3": 1, "s4": 1} self.graph4 = BipartiteGraph() self.graph4.addEdge("s1", "st1") self.graph4.addEdge("s1", "st3") self.graph4.addEdge("s1", "st4") self.graph4.addEdge("s2", "st3") self.graph4.addEdge("s2", "st4") self.graph4.addEdge("s3", "st1") self.graph4.addEdge("s3", "st2") self.structure4 = {"s1": 1, "s2": 2, "s3": 1} #Creating 60-400 data set self.students2, self.supervisors2 = createRandomData(60, 400, 405) # m,n,quotaSum,level=3,maxQuota=10,minQuota=4,no_topics=5 self.students3, self.supervisors3 = createRandomData(3, 5, 8, minQuota=1, maxQuota=3) self.problem_instances = [ #createRandomData(6,10,16,minQuota=1) createRandomData(60, 400, 405) ] #def test_case_special_cr(self): #for (students,supervisors) in self.problem_instances : #for i in range(100): # sol1 = Solution.generateRandomSolution(students,supervisors) # sol2 = Solution.generateRandomSolution(students,supervisors) # sp_crossover(sol1,sol2) def test_case_simplify1(self): response, already_set = simplify(self.graph3, self.structure3) self.assertTrue(("s1", "st1") in response) self.assertTrue(("s1", "st4") in response) self.assertTrue(("s2", "st2") in response) self.assertEqual(self.structure3["s1"], 0) self.assertEqual(self.structure3["s2"], 0) self.assertEqual(self.structure3["s3"], 1) self.assertEqual(self.structure3["s4"], 1) self.assertTrue(("stu", "st1") in already_set) self.assertTrue(("stu", "st4") in already_set) self.assertTrue(("stu", "st2") in already_set) self.assertTrue(("sup", "s1") in already_set) self.assertTrue(("sup", "s2") in already_set) self.assertEqual(len(response), 3) def test_case_simplify2(self): response, already_set = simplify(self.graph4, self.structure4) self.assertTrue(("s1", "st1") in response) self.assertTrue(("s2", "st3") in response) self.assertTrue(("s2", "st4") in response) self.assertTrue(("s3", "st2") in response) self.assertEqual(self.structure4["s1"], 0) self.assertEqual(self.structure4["s2"], 0) self.assertEqual(self.structure4["s3"], 0) self.assertTrue(("stu", "st1") in already_set) self.assertTrue(("stu", "st3") in already_set) self.assertTrue(("stu", "st4") in already_set) self.assertTrue(("stu", "st2") in already_set) self.assertTrue(("sup", "s1") in already_set) self.assertTrue(("sup", "s2") in already_set) self.assertTrue(("sup", "s3") in already_set) self.assertEqual(len(response), 4) def test_case1(self): """Testing the ERX Modified Crossover function - for 3sup:4stu solution""" solution3 = crossover(self.solution1, self.solution2, self.supervisors, self.students) structureResult = (solution3.getGraph().getStructure() == self.solution1.getGraph().getStructure()) or ( solution3.getGraph().getStructure() == self.solution2.getGraph().getStructure()) result = (solution3.isValid(self.students, self.supervisors)) and (structureResult) self.assertTrue(result) def test_case2(self): """Testing the kPoint crossover function - for 3sup:4stu solution""" solution3 = kPoint(self.solution1, self.solution2, self.supervisors, self.students, k=3) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case3(self): """Testing the EDX Modified crossover function - when one valid and one dummy solution are passed""" self.assertRaises( KeyError, lambda: crossover(self.solution1, self.dummySolution, self.supervisors, self.students)) def test_case4(self): """Testing the K Point Crossover function - when one valid and one dummy solution are passed""" self.assertRaises( KeyError, lambda: kPoint(self.solution2, self.dummySolution, self.supervisors, self.students, k=3)) def test_case5(self): """Testing the ERX Modified Crossover function - for random 3sup:4stu solution""" solution1 = Solution.generateRandomSolution(self.students, self.supervisors) solution2 = Solution.generateRandomSolution(self.students, self.supervisors) solution3 = crossover(solution1, solution2, self.supervisors, self.students) structureResult = (solution3.getGraph().getStructure() == solution1.getGraph().getStructure()) or ( solution3.getGraph().getStructure() == solution2.getGraph().getStructure()) result = (solution3.isValid(self.students, self.supervisors)) and (structureResult) self.assertTrue(result) def test_case6(self): """Testing the K Point Crossover function - for random 3sup:4stu solution""" solution1 = Solution.generateRandomSolution(self.students, self.supervisors) solution2 = Solution.generateRandomSolution(self.students, self.supervisors) solution3 = kPoint(solution1, solution2, self.supervisors, self.students, k=3) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case7(self): """Testing the K Point crossover function - when k=0""" solution3 = kPoint(self.solution1, self.solution2, self.supervisors, self.students, k=0) structureResult = (solution3.getGraph().getStructure() == self.solution1.getGraph().getStructure()) or ( solution3.getGraph().getStructure() == self.solution2.getGraph().getStructure()) result = (solution3.isValid(self.students, self.supervisors)) and (structureResult) self.assertTrue(result) def test_case8(self): """Testing the K Point crossover function - when k=1""" solution3 = kPoint(self.solution1, self.solution2, self.supervisors, self.students, k=1) result = solution3.isValid(self.students, self.supervisors) self.assertTrue(result) def test_case9(self): """Testing the K Point crossover function - when k > no_students""" self.assertRaises( ValueError, lambda: kPoint(self.solution1, self.solution2, self.supervisors, self.students, k=6)) def test_case10(self): """Testing the ERX Modified crossover function - for random 60sup:400stu solution""" solution1 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution2 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution3 = crossover(solution1, solution2, self.supervisors2, self.students2) structureResult = (solution3.getGraph().getStructure() == solution1.getGraph().getStructure()) or ( solution3.getGraph().getStructure() == solution2.getGraph().getStructure()) result = (solution3.isValid(self.students2, self.supervisors2)) and (structureResult) self.assertTrue(result) def test_case11(self): """Testing the ERX Modified crossover function - for random 60sup:400stu solution""" solution1 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution2 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution3 = crossover(solution1, solution2, self.supervisors, self.supervisors2, self.students2) structureResult = (solution3.getGraph().getStructure() == solution1.getGraph().getStructure()) or ( solution3.getGraph().getStructure() == solution2.getGraph().getStructure()) result = (solution3.isValid(self.students2, self.supervisors2)) and (structureResult) self.assertTrue(result) def test_case12(self): """Testing the kPoint crossover function - for random 60sup:400stu solution""" solution1 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution2 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution3 = kPoint(solution1, solution2, self.supervisors2, self.students2, k=15) result = solution3.isValid(self.students2, self.supervisors2) self.assertTrue(result) def test_case13(self): """Testing the kPoint crossover function - for random 60sup:400stu solution""" solution1 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution2 = Solution.generateRandomSolution(self.students2, self.supervisors2) solution3 = kPoint(solution1, solution2, self.supervisors2, self.students2, k=15) result = solution3.isValid(self.students2, self.supervisors2) self.assertTrue(result)
class SolutionTest(unittest.TestCase): def setUp(self): #Creating a list of students and supervisors topicNames,topicPaths, topicIDs, levels = parseFile("pystsup/test/acm.txt") self.supervisors = {} self.students = {} stuID = "student" supID = "supervisor" stuList1 = ["MapReduce-based systems","Multidimensional range search","Open source software","Data mining","Online shopping"] stuList2 = ["Heuristic function construction","Multi-agent systems","Open source software","Data mining","Speech recognition"] stuList3 = ["Multi-agent systems","Speech recognition","Heuristic function construction","Data mining","Object identification"] stuList4 = ["Multi-agent systems","Intelligent agents","Speech recognition","Object identification","Heuristic function construction"] supList1 = ["Multi-agent systems","Intelligent agents","MapReduce-based systems","Object identification","Heuristic function construction"] supList2 = ["Open source software","Data mining","Speech recognition","Object identification","Heuristic function construction"] supList3 = ["Multi-agent systems","Intelligent agents","Speech recognition","Object identification","Heuristic function construction"] supList = [supList1,supList2,supList3] supQuota = [2,2,1] stuList = [stuList1,stuList2,stuList3,stuList4] for i in range(3): toAdd = [] sup_list = {} rank = 0 for kw in supList[i]: rank+=1 sup_list[rank]=[kw,getPath(kw,topicNames,topicPaths, topicIDs)] sup = supID + str(i+1) quota = supQuota[i] supervisorObject = Supervisor(sup,sup_list,quota) self.supervisors[sup]=supervisorObject for i in range(4): toAdd = [] stu_list = {} rank = 0 for kw in stuList[i]: rank+=1 stu_list[rank] = [kw,getPath(kw,topicNames,topicPaths, topicIDs)] stu = stuID + str(i+1) studentObject = Student(stu,stu_list) self.students[stu]=studentObject # Generating rank weights for c = 0.5 self.rankWeights = Solution.calcRankWeights() #Creating fitness cache self.dummySolution = Solution() self.fitnessCache = {} for sup in self.supervisors: supervisorKeywords = self.supervisors[sup].getKeywords() for stu in self.students: studentKeywords = self.students[stu].getKeywords() f_stu,f_sup = self.dummySolution.kw_similarity(studentKeywords,supervisorKeywords, self.rankWeights) self.fitnessCache[str((stu,sup))] = (f_stu,f_sup) # Creating two graphs and solutions self.graph1 = BipartiteGraph() self.graph2 = BipartiteGraph() self.graph1.addEdge("supervisor1","student2") self.graph1.addEdge("supervisor2","student4") self.graph1.addEdge("supervisor3","student1") self.graph1.addEdge("supervisor1","student3") self.solution1 = Solution(self.graph1) self.graph2.addEdge("supervisor1","student2") self.graph2.addEdge("supervisor2","student1") self.graph2.addEdge("supervisor3","student4") self.graph2.addEdge("supervisor1","student3") self.solution2 = Solution(self.graph2) def test_case1(self): """Testing the create random solution function""" solution1 = Solution.generateRandomSolution(self.students,self.supervisors) result = solution1.isValid(self.students,self.supervisors) self.assertEqual(result,True) def test_case2(self): """Testing the calculate Rank Weights function when c = 1""" rankWeights = Solution.calcRankWeights(c=1) result = True expected = 0.2 for i in rankWeights: if rankWeights[i] != expected: result = False break self.assertTrue(result) def test_case3(self): """Testing the calculate rank weights function when c = 0.3""" rankWeights = Solution.calcRankWeights(c=0.3) result = round(sum(rankWeights.values()),15) expected = {1: 0.701705143, 2: 0.210511543, 3: 0.063153463, 4: 0.0189460389, 5: 0.005683812} result2 = True for i in rankWeights: if round(rankWeights[i],8) != round(expected[i],8): result2 = False break self.assertEqual((result,result2),(1,True)) def test_case4(self): """Testing the calculate rank weights function when c=0 and n=0""" rankWeights = Solution.calcRankWeights(c=0,n=0) expected = {} self.assertEqual(rankWeights,expected) def test_case5(self): """Testing similarity function with 2 non-similar profiles (0)""" dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student1"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) expected_fstu = 0.1217742 expected_fsup = 0.1416129 expected = (round(expected_fstu,6),round(expected_fsup,6)) retrieved = (round(f_stu,6),round(f_sup,6)) self.assertEqual(retrieved,expected) def test_case6(self): """Testing similarity function with 2 identical profiles (1)""" dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student4"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) self.assertEqual((f_stu,f_sup),(1,1)) def test_case7(self): """Testing similarity function between 2 mostly similar profiles """ dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student3"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) expected_fstu = 0.708333 expected_fsup = 0.726882 expected = (round(expected_fstu,6),round(expected_fsup,6)) retrieved = (round(f_stu,6),round(f_sup,6)) self.assertEqual(retrieved,expected) def test_case8(self): """Testing similarity function between 2 less similar profiles """ dummySolution = Solution() supervisorKeywords = self.supervisors["supervisor3"].getKeywords() studentKeywords = self.students["student2"].getKeywords() f_stu,f_sup = dummySolution.kw_similarity(studentKeywords,supervisorKeywords,self.rankWeights) expected_fstu = 0.255645 expected_fsup = 0.522043 expected = (round(expected_fstu,6),round(expected_fsup,6)) retrieved = (round(f_stu,6),round(f_sup,6)) self.assertEqual(retrieved,expected) def test_case9(self): """Testing intersection function - between 2 non-intersecting lists""" list1 = self.supervisors["supervisor1"].getKeywords()[1][1] list2 = self.students["student1"].getKeywords()[1][1] result = self.dummySolution._intersection(list1,list2) self.assertEqual(result,1) def test_case10(self): """Testing intersection function - between 2 lists with 1 common element""" list1 = ["Document types","General and reference"] list2 = ["Cross-computing tools and techniques","General and reference"] result = self.dummySolution._intersection(list1,list2) self.assertEqual(result,1) def test_case11(self): """Testing intersection function - between 2 lists with 2 common element""" list1 = ["Reference works","Document types","General and reference"] list2 = ["Surveys and overviews","Document types","General and reference"] result = self.dummySolution._intersection(list1,list2) self.assertEqual(result,2) def test_case12(self): """Testing intersection function - between 2 lists with 3 common element""" list1 = ["Digital signal processing","Signal processing systems","Communication hardware, interfaces and storage","Hardware"] list2 = ["Beamforming","Signal processing systems","Communication hardware, interfaces and storage","Hardware"] result = self.dummySolution._intersection(list1,list2) self.assertEqual(result,3) def test_case13(self): """Testing intersection function - between 2 identical lists""" list1 = self.supervisors["supervisor1"].getKeywords()[1][1] list2 = self.students["student4"].getKeywords()[1][1] result = self.dummySolution._intersection(list1,list2) self.assertEqual(result,5) def test_case14(self): """Testing the calc fitness function for a bad solution""" self.solution1.calcFitness(self.students,self.supervisors,self.rankWeights,self.fitnessCache) F_st = self.solution1.getFst() F_sup = self.solution1.getFsup() retrieved = (round(F_sup,6),round(F_st,6)) expected = (0.600813,1.457903) self.assertEqual(retrieved,expected) def test_case15(self): """Testing the calc fitness function for a fairly good solution""" self.solution2.calcFitness(self.students,self.supervisors,self.rankWeights,self.fitnessCache) F_st = self.solution2.getFst() F_sup = self.solution2.getFsup() retrieved = (round(F_sup,7),round(F_st,7)) expected = (1.1482502,2.1678495) self.assertEqual(retrieved,expected) def test_case16(self): """Testing transfer function - a valid transfer""" self.solution1.transferStudent("student3","supervisor1","supervisor2",self.supervisors) solutionGraph = self.solution1.getGraph() val1 = solutionGraph.getStudents("supervisor1") val2 = solutionGraph.getStudents("supervisor2") val3 = solutionGraph.getSupervisors("student3") expected = (['student2'],['student4','student3'],['supervisor2']) self.assertEqual((val1,val2,val3),expected) def test_case17(self): """Testing getGraph function""" solutionGraph = self.solution1.getGraph() val1 = isinstance(solutionGraph,BipartiteGraph) val2 = solutionGraph.getStuEdges() result = (val1,val2) expected1 = True expected2 = {'student1':['supervisor3'],'student2':['supervisor1'],'student3':['supervisor1'],'student4':['supervisor2']} expected = (expected1,expected2) self.assertEqual(result,expected) def test_case18(self): """Testing the isValid function - passing a null graph""" graph = BipartiteGraph() solution = Solution(graph) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case19(self): """Testing the isValid function - when number of supervisors less than actual""" graph = BipartiteGraph() graph.addEdge("supervisor1","student1") graph.addEdge("supervisor2","student4") graph.addEdge("supervisor2","student3") graph.addEdge("supervisor1","student2") solution = Solution(graph) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case20(self): """Testing the isValid function - when number of students less than actual""" graph = BipartiteGraph() graph.addEdge("supervisor1","student1") graph.addEdge("supervisor3","student3") graph.addEdge("supervisor2","student2") solution = Solution(graph) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case21(self): """Testing the isValid function - when a supervisor's allocation exceeds their quota""" self.graph1.addEdge("supervisor3","student2") solution = Solution(self.graph1) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case22(self): """Testing the isValid function - when a supervisor's degree is 0""" self.graph1.removeEdge("supervisor3","student1") solution = Solution(self.graph1) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case23(self): """Testing the isValid function - when a student's degree is not equal to 1""" self.graph1.addEdge("supervisor2","student3") solution = Solution(self.graph1) result = solution.isValid(self.students,self.supervisors) self.assertFalse(result) def test_case24(self): """Testing is valid function - when a correct graph is passed""" result1 = self.solution1.isValid(self.students,self.supervisors) result2 = self.solution2.isValid(self.students,self.supervisors) self.assertEqual((result1,result2),(True,True)) def test_case25(self): """Testing 'dominates' function - when both Fst and Fsup are greater in solution1 than solution2""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.4) solution2.setFst(27.5) solution2.setFsup(0.2) result = solution1.dominates(solution2) self.assertTrue(result) def test_case26(self): """Testing 'dominates' function - when only Fsup is greater in solution2 than solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.4) solution2.setFst(27.5) solution2.setFsup(0.6) result = solution1.dominates(solution2) self.assertFalse(result) def test_case27(self): """Testing 'dominates' function - when Fsup is same in solution2 and solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.4) solution2.setFst(27.5) solution2.setFsup(0.4) result = solution1.dominates(solution2) self.assertTrue(result) def test_case28(self): """Testing 'dominates' function - when only Fst is greater in solution2 and solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(26.5) solution1.setFsup(0.4) solution2.setFst(27.5) solution2.setFsup(0.2) result = solution1.dominates(solution2) self.assertFalse(result) def test_case29(self): """Testing 'dominates' function - when both Fst and Fsup are lesser in solution1 than solution2""" solution1 = Solution() solution2 = Solution() solution1.setFst(26.5) solution1.setFsup(0.2) solution2.setFst(27.5) solution2.setFsup(0.4) result = solution1.dominates(solution2) self.assertFalse(result) def test_case30(self): """Testing 'dominates' function - when Fst is same in solution2 and solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.6) solution2.setFst(29.5) solution2.setFsup(0.4) result = solution1.dominates(solution2) self.assertTrue(result) def test_case31(self): """Testing 'dominates' function - when Fst is same in solution2 and solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.2) solution2.setFst(29.5) solution2.setFsup(0.4) result = solution1.dominates(solution2) self.assertFalse(result) def test_case32(self): """Testing 'dominates' function - when Fst and Fsup are same in solution2 and solution1""" solution1 = Solution() solution2 = Solution() solution1.setFst(29.5) solution1.setFsup(0.4) solution2.setFst(29.5) solution2.setFsup(0.4) result = solution1.dominates(solution2) self.assertFalse(result)