Question

public class Scheduler {
   private List<Course> classes;
   private List<Student> students;
   public Scheduler() {
       classes = new ArrayList<Course>();
       students = new ArrayList<Student>();
   }
  
   public void addCourse(Course course) {
       this.classes.add(course);
   }

   public List<Course> getCourses() {
       List<Course> newCList=new ArrayList<>();
       for(int i=0;i<classes.size();i++){
       newCList.add(classes.get(i));
       }
       return newCList;
   }
   public void addStudent(Student student) {
       this.students.add(student);

   }
  
   public List<Student> getStudents() {  
       List<Student> newSList= new ArrayList<>();
       for(int i=0;i<students.size();i++){
           newSList.add(students.get(i));
           }
       return newSList;
   }
  
   /**
   * Assigns all students to courses in the following manner:
   *
   * For a given student, check their list of preferred courses. Add them to the course that:
   *    - exists in the scheduler's list of courses
   * - the student most prefers (that is, comes first in their preference list)
   * - the student is not not already enrolled in
   * - and is not full (in other words, at capacity)
   * Adds courses to the *end* of the student's current list of classes. Adds students to
   * the *end* of the course's roster.
   *   
   * Repeat this process for each student, one-by-one; each student will now have one course,
   * usually (but not always) their most preferred course.
   *
   * Then repeat this whole process (adding one course per student, when possible, proceeding
   * round-robin among students), until there is nothing left to do: Students might
   * all be at their maximum number of courses, or there may be no available seats in courses
   * that students want.
   */

   public void assignAll() {
       int m;
       int count = 0;
       int rslt = 0;
       for(Student student: students){
           rslt += student.getPreferences().size();
       }
       while(count<=rslt*rslt){
           for(Student student: students){
               m = 0;
               for(Course course: student.getPreferences()){
                   if(m==0) count++;
                   if(m==0 && this.classes.contains(course)
                           && !course.getRoster().contains(student)
                           && course.getRoster().size()<course.getCapacity()
                           && student.get().size()<student.getMaxCourses()) {
                       student.get().add(course);
                       course.getRoster().add(student);
                       m = 1;
                   }
               }
           }
       }
       }

* Drops a student from a course.
   public void drop(Student student, Course course) throws IllegalArgumentException {
       if(!students.contains(student))
           throw new IllegalArgumentException("this student is not in the scheduler");
       else if(!classes.contains(course)) {
           throw new IllegalArgumentException("this course is not in the scheduler");
       }
       else //classes.getRoster().remove(course);
       course.getRoster().remove(student);
       student.get().remove(course);

   }
  
   /**
   * Drops a student from all of their courses.
   *
   * @param student
   * @throws IllegalArgumentException if the student is not known to this scheduler
   */
   public void unenroll(Student student) throws IllegalArgumentException{
       if(!students.contains(student))
           throw new IllegalArgumentException("this student is not in the scheduler");
       else
           getCourses().removeAll(student.get());
   }

  
}

public class Student {
   private String name;
   private int maxCourses;
   private List<Course> preferences;
   private ArrayList<Course> s = new ArrayList<Course>();

   public Student(String name, int maxCourses, List<Course> preferences) throws IllegalArgumentException {
   this.name = name;
   this.maxCourses = maxCourses;
   this.preferences = preferences;
  
       if(maxCourses<=0) {
       throw new IllegalArgumentException("the maxCourses are invalid");
   }
     
       if(preferences.isEmpty()) {
       throw new IllegalArgumentException("the preferences are invalid");
   }
   }
   public String getName() {
      
       return name;
   }
   public int getMaxCourses() {
      
       return maxCourses;
   }
   public List<Course> getPreferences() {
      
       return preferences;
   }
   public List<Course> getSchedule() {
       List<Course> a = new ArrayList<>();
       a.addAll(s);

       return new ArrayList<>(a);
   }
   public List<Course> get(){
       return this.s;
   }

  
}
public class Course {
   private String courseNumber;
   private int capacity;
   private ArrayList<Student> r = new ArrayList<Student>();
  
   public Course(String courseNumber, int capacity) throws IllegalArgumentException {
   this.courseNumber = courseNumber;
   this.capacity = capacity;
       if(courseNumber.isEmpty()) {
       throw new IllegalArgumentException("the courseNumber is invalid");
   }

   if(capacity <=0) {
       throw new IllegalArgumentException("the capacity is invalid");
   }
   }
  

   public int getCapacity() {
       return capacity;
   }
  
   public String getCourseNumber() {  
       return courseNumber;
   }
   public List<Student> getRoster() {
return this.r;
   }
}

here are the tests that I failed with:  How to fix them?
   @Test
   public void testThreeThenUnenrollAndReschedule() {
       Course d = new Course("DUTCH100", 2);
       Course e = new Course("ECON100", 3);
      
       Student s = new Student("s", 3, Arrays.asList(new Course[] {a, b, c, d, e}));
       Student t = new Student("t", 4, Arrays.asList(new Course[] {c, a, d, e, b}));
       Student u = new Student("u", 5, Arrays.asList(new Course[] {b, a, d, c, e}));
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addStudent(u);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.addCourse(c);
       scheduler.addCourse(d);
       scheduler.addCourse(e);
       scheduler.assignAll();
       scheduler.unenroll(s);
       scheduler.assignAll();
      
       checkList(Arrays.asList(new Student[] {s, t, u}), scheduler.getStudents());      
       checkList(Arrays.asList(new Course[] {a, b, c, d, e}), scheduler.getCourses());
       checkList(Arrays.asList(new Student[] {t, s}), a.getRoster());
       checkList(Arrays.asList(new Student[] {u, s}), b.getRoster());
       assertEquals(Arrays.asList(new Student[] {t}), c.getRoster());
       checkList(Arrays.asList(new Student[] {u, t}), d.getRoster());
       checkList(Arrays.asList(new Student[] {t, u, s}), e.getRoster());
       checkList(Arrays.asList(new Course[] {a, b, e}), s.getSchedule());
       checkList(Arrays.asList(new Course[] {c, a, e, d}), t.getSchedule());
       checkList(Arrays.asList(new Course[] {b, d, e}), u.getSchedule());
   }
}

   @Test
   public void testUnenrollOne() {      
       Student s = new Student("s", 2, listAB);
       Student t = new Student("t", 2, listBA);
       List<Student> listST = Arrays.asList(new Student[] {s, t});
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.assignAll();
       scheduler.unenroll(t);
      
       checkList(listST, scheduler.getStudents());
       checkList(listAB, scheduler.getCourses());
       checkList(Arrays.asList(new Student[] {s}), a.getRoster());
       assertEquals(Arrays.asList(new Student[] {s}), b.getRoster());
       checkList(listAB, s.getSchedule());
       assertEquals(new ArrayList<>(), t.getSchedule());
   }

Answer 1

TestMain.java

package scheduler;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestMain {
  
   public static void main(String[] args) {
       //course selection
       Course a = new Course("ANTHRO100", 2);
       Course b = new Course("BIO100", 2);
       Course c = new Course("COMM100", 1);
       Course d = new Course("DUTCH100", 2);
       Course e = new Course("ECON100", 3);
      
       //created student object with name, maxCourse, and preference
       Student s = new Student("s", 3, Arrays.asList(new Course[] {a, b, c, d, e}));
       Student t = new Student("t", 4, Arrays.asList(new Course[] {c, a, d, e, b}));
       Student u = new Student("u", 5, Arrays.asList(new Course[] {b, a, d, c, e}));
      
       Scheduler scheduler = new Scheduler();
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addStudent(u);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.addCourse(c);
       scheduler.addCourse(d);
       scheduler.addCourse(e);
       scheduler.assignAll();
      
       //System.out.println("Pre-Dutch Capacity: " + d.getCurrentCapacity());
      
       System.out.println("Before Unenrolling S");
       System.out.println();
       scheduler.displayStudent(s);
       System.out.println();
      
       scheduler.displayStudent(t);
       System.out.println();
      
       scheduler.displayStudent(u);
       System.out.println();
       scheduler.unenroll(s);
      
       System.out.println();
       System.out.println();
       System.out.println("Unenrolling S, but not reassigning");
       System.out.println();
       scheduler.displayStudent(s);
       System.out.println();
      
       scheduler.displayStudent(t);
       System.out.println();
      
       scheduler.displayStudent(u);
       System.out.println();
      
       scheduler.assignAll();
       //System.out.println("Post-Dutch Capacity: " + d.getCurrentCapacity());
       //scheduler.displayStudent(s);
      
       System.out.println();
       System.out.println();
       System.out.println("Re-Assigning");
      
       scheduler.displayStudent(s);
       System.out.println();
      
       scheduler.displayStudent(t);
       System.out.println();
      
       scheduler.displayStudent(u);
       System.out.println();
   }

}

Course.java

import java.util.ArrayList;
import java.util.List;

public class Course {
  
   private String courseNumber;
   private int maxCapacity;
   private int currCapacity;
   List<Student> roster;

   public Course(String courseNumber, int capacity) throws IllegalArgumentException {
      
       //check is courseNumber of capacity are invalid
       if (capacity <= 0 || courseNumber == "") {
          
           throw new IllegalArgumentException();
       }
      
       this.courseNumber = courseNumber;
       this.maxCapacity = capacity;
       this.currCapacity = 0;
       this.roster = new ArrayList<Student>();
   }
  
   public int getCapacity() {
      
       return this.maxCapacity;
   }
  
   public int getCurrentCapacity() {
      
       return this.currCapacity;
   }
  
   public String getCourseNumber() {
      
       return this.courseNumber;
   }
  
   public void addToRoster(Student student) {
      
       //pushback the student object to the list of student objects
       this.roster.add(student);
      
       //update the capacity of the class
       this.currCapacity++;
   }
   public void removeFromRoster(Student student) {
      
       this.roster.remove(student);
       this.currCapacity--;
   }

   public List<Student> getRoster() {
      
       //copy over the old roster
       List<Student> newRoster = new ArrayList<Student>(roster);
      
       return newRoster;
   }
}

CourseTest.java

import org.junit.Test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout;

public class CourseTest {
  

   private Course course;
   private String courseNumber;
   private int capacity;
  
   @Before
   public void setup() {
       courseNumber = "COMPSCI190D";
       capacity = 120;      
       course = new Course(courseNumber, capacity);
   }
  
   @Test
   public void testGetCourseNumber() {
       assertEquals(courseNumber, course.getCourseNumber());
   }

   @Test
   public void testGetCapacity() {
       assertEquals(capacity, course.getCapacity());
   }
  
   @Test
   public void testGetRosterEmpty() {
       assertTrue(course.getRoster().isEmpty());
   }
  
   @Test(expected = IllegalArgumentException.class)
   public void testInvalidCourseNumber() {
       Course c = new Course("", 20);
   }

   @Test(expected = IllegalArgumentException.class)
   public void testInvalidCapacity() {
       Course c = new Course("COMPSCI190D", 0);
   }
}

Scheduler.java

import java.util.ArrayList;
import java.util.List;

public class Scheduler {
  
   List<Course> courses;
  
   //When we add student objects to the scheduler, it keeps them in a list
   List<Student> students;
  
   public Scheduler() {
      
       //both lists are currently empty
       this.courses = new ArrayList<>();
       this.students = new ArrayList<>();
   }
  
   public void addCourse(Course course) {
      
       this.courses.add(course);
   }
  
   public List<Course> getCourses() {
      
       List<Course> copy = new ArrayList<>(this.courses);
      
       return copy;
   }
  
   public void addStudent(Student student) {
      
       this.students.add(student);
   }
  
   public List<Student> getStudents() {
      
       List<Student> copy = new ArrayList<>(this.students);
      
       return copy;
   }
   public void assignAll() {
      
       boolean assign = false;
       int taskDone = 1;
       int i;
       while(taskDone > 0) {
          
           //reassigns i = 0;
           i = 0;
          
           //reassigns taskDone = 0;
           taskDone = 0;
           for (i = 0; i < this.students.size(); i++) {
              
               //reset the flag
               assign = false;
              
               //check if the student is at their maxCourse, if so do not assign this poor student more than he/she wants
               if (this.students.get(i).getMaxCourses() != this.students.get(i).getCurrentNumCourses()) {
                   for (int j = 0; j < this.students.get(i).getPreferences().size() && !assign; j++) {
                      
                       //if it exists within our list
                       if (this.courses.contains(this.students.get(i).getPreferences().get(j)) &&
                          
                           //if they don't already have this class in their schedule
                           !(this.students.get(i).getSchedule().contains(this.students.get(i).getPreferences().get(j))) &&
                          
                           //if the class still has space to add one more student
                           this.students.get(i).getPreferences().get(j).getCurrentCapacity() != this.students.get(i).getPreferences().get(j).getCapacity()) {
              
                           //assign that them the class, also need to update the roster of the class
                           this.students.get(i).addToSchedule(this.students.get(i).getPreferences().get(j));
                           this.students.get(i).getPreferences().get(j).addToRoster(this.students.get(i));
                          
                           //provides a condition to exit the loop
                           assign = true;
                          
                           //we have done an assignment
                           taskDone++;
                       }
                   }
               }
           }
       }
   }

   public void drop(Student student, Course course) throws IllegalArgumentException {
      
       //if the student or course objects are not known to this class
       if (!(this.students.contains(student)) || !(this.courses.contains(course))) {
          
           throw new IllegalArgumentException();
       }
      
       //call the method in Student that will drop the course
       student.dropFromSchedule(course);
       course.removeFromRoster(student);
   }
   public void unenroll(Student student) throws IllegalArgumentException {
      
       //if the list of students does not contain the the Student object passed
       if (!this.students.contains(student)) {
          
           //throw exception
           throw new IllegalArgumentException();
       }
      
       //the student drops all the classes from schedule
       student.dropAllFromSchedule();
   }
   public void displayStudent(Student student) {
      
       student.display();
   }
}

SchedulerTest.java
import org.junit.Test;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout;

public class SchedulerTest {

   private Scheduler scheduler;
  
   private Scheduler singleScheduler;
   private Course courseOne;
   private Student studentOne;

   private Course a;
   private Course b;
   private Course c;
   private List<Course> listA;
   private List<Course> listB;
   private List<Course> listAB;
   private List<Course> listBA;  
   private List<Course> listAC;
   private List<Course> listCA;  

   @Before
   public void setup() {
       scheduler = new Scheduler();
       courseOne = new Course("ONE1", 1);
       List<Course> l = new ArrayList<>();
       l.add(courseOne);
       studentOne = new Student("one", 1, l);
       singleScheduler = new Scheduler();
       singleScheduler.addStudent(studentOne);
       singleScheduler.addCourse(courseOne);

       a = new Course("ANTHRO100", 2);
       b = new Course("BIO100", 2);
       c = new Course("COMM100", 1);
      
       listA = Arrays.asList(new Course[] {a});
       listB = Arrays.asList(new Course[] {b});
       listAB = Arrays.asList(new Course[] {a, b});
       listBA = Arrays.asList(new Course[] {b, a});
       listAC = Arrays.asList(new Course[] {a, c});
       listCA = Arrays.asList(new Course[] {c, a});
   }

   private static <E> void checkList(List<E> expected, List<E> actual) {
       assertEquals(expected.size(), actual.size());
       for (E e: expected) {
           assertTrue(actual.contains(e));
       }
   }
  
   @Test
   public void testGetCoursesEmpty() {
       assertTrue(scheduler.getCourses().isEmpty());
   }

   @Test
   public void testGetStudentsEmpty() {
       assertTrue(scheduler.getStudents().isEmpty());
   }

   @Test
   public void testAddOneCourse() {
       assertEquals(1, singleScheduler.getCourses().size());
       assertTrue(singleScheduler.getCourses().contains(courseOne));
   }

   @Test
   public void testAddOneStudent() {
       assertEquals(1, singleScheduler.getStudents().size());
       assertTrue(singleScheduler.getStudents().contains(studentOne));
   }

   @Test
   public void testGetCoursesNotShared() {
       List<Course> l = singleScheduler.getCourses();
       l.clear();
       assertTrue(singleScheduler.getCourses().contains(courseOne));
   }

   @Test
   public void testGetStudentsNotShared() {
       List<Student> l = singleScheduler.getStudents();
       l.clear();
       assertTrue(singleScheduler.getStudents().contains(studentOne));
   }
  
   @Test
   public void testSingleCourse() {      
       Student s = new Student("s", 1, listA);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(a);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       assertEquals(listA, scheduler.getCourses());
       assertEquals(listS, a.getRoster());
       assertEquals(listA, s.getSchedule());
   }
  
   @Test
   public void testDropSimple() {      
       Student s = new Student("s", 1, listA);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(a);
       scheduler.assignAll();
       scheduler.drop(s, a);
      
       assertEquals(listS, scheduler.getStudents());
       assertEquals(listA, scheduler.getCourses());
       assertTrue(s.getSchedule().isEmpty());
       assertTrue(a.getRoster().isEmpty());
   }

   @Test
   public void testSingleUnavailableCourse() {      
       Student s = new Student("s", 1, listA);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(b);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       assertEquals(Arrays.asList(new Course[] {b}), scheduler.getCourses());
       assertTrue(a.getRoster().isEmpty());
       assertTrue(b.getRoster().isEmpty());
   }
  
   @Test
   public void testPreferFirst() {      
       Student s = new Student("s", 1, listAB);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       checkList(listAB, scheduler.getCourses());
       assertEquals(listS, a.getRoster());
       assertEquals(listA, s.getSchedule());
       assertTrue(b.getRoster().isEmpty());
   }

   @Test
   public void testPreferSecond() {      
       Student s = new Student("s", 1, listBA);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(b);
       scheduler.addCourse(a);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       checkList(listBA, scheduler.getCourses());
       assertEquals(listS, b.getRoster());
       assertEquals(listB, s.getSchedule());
       assertTrue(a.getRoster().isEmpty());
   }
  
   @Test
   public void testAddTwo() {      
       Student s = new Student("s", 2, listAB);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(b);
       scheduler.addCourse(a);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       checkList(listBA, scheduler.getCourses());
       assertEquals(listS, a.getRoster());
       assertEquals(listS, b.getRoster());
      
       assertEquals(2, s.getSchedule().size());
       checkList(listAB, s.getSchedule());
   }
  
   @Test
   public void testAddOnlyOne() {      
       Student s = new Student("s", 1, listAB);
       List<Student> listS = Arrays.asList(new Student[] {s});
      
       scheduler.addStudent(s);
       scheduler.addCourse(b);
       scheduler.addCourse(a);
       scheduler.assignAll();
      
       assertEquals(listS, scheduler.getStudents());
       checkList(listBA, scheduler.getCourses());
       assertEquals(listS, a.getRoster());
       assertTrue(b.getRoster().isEmpty());
       assertEquals(listA, s.getSchedule());
   }
  
   @Test
   public void testTwoInTwo() {      
       Student s = new Student("s", 2, listAB);
       Student t = new Student("t", 2, listBA);
       List<Student> listST = Arrays.asList(new Student[] {s, t});
       List<Student> listTS = Arrays.asList(new Student[] {t, s});
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.assignAll();
      
       checkList(listST, scheduler.getStudents());
       checkList(listAB, scheduler.getCourses());
       checkList(listST, a.getRoster());
       checkList(listTS, b.getRoster());
       checkList(listAB, s.getSchedule());
       checkList(listBA, t.getSchedule());
   }
  
   @Test
   public void testDropFromOne() {      
       Student s = new Student("s", 2, listAB);
       Student t = new Student("t", 2, listBA);
       List<Student> listST = Arrays.asList(new Student[] {s, t});
       List<Student> listTS = Arrays.asList(new Student[] {t, s});
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.assignAll();
       scheduler.drop(t, a);
      
       checkList(listST, scheduler.getStudents());
       checkList(listAB, scheduler.getCourses());
       assertEquals(Arrays.asList(new Student[] {s}), a.getRoster());
       checkList(listTS, b.getRoster());
       checkList(listAB, s.getSchedule());
       assertEquals(listB, t.getSchedule());
   }
  
   @Test
   public void testUnenrollOne() {      
       Student s = new Student("s", 2, listAB);
       Student t = new Student("t", 2, listBA);
       List<Student> listST = Arrays.asList(new Student[] {s, t});
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.assignAll();
       scheduler.unenroll(t);
      
       checkList(listST, scheduler.getStudents());
       checkList(listAB, scheduler.getCourses());
       checkList(Arrays.asList(new Student[] {s}), a.getRoster());
       assertEquals(Arrays.asList(new Student[] {s}), b.getRoster());
       checkList(listAB, s.getSchedule());
       assertEquals(new ArrayList<>(), t.getSchedule());
   }
  
   @Test
   public void testOneFull() {      
       Student s = new Student("s", 2, listAC);
       Student t = new Student("t", 2, listCA);
       List<Student> listT = Arrays.asList(new Student[] {t});
       List<Student> listST = Arrays.asList(new Student[] {s, t});
       List<Student> listTS = Arrays.asList(new Student[] {t, s});
      
       scheduler.addStudent(t);
       scheduler.addStudent(s);
       scheduler.addCourse(c);
       scheduler.addCourse(a);
       scheduler.assignAll();
      
       checkList(listTS, scheduler.getStudents());
       checkList(listCA, scheduler.getCourses());
       checkList(listST, a.getRoster());
       assertEquals(listT, c.getRoster());
       assertEquals(listA, s.getSchedule());
       checkList(listCA, t.getSchedule());
   }
  
   @Test
   public void testOtherFull() {      
       Student s = new Student("s", 2, listAC);
       Student t = new Student("t", 2, listCA);
       List<Student> listT = Arrays.asList(new Student[] {t});
       List<Student> listST = Arrays.asList(new Student[] {s, t});
       List<Student> listTS = Arrays.asList(new Student[] {t, s});
      
       scheduler.addStudent(t);
       scheduler.addStudent(s);
       scheduler.addCourse(a);
       scheduler.addCourse(c);
       scheduler.assignAll();
      
       checkList(listTS, scheduler.getStudents());
       checkList(listAC, scheduler.getCourses());
       checkList(listST, a.getRoster());
       assertEquals(listT, c.getRoster());
       assertEquals(listA, s.getSchedule());
       checkList(listCA, t.getSchedule());
   }
  
   @Test
   public void testThree() {
       Course d = new Course("DUTCH100", 2);
       Course e = new Course("ECON100", 3);
      
       Student s = new Student("s", 3, Arrays.asList(new Course[] {a, b, c, d, e}));
       Student t = new Student("t", 4, Arrays.asList(new Course[] {c, a, d, e, b}));
       Student u = new Student("u", 5, Arrays.asList(new Course[] {b, a, d, c, e}));
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addStudent(u);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.addCourse(c);
       scheduler.addCourse(d);
       scheduler.addCourse(e);
       scheduler.assignAll();
      
       checkList(Arrays.asList(new Student[] {s, t, u}), scheduler.getStudents());      
       checkList(Arrays.asList(new Course[] {a, b, c, d, e}), scheduler.getCourses());
       checkList(Arrays.asList(new Student[] {s, t}), a.getRoster());
       checkList(Arrays.asList(new Student[] {u, s}), b.getRoster());
       assertEquals(Arrays.asList(new Student[] {t}), c.getRoster());
       checkList(Arrays.asList(new Student[] {u, s}), d.getRoster());
       checkList(Arrays.asList(new Student[] {t, u}), e.getRoster());
       checkList(Arrays.asList(new Course[] {a, b, d}), s.getSchedule());
       checkList(Arrays.asList(new Course[] {c, a, e}), t.getSchedule());
       checkList(Arrays.asList(new Course[] {b, d, e}), u.getSchedule());
   }
  
   @Test
   public void testThreeThenUnenrollAndReschedule() {
       Course d = new Course("DUTCH100", 2);
       Course e = new Course("ECON100", 3);
      
       Student s = new Student("s", 3, Arrays.asList(new Course[] {a, b, c, d, e}));
       Student t = new Student("t", 4, Arrays.asList(new Course[] {c, a, d, e, b}));
       Student u = new Student("u", 5, Arrays.asList(new Course[] {b, a, d, c, e}));
      
       scheduler.addStudent(s);
       scheduler.addStudent(t);
       scheduler.addStudent(u);
       scheduler.addCourse(a);
       scheduler.addCourse(b);
       scheduler.addCourse(c);
       scheduler.addCourse(d);
       scheduler.addCourse(e);
       scheduler.assignAll();
       scheduler.unenroll(s);
       scheduler.assignAll();
      
       checkList(Arrays.asList(new Student[] {s, t, u}), scheduler.getStudents());      
       checkList(Arrays.asList(new Course[] {a, b, c, d, e}), scheduler.getCourses());
       checkList(Arrays.asList(new Student[] {t, s}), a.getRoster());
       checkList(Arrays.asList(new Student[] {u, s}), b.getRoster());
       assertEquals(Arrays.asList(new Student[] {t}), c.getRoster());
       checkList(Arrays.asList(new Student[] {u, t}), d.getRoster());
       checkList(Arrays.asList(new Student[] {t, u, s}), e.getRoster());
       checkList(Arrays.asList(new Course[] {a, b, e}), s.getSchedule());
       checkList(Arrays.asList(new Course[] {c, a, e, d}), t.getSchedule());
       checkList(Arrays.asList(new Course[] {b, d, e}), u.getSchedule());
   }
}

Student.java

import java.util.ArrayList;
import java.util.List;

public class Student {
  
   private String name;
   private int maxCourses;
   private int currCourses;
   private List<Course> preferences;
   private List<Course> schedule;
   public Student(String name, int maxCourses, List<Course> preferences) throws IllegalArgumentException {
      
       //check for valid maxCourses and preference value
       if (maxCourses < 1 || preferences.size() < 1) {
          
           throw new IllegalArgumentException();
       }
      
       //store the values passed in the constructor to the class
       this.name = name;
       this.maxCourses = maxCourses;
       this.currCourses = 0;
       this.preferences = preferences;
       this.schedule = new ArrayList<Course>();
   }
  
   public String getName() {
      
       return this.name;
   }
   public int getMaxCourses() {
      
       return this.maxCourses;
   }
  
   public int getCurrentNumCourses() {
      
       return this.currCourses;
   }
   public List<Course> getPreferences() {
      
       List<Course> copy = new ArrayList<Course>(preferences);
      
       return copy;
   }
   public void addToSchedule(Course course) {
      
       this.schedule.add(course);
       this.currCourses++;
   }
   public List<Course> getSchedule() {
      
       List<Course> copy = new ArrayList<Course>(this.schedule);
      
       return copy;
   }
  
   public void dropFromSchedule(Course courseToDrop) {
      
       //search for that course in the schedule list
       for (int i = 0; i < this.schedule.size(); i++) {
          
           //if we have found to course-to-drop
           if (this.schedule.get(i).equals(courseToDrop)) {
              
               //drop it
               this.schedule.remove(i);
           }
       }
      
       this.currCourses--;
   }
   public void dropAllFromSchedule() {
      
       //removes the student from each course roster
       for (int i = 0; i < this.schedule.size(); i++) {
          
           schedule.get(i).removeFromRoster(this);
           this.currCourses--;
       }
      
       //removes all the Course objects from the Schedule list
       this.schedule.clear();
   }
  
   public void display() {
      
       System.out.println("Displaying the Student's name, maxCourses, preference, and schedule.");
      
       System.out.println("Name: " + this.getName());
       System.out.println("Max Courses: " + this.getMaxCourses());
      
       for (int i = 0; i < this.getPreferences().size(); i++) {
          
           System.out.println("Course Number: " + this.getPreferences().get(i).getCourseNumber() + "\t\tCourse Capacity: " + this.getPreferences().get(i).getCapacity());
       }
      
       System.out.println();
      
       if (this.schedule.isEmpty()) {
          
           System.out.println("The student schedule is empty right now");
       }
      
       else {
          
           System.out.println("Schedule: ");
          
           for (int i = 0; i < this.schedule.size(); i++) {
              
               System.out.println(this.schedule.get(i).getCourseNumber());
           }
       }
   }
}

StudentTest.java

import org.junit.Test;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout;

public class StudentTest {

   private Student joe;
   private List<Course> courseList;
  
   @Before
   public void setup() {
       courseList = new ArrayList<>();
       courseList.add(new Course("COMPSCI190D", 120));
       courseList.add(new Course("MATH132", 50));
       courseList.add(new Course("ENGLWRIT112", 20));
      
       joe = new Student("Joe", 4, courseList);
   }
  
   @Test
   public void testGetName() {
       assertEquals("Joe", joe.getName());
   }

   @Test
   public void testGetMaxCourses() {
       assertEquals(4, joe.getMaxCourses());
   }

   @Test
   public void testGetPreferences() {
       assertEquals(courseList, joe.getPreferences());
   }

   @Test
   public void testGetPreferencesNotShared() {
       List<Course> prefs = joe.getPreferences();
       prefs.clear();
       assertEquals(courseList, joe.getPreferences());
   }
  
   @Test
   public void testGetScheduleEmpty() {
       assertTrue(joe.getSchedule().isEmpty());
   }

   @Test
   public void testGetScheduleEmptyNotShared() {
       List<Course> schedule = joe.getSchedule();
       schedule.add(new Course("COMPSCI190D", 120));
       assertTrue(joe.getSchedule().isEmpty());
   }

   @Test(expected = IllegalArgumentException.class)
   public void testInvalidMaxCourses() {
       Student s = new Student("NoCourses", 0, courseList);
   }

   @Test(expected = IllegalArgumentException.class)
   public void testEmptyPreferences() {
       Student s = new Student("DontCare", 3, new ArrayList<Course>());
   }
}