diff --git a/src/Controller.java b/src/Controller.java index abdbd87..4dd6c48 100644 --- a/src/Controller.java +++ b/src/Controller.java @@ -1,11 +1,79 @@ public abstract class Controller { - protected Elevator elevator; + protected int numberOfFloors; + protected Elevator[] elevators; + protected boolean[] pushedUp; + protected boolean[] pushedDown; + + /** + * Editor: Elijah Smith + * initialized size of new pushed fields. + */ + protected Controller(int numberOfFloors, int numberOfElevators) + { + this.numberOfFloors = numberOfFloors; + + this.elevators = new Elevator[numberOfElevators]; + for(int loop = 0; loop < numberOfElevators; loop++) + { + this.elevators[loop] = new Elevator(numberOfFloors); + } - protected Controller(Elevator elevator) + pushedUp = new boolean[numberOfFloors + 1]; + pushedDown = new boolean[numberOfFloors + 1]; + } + + public abstract void next(); + + public int pushTrue() { - this.elevator = elevator; + int counter = 0; + for(int loop = 0; loop < pushedUp.length; loop++) + { + if(pushedUp[loop] || pushedDown[loop]) + counter++; + } + return counter; } + /** + * Editor: Elijah Smith + * Issue #108 moving this method from Elevator + */ + public void pushUp(int currentFloor) { + pushedUp[currentFloor] = true; + } - public abstract void next(); + /** + * Editor: Elijah Smith + * Issue #108 moving this method from Elevator + */ + public void pushDown(int currentFloor) { + pushedDown[currentFloor] = true; + } + + public int getNumberOfFloors() + { + return numberOfFloors; + } + + public Elevator[] getElevators() + { + return elevators; + } + + /** + * Author: Elijah Smith + * accessor for boolean array pushedUp[] + */ + public boolean[] getPushedUpArray() { + return this.pushedUp; + } + + /** + * Author: Elijah Smith + * accessor for boolean array pushedDown[] + */ + public boolean[] getPushedDownArray() { + return this.pushedDown; + } } diff --git a/src/DefaultController.java b/src/DefaultController.java index a3a7a3f..5f34e67 100644 --- a/src/DefaultController.java +++ b/src/DefaultController.java @@ -1,12 +1,151 @@ + +import java.util.ArrayList; + public class DefaultController extends Controller { - public DefaultController(Elevator elevator) + private Timer time = new Timer(3000); + private boolean leftMovingUp; + private boolean leftMovingDown; + private boolean leftRest; + + private boolean rightMovingUp; + private boolean rightMovingDown; + private boolean rightRest; + + public DefaultController(int numberOfFloors, int numberOfElevators) { - super(elevator); + super(numberOfFloors, numberOfElevators); + + super.elevators[1] = new Elevator(super.numberOfFloors - 1, super.numberOfFloors); + + leftMovingUp = false; + leftMovingDown = false; + leftRest = true; + + rightMovingUp = false; + rightMovingDown = false; + rightRest = true; } public void next() { + Elevator leftElev = super.elevators[0]; + int leftCurrentFloor = leftElev.getCurrentFloor(); + boolean[] leftDestFloors = leftElev.getDestinationFloor(); + + Elevator rightElev = super.elevators[1]; + int rightCurrentFloor = rightElev.getCurrentFloor(); + boolean[] rightDestFloors = rightElev.getDestinationFloor(); + + if(super.pushTrue() == 0) + { + if(leftElev.hasDestFloors() == 0) + { + if(leftCurrentFloor > 1) + { + leftMovingDown = true; + leftMovingUp = false; + } + else + { + leftMovingDown = false; + leftMovingUp = false; + leftRest = true; + } + } + + if(rightElev.hasDestFloors() == 0) + { + if(rightCurrentFloor < super.numberOfFloors) + { + rightMovingUp = true; + rightMovingDown = false; + } + else + { + rightMovingUp = false; + rightMovingDown = false; + rightRest = true; + } + } + } + else + { + int pushedUp = 0; + int pushedDown = 0; + + for(int loop = 1; loop <= super.numberOfFloors; loop++) + { + if(super.pushedUp[loop]) + pushedUp++; + + if(super.pushedDown[loop]) + pushedDown++; + } + + if(pushedUp > 0 && !rightMovingUp && !leftMovingUp) + { + leftMovingUp = true; + leftMovingDown = false; + leftRest = false; + } + + if(pushedDown > 0 && !rightMovingDown && !leftMovingDown) + { + rightMovingDown = true; + rightMovingUp = false; + rightRest = false; + } + + } + + + if((leftMovingUp && pushedUp[leftCurrentFloor]) || (leftMovingDown && pushedDown[leftCurrentFloor]) || leftDestFloors[leftCurrentFloor]) + { + leftElev.stop(); + + if(leftMovingUp) + { + pushedUp[leftCurrentFloor] = false; + } + else if(leftMovingDown) + { + pushedDown[leftCurrentFloor] = false; + } + } + else if(leftMovingUp) + { + leftElev.moveUp(); + } + else if(leftMovingDown) + { + leftElev.moveDown(); + } + + if((rightMovingUp && pushedUp[rightCurrentFloor]) || (rightMovingDown && pushedDown[rightCurrentFloor]) || rightDestFloors[rightCurrentFloor]) + { + rightElev.stop(); + + if(rightMovingUp) + { + pushedUp[rightCurrentFloor] = false; + } + else if(rightMovingDown) + { + pushedDown[rightCurrentFloor] = false; + } + } + else if(rightMovingUp) + { + rightElev.moveUp(); + } + else if(rightMovingDown) + { + rightElev.moveDown(); + } + + time.run(); } + } diff --git a/src/Display.java b/src/Display.java index bd49196..690922c 100644 --- a/src/Display.java +++ b/src/Display.java @@ -1,58 +1,94 @@ -/* - * - *Author Jake Wooten - * Iusse #7 - * */ - -public class Display { - -Elevator elevator; -Passenger passenger; - - public Display(Passenger passenger, Elevator elevator) { - - this.passenger = passenger; - this.elevator = elevator; - } - /* - *Displays floor passenger is currently on - */ - - public void display_currentP () { - - - System.out.println("Passenger is on floor " + passenger.getStartFloor()); - } - - /* - *Displays the floor the passenger has selected - */ - - public void display_selectP () { - - System.out.println("Passenger has selected floor " + passenger.getDestinationFloor()); - } - - /* - *Displays the floor the passenger has arrived at - */ - public void display_destP () { - System.out.println("Passenger has arrived at floor " + passenger.getDestinationFloor()); - } - - /* - *Displays the floor the elevator leaves from - */ - public void display_currentE () { - - System.out.println("Elevator doors close\nElevator leaves from floor " + elevator.getCurrentFloor()); - } - - /* - *Displays the floor the elevator has arrived at - */ - public void display_destE () { - - System.out.println("Elevator doors open\nElevator arrives at floor " + elevator.getDestinationFloor()); - } +import java.util.ArrayList; + +public class Display +{ + private PassengerManager passengerManager; + private Controller control; + + public Display(PassengerManager passengerManager, Controller control) + { + this.passengerManager = passengerManager; + this.control = control; + + start(); + } + + public void display() + { + System.out.println("============================================================="); + + ArrayList passengers = passengerManager.getPassengers(); + for(int loop = 0; loop < passengers.size(); loop++) + { + Passenger passenger = passengers.get(loop); + printPassenger(loop, passenger); + } + + System.out.println("============================================================="); + + Elevator[] elevators = control.getElevators(); + for(int loop = 0; loop < elevators.length; loop++) + { + printElevator(loop, elevators[loop]); + System.out.println("============================================================="); + } + + System.out.println("=============================================================\n\n"); + } + + public void start() + { + System.out.println("Welcome to our Elevator Simulation:\n (Enter Ctrl+C to exit simulation) \n\n\n"); + } + + public void printPassenger(int number, Passenger passenger) + { + if(passenger.getWaiting()) + { + System.out.print("Passenger " + number + " is on Floor " + passenger.getStartFloor()); + + if(passenger.getStartFloor() > passenger.getDestinationFloor()) + { + System.out.println(" waiting to go down to " + passenger.getDestinationFloor() + "."); + } + else + { + System.out.println(" waiting to go up to " + passenger.getDestinationFloor() + "."); + } + } + } + + public void printElevator(int number, Elevator elevator) + { + if(elevator.getStopped()) + { + System.out.println("Elevator " + number + " has stopped on Floor " + elevator.getCurrentFloor()); + System.out.println("Elevator doors have opened."); + + ArrayList passengers = passengerManager.getPassengers(); + for(int loop = 0; loop < passengers.size(); loop++) + { + Passenger passenger = passengers.get(loop); + + if(elevator.getCurrentFloor() == passenger.getStartFloor()) + { + System.out.println("Passenger " + loop + " has boarded the elevator."); + } + else if(passenger.getRidingElev() == number) + { + System.out.println("Passenger " + loop + " has left the elevator."); + } + else if(passenger.getRiding() && passenger.getRidingElev() == number) + { + System.out.println("Passenger " + loop + " has left the elevator."); + } + + } + System.out.println("Elevator doors have closed."); + } + else + { + System.out.println("Elevator " + number + " is on Floor " + elevator.getCurrentFloor()); + } + } } diff --git a/src/ElevSim.java b/src/ElevSim.java index 46e8538..e4dfd11 100644 --- a/src/ElevSim.java +++ b/src/ElevSim.java @@ -1,17 +1,23 @@ -/** - * Author: Elijah Smith - * version: Mon Jul 15, 2019 - * Issue #2 - */ import java.util.Scanner; -public class ElevSim { - public static void main(String[] args) { - Scanner kb = new Scanner(System.in); - System.out.println("Enter the desired floor: "); - int df = kb.nextInt(); //df is desired floor +public class ElevSim +{ + + public static void main(String[] args) + { + + Controller control = new DefaultController(10, 2); + PassengerManager passengerManager = new PassengerManager(control); + Display disp = new Display(passengerManager, control); - //hard coded 5 as the numberOfFloor parameter because Im not quite sure how to handle that now - Elevator elevator = new Elevator(1, df, 5); - } + Passenger p1 = passengerManager.newPassenger(5, 8); + Passenger p2 = passengerManager.newPassenger(7, 2); + + while(true) + { + passengerManager.next(); + control.next(); + disp.display(); + } + } } diff --git a/src/Elevator.java b/src/Elevator.java index 30d8927..1649e39 100644 --- a/src/Elevator.java +++ b/src/Elevator.java @@ -1,66 +1,95 @@ -/** - * - */ - public class Elevator { private int currentFloor; - private int destinationFloor; + private boolean[] destinationFloor; private int numberOfFloors; + private boolean stopped; + /* + * Author: Elijah Smith + * Issue #61 new Constructor + */ + public Elevator(int numberOfFloors) { + this.currentFloor = 1; + this.numberOfFloors = numberOfFloors; + this.destinationFloor = new boolean[numberOfFloors+1]; + this.stopped = false; + } + /** * Author: Elijah Smith * Issue #18 Constructor */ - public Elevator(int currentFloor, int destinationFloor, int numberOfFloors) { + public Elevator(int currentFloor, int numberOfFloors) { this.currentFloor = currentFloor; - this.destinationFloor = destinationFloor; this.numberOfFloors = numberOfFloors; + this.destinationFloor = new boolean[numberOfFloors+1]; + this.stopped = false; } /** * Author: Elijah Smith * Issue #57/51 moveDown() + * @throws Exception */ public void moveDown() { currentFloor--; + System.out.print("\007"); + this.stopped = false; } /** * Author: Elijah Smith * Issue #57/51 moveUp */ - public void moveUp(){ - currentFloor++; + public void moveUp() { + currentFloor++; + System.out.print("\007"); + this.stopped = false; + } + + public int hasDestFloors() + { + int count = 0; + for(int loop = 0; loop < destinationFloor.length; loop++) + { + if(destinationFloor[loop]) + count++; + } + return count; } - /** - * Author: Elijah Smith - * Issue #22 getter method - */ - public int getCurrentFloor() { + public int getCurrentFloor() { return this.currentFloor; - } - - public int getDestinationFloor() { - return this.destinationFloor; } + public void addDestinationFloor(int currentFloor) { + destinationFloor[currentFloor] = true; + } + + public boolean[] getDestinationFloor() { + return this.destinationFloor; + } + public int getNumberOfFloors() { return this.numberOfFloors; } + public void stop() { + this.stopped = true; + destinationFloor[currentFloor] = false; + } + + public boolean getStopped() { + return this.stopped; + } + public void setCurrentFloor(int currentFloor) { this.currentFloor = currentFloor; } - public void setDestinationFloor(int destinationFloor) { - this.destinationFloor = destinationFloor; - } public void setNumberOfFloors(int numberOfFloors) { this.numberOfFloors = numberOfFloors; } } - - diff --git a/src/Passenger.java b/src/Passenger.java index 9648e97..89ab779 100644 --- a/src/Passenger.java +++ b/src/Passenger.java @@ -1,18 +1,96 @@ public class Passenger { + private Controller control; + private int startFloor; private int destinationFloor; + private int ridingElev; - public Passenger(int startFloor, int destinationFloor) + private boolean waiting; + private boolean riding; + private boolean done; + + public Passenger(Controller control, int startFloor, int destinationFloor) { + this.control = control; + this.startFloor = startFloor; this.destinationFloor = destinationFloor; + this.ridingElev = -1; + + this.waiting = false; + this.riding = false; + this.done = false; } - public Passenger(int destinationFloor) + public Passenger(Controller control, int destinationFloor) { + this.control = control; + this.startFloor = 1; this.destinationFloor = destinationFloor; + this.ridingElev = -1; + + this.waiting = false; + this.riding = false; + this.done = false; + } + + public void next() + { + if(!this.waiting) + { + if(this.destinationFloor > this.startFloor) + { + control.pushUp(this.startFloor); + } + else + { + control.pushDown(this.startFloor); + } + this.waiting = true; + } + else + { + Elevator[] elevators = control.getElevators(); + for(int loop = 0; loop < elevators.length; loop++) + { + Elevator elev = elevators[loop]; + if(!riding && elev.getStopped() && elev.getCurrentFloor() == startFloor) + { + elev.addDestinationFloor(destinationFloor); + this.riding = true; + this.ridingElev = loop; + + break; + } + else if(loop == ridingElev && elev.getStopped() && elev.getCurrentFloor() == destinationFloor) + { + this.done = true; + break; + } + } + } + } + + public boolean getWaiting() + { + return this.waiting; + } + + public boolean getRiding() + { + return this.riding; + } + + public int getRidingElev() + { + return this.ridingElev; + } + + public boolean getDone() + { + return this.done; } public int getStartFloor() diff --git a/src/PassengerManager.java b/src/PassengerManager.java new file mode 100644 index 0000000..a3f4b93 --- /dev/null +++ b/src/PassengerManager.java @@ -0,0 +1,53 @@ +import java.util.Random; +import java.util.ArrayList; + +public class PassengerManager +{ + private ArrayList passengers; + private Controller control; + + public PassengerManager(Controller control) + { + this.control = control; + this.passengers = new ArrayList(); + } + + public Passenger newPassenger() + { + Random rand = new Random(); + int start = rand.nextInt(control.getNumberOfFloors()) + 1; + int dest = rand.nextInt(control.getNumberOfFloors()) + 1; + + while (dest == start) + { + dest = rand.nextInt(control.getNumberOfFloors()) + 1; + } + + Passenger newPass = new Passenger(control, start, dest); + passengers.add(newPass); + + return newPass; + } + + + public Passenger newPassenger(int startFloor, int destFloor) + { + Passenger newPass = new Passenger(control, startFloor, destFloor); + passengers.add(newPass); + + return newPass; + } + + public void next() + { + for (int i = 0; i < passengers.size(); i++) + { + passengers.get(i).next(); + } + } + + public ArrayList getPassengers() + { + return passengers; + } +} diff --git a/src/Timer.java b/src/Timer.java new file mode 100644 index 0000000..9c37916 --- /dev/null +++ b/src/Timer.java @@ -0,0 +1,46 @@ +public class Timer extends Thread + { + int timeUsed; + boolean timeV; + TimerClient callbackObject; + + public Timer(int millis) + { + timeUsed = millis; + timeV = false; + } + public Timer(int millis, TimerClient client) + { + this(millis); + callbackObject = client; + } + public void run() + { + try + { + Thread.sleep(timeUsed); + } + catch(Exception e) + { + + } + + timeV = true; + if (callbackObject != null) + { + callbackObject.timerCallback(); + } + } + + public boolean expired() + { + return timeV; + } + + public void start() + { + //System.out.println("Starting: " + timeUsed + " Second Timer "); + super.start(); + + } + } diff --git a/src/TimerTest.java b/src/TimerTest.java new file mode 100644 index 0000000..0bbe8c8 --- /dev/null +++ b/src/TimerTest.java @@ -0,0 +1,108 @@ + + interface TimerClient { + public void timerCallback(); + } + + public class TimerTest implements TimerClient + { + double numSeconds = 4.5; + double pollDelay = 0.25; + int numPolls = 0; + int numExpectedPolls = (int)(numSeconds / pollDelay) - 1; // last poll will work! + boolean timerExpired = false; + + public void timerCallback() { + timerExpired = true; + } + public static void main(String[] args) + { + TimerTest test = new TimerTest(); + test.runPollTest(); + + test.runInterruptTest(); + } + public void runPollTest() { + pollDelay *= 1000; + System.out.println("Testing using poll method:"); + System.out.println("\tTest will sleep for " + + pollDelay + "ms then poll timer to see if expired."); + System.out.println("\tEach poll will print a dot."); + + System.out.println("\tCreating " + numSeconds + " second timer..."); + Timer t = new Timer((int)(numSeconds*1000)); + + System.out.println("\tStarting timer..."); + System.out.print("\t"); + t.start(); + + while(true) + { + try + { + Thread.sleep((int)pollDelay); + + } + catch(Exception e) + { + } + + if(! t.expired()) + { + numPolls++; + System.out.print("."); + } + else + { + break; + } + } + System.out.println(); + System.out.println("\tNumber of polls was " + numPolls); + System.out.println("\tNumber of expected polls was " + numExpectedPolls); + if (numExpectedPolls == numPolls) + System.out.println("Poll Test PASSED!"); + else if (numExpectedPolls-1 <= numPolls && numPolls <= numExpectedPolls+1) + System.out.println("Poll Test PASSED! (small timing variance between threads is allowed)"); + else + System.out.println("Poll Test FAILED!"); + } + + public void runInterruptTest() { + numPolls = 0; + System.out.println("Testing using interrupt method:"); + System.out.println("\tTest will sleep for " + + pollDelay + "ms and then awake and print a dot."); + System.out.println("\tWhen timer expires it will interrupt causing sleeping to stop."); + + System.out.println("\tCreating " + numSeconds + " second timer..."); + Timer t = new Timer((int)(numSeconds*1000), this); // pass object with callback method + + System.out.println("\tStarting timer..."); + System.out.print("\t"); + t.start(); + + while(! timerExpired) + { + try + { + Thread.sleep((int)pollDelay); + + } + catch(Exception e) + { + } + + numPolls++; + System.out.print("."); + } + System.out.println(); + System.out.println("\tNumber of sleeps was " + numPolls); + System.out.println("\tNumber of expected sleeps was " + numExpectedPolls); + if (numExpectedPolls == numPolls) + System.out.println("Interrupt Test PASSED!"); + else if (numExpectedPolls-1 <= numPolls && numPolls <= numExpectedPolls+1) + System.out.println("Interrupt Test PASSED! (small timing variance between threads is allowed)"); + else + System.out.println("Interrupt Test FAILED!"); + } + } diff --git a/tests/Tests.java b/tests/Tests.java index c0b466d..cb07d74 100644 --- a/tests/Tests.java +++ b/tests/Tests.java @@ -1,7 +1,12 @@ import static org.junit.Assert.*; import org.junit.Test; -public class Tests +//brought in from TimerTest.java +interface TimerClient { + public void timerCallback(); +} + +public class Tests implements TimerClient { /** * Author: Elijah Smith @@ -9,10 +14,10 @@ public class Tests */ @Test public void testMoveDown() { - Elevator elevator = new Elevator(5, 1, 5); + Elevator elevator = new Elevator(5, 5); elevator.moveDown(); int newCurrent = elevator.getCurrentFloor(); - assertEquals(1, newCurrent); + assertEquals(4, newCurrent); } /** @@ -21,13 +26,194 @@ public void testMoveDown() { */ @Test public void testMoveUp() { - Elevator elev = new Elevator(1, 5, 5); + Elevator elev = new Elevator(1, 5); elev.moveUp(); int newCurrent = elev.getCurrentFloor(); - assertEquals(1, newCurrent); + assertEquals(2, newCurrent); } + + + //simple values needed for Timer + double numSeconds = 4.5; + double pollDelay = 0.25; + int numPolls = 0; + int numExpectedPolls = (int)(numSeconds / pollDelay) - 1; // last poll will work! + boolean timerExpired = false; + boolean state = false; + //method needed for TimerClient + public void timerCallback() { + timerExpired = true; + } + + /** + * Author: Elijah Smith + */ + public void runPollTest() { + pollDelay *= 1000; + System.out.println("Testing using poll method:"); + System.out.println("\tTest will sleep for " + + pollDelay + "ms then poll timer to see if expired."); + System.out.println("\tEach poll will print a dot."); + + System.out.println("\tCreating " + numSeconds + " second timer..."); + Timer t = new Timer((int)(numSeconds*1000)); + System.out.println("\tStarting timer..."); + System.out.print("\t"); + t.start(); + + while(true) + { + try + { + Thread.sleep((int)pollDelay); + + } + catch(Exception e) + { + } + + if(!t.expired()) + { + numPolls++; + System.out.print("."); + } + else + { + break; + } + } + System.out.println(); + System.out.println("\tNumber of polls was " + numPolls); + System.out.println("\tNumber of expected polls was " + numExpectedPolls); + if (numExpectedPolls == numPolls) { + System.out.println("Poll Test PASSED!"); + assertEquals(numExpectedPolls, numPolls); + } + else if (numExpectedPolls-1 <= numPolls && numPolls <= numExpectedPolls+1) { + System.out.println("Poll Test PASSED! (small timing variance between threads is allowed)"); + state = true; + assertTrue(state); + } + else { + System.out.println("Poll Test FAILED!"); + assertTrue(state); + } + } + /** + * Author: Elijah Smith + * test for getElevators() method + */ + @Test + public void testGetElevators() { + Controller control = new DefaultController(10, 2); + Elevator[] elevArray = control.getElevators(); + Elevator elev1 = elevArray[0]; + Elevator elev2 = elevArray[1]; + + assertEquals(elev1, elev2); + } + + + /** + * Author: Elijah Smith + * pushUp() method test now in Controller + */ + @Test + public void testPushUp() { + Controller control = new DefaultController(10, 2); + control.pushUp(0); + control.pushUp(2); + control.pushUp(3); + + boolean[] pushedUpArray = control.getPushedUpArray(); + boolean pushedUp1 = pushedUpArray[0]; + boolean pushedUp2 = pushedUpArray[2]; + boolean pushedUp3 = pushedUpArray[3]; + + assertEquals(true, pushedUp1); + assertEquals(true, pushedUp2); + assertEquals(true, pushedUp3); + } + + /** + * Author: Elijah Smith + * pushDown() method test now in Controller + */ + @Test + public void testPushDown() { + Controller control = new DefaultController(10, 2); + control.pushDown(5); + control.pushDown(7); + control.pushDown(3); + + boolean[] pushedUpArray = control.getPushedUpArray(); + boolean pushedDown1 = pushedUpArray[5]; + boolean pushedDown2 = pushedUpArray[7]; + boolean pushedDown3 = pushedUpArray[3]; + + assertEquals(true, pushedDown1); + assertEquals(true, pushedDown2); + assertEquals(true, pushedDown3); + } + + + /** + * Author: Elijah Smith + * test brought from TimerTest.java + */ + /* + @Test + public void runInterruptTest() { + numPolls = 0; + System.out.println("Testing using interrupt method:"); + System.out.println("\tTest will sleep for " + + pollDelay + "ms and then awake and print a dot."); + System.out.println("\tWhen timer expires it will interrupt causing sleeping to stop."); + + System.out.println("\tCreating " + numSeconds + " second timer..."); + Timer t = new Timer((int)(numSeconds*1000), this); // pass object with callback method + + System.out.println("\tStarting timer..."); + System.out.print("\t"); + t.start(); + + while(! timerExpired) + { + try + { + Thread.sleep((int)pollDelay); + + } + catch(Exception e) + { + } + + numPolls++; + System.out.print("."); + } + System.out.println(); + System.out.println("\tNumber of sleeps was " + numPolls); + System.out.println("\tNumber of expected sleeps was " + numExpectedPolls); + + if (numExpectedPolls == numPolls) { + System.out.println("Interrupt Test PASSED!"); + assertEquals(numExpectedPolls, numPolls); + } + else if (numExpectedPolls-1 <= numPolls && numPolls <= numExpectedPolls+1) { + System.out.println("Interrupt Test PASSED! (small timing variance between threads is allowed)"); + state = true; + assertTrue(state); + } + else { + state = false; + System.out.println("Interrupt Test FAILED!"); + assertTrue(state); + } + } + */ + /** * Author: Elijah Smith * @@ -35,26 +221,97 @@ public void testMoveUp() { @Test public void testCurrentFloor() { int currentFloor = 60; - int destinationFloor = 420; int totalFloors = 600; - Elevator elevator = new Elevator(currentFloor, destinationFloor, totalFloors); + Elevator elevator = new Elevator(currentFloor, totalFloors); + + assertEquals(60, elevator.getCurrentFloor()); + } + + @Test + public void testElevatorConstructor1() { + Elevator elev = new Elevator(100); + + assertEquals(1, elev.getCurrentFloor()); + assertEquals(100, elev.getNumberOfFloors()); + } + + /** + * Author: Elijah Smith + */ + @Test + public void testElevatorConstructor2() { + Elevator elev = new Elevator(2, 100); + + assertEquals(2, elev.getCurrentFloor()); + assertEquals(100, elev.getNumberOfFloors()); + + } + + +/** + * Author: Elijah Smith + * New test for next() within Passenger + */ + @Test + public void testPassengerNext1() + { + Controller control = new DefaultController(10, 2); + + Passenger pass = new Passenger(control, 7, 10); + Passenger pass2 = new Passenger(control, 2, 1); + + pass.next(); + pass.next(); + + assertEquals(2, control.pushTrue()); + } + + @Test + public void testHasDestFloor() + { + Elevator elev = new Elevator(1, 10); + + assertEquals(0, elev.hasDestFloors()); + + elev.addDestinationFloor(7); + + assertEquals(1, elev.hasDestFloors()); } @Test - public void testPassengerConstructor1() + public void testpushTrue() { - Passenger pass = new Passenger(3, 10); - - assertEquals(3, pass.getStartFloor()); - assertEquals(10, pass.getDestinationFloor()); + Elevator[] elevators = new Elevator[2]; + DefaultController control = new DefaultController(10, 0); + assertEquals(0, control.pushTrue()); } + + @Test + public void testpushTrue1() + { + Controller control = new DefaultController(10,3); + control.pushUp(1); + control.pushUp(3); + control.pushDown(8); + + int count = control.pushTrue(); + + assertEquals(3, count); + } + +/* needs to change @Test - public void testPassengerConstructor2() + public void testDefaultController1() { - Passenger pass = new Passenger(50); + Elevator[] elevators = new Elevator[2]; + elevators[0] = new Elevator(1, 10); + DefaultController control = new DefaultController(elevators[0]); + + elev.pushUp(5); + control.next(); - assertEquals(1, pass.getStartFloor()); - assertEquals(50, pass.getDestinationFloor()); + assertEquals(2, elev.getCurrentFloor()); } +*/ }