Пример #1
0
  /**
   * Tests numberOfSeats with no Cars
   *
   * @throws TrainException
   */
  @Test
  public void testNumberOfSeats_NoCars() throws TrainException {
    final Integer EXPECTED_SEATS = 0;

    DepartingTrain departingTrain = new DepartingTrain();
    assertEquals(departingTrain.numberOfSeats(), EXPECTED_SEATS);
  }
Пример #2
0
 /**
  * Tests Train Successfully Added
  *
  * @throws TrainException
  */
 @Test
 public void testAddCarriage() throws TrainException {
   final Locomotive LOCO = new Locomotive(90, "4S");
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(LOCO);
   assertEquals(departingTrain.firstCarriage(), LOCO);
 }
Пример #3
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that when passengers board, the
   *     individual cars are filling up, not just a total number on the whole train
   */
  @Test
  public void testIndividualPassengerCarsAreBeingAddedTo() throws TrainException {
    final Integer SEATS = 20;
    final Integer PASSENGERS = 79;
    final Integer GROSS_WEIGHT = 90;
    final Integer ZERO_PASSENGERS = 0;
    final String CLASSIFICATION = "4S";

    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final PassengerCar PASSENGER_01 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER_02 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER_03 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER_04 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(PASSENGER_01);
    departingTrain.addCarriage(PASSENGER_02);
    departingTrain.addCarriage(PASSENGER_03);
    departingTrain.addCarriage(PASSENGER_04);

    departingTrain.board(PASSENGERS);

    assertTrue(PASSENGER_01.numberOnBoard() > ZERO_PASSENGERS);
    assertTrue(PASSENGER_02.numberOnBoard() > ZERO_PASSENGERS);
    assertTrue(PASSENGER_03.numberOnBoard() > ZERO_PASSENGERS);
    assertTrue(PASSENGER_04.numberOnBoard() > ZERO_PASSENGERS);
  }
Пример #4
0
  /**
   * Test Multiple Carriages toString no passengers
   *
   * @throws TrainException
   */
  @Test
  public void testToStringMultipleCarriageNoPassengers() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String GOODS_TYPE = "G";
    final Integer SEATS = 20;
    final Integer PASSENGERS = 0;
    final String CLASSIFICATION = "4S";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);
    final PassengerCar PASSENGER = new PassengerCar(GROSS_WEIGHT, SEATS);

    final String TO_STRING =
        "Loco("
            + CLASSIFICATION
            + ")-Passenger("
            + PASSENGERS
            + "/"
            + SEATS
            + ")-Freight("
            + GOODS_TYPE
            + ")";

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER);
    departingTrain.addCarriage(FREIGHT);

    assertEquals(TO_STRING, departingTrain.toString());
  }
Пример #5
0
 /**
  * Tests First Carriage is a Locomotive
  *
  * @throws TrainException
  */
 @Test(expected = TrainException.class)
 public void testLocoFirstFalse() throws TrainException {
   final Locomotive LOCO = new Locomotive(90, "4S");
   final FreightCar FREIGHT = new FreightCar(90, "G");
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(FREIGHT);
   departingTrain.addCarriage(LOCO);
 }
Пример #6
0
 /**
  * Tests First Carriage is a Locomotive
  *
  * @throws TrainException
  */
 @Test
 public void testLocoFirstTrue() throws TrainException {
   final Locomotive LOCO = new Locomotive(90, "4S");
   final FreightCar FREIGHT = new FreightCar(90, "G");
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(LOCO);
   departingTrain.addCarriage(FREIGHT);
   assertEquals(departingTrain.firstCarriage(), LOCO);
 }
Пример #7
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that an exception is thrown if a
   *     passenger car is added before a locomotive
   * @throws TrainException
   */
  @Test(expected = TrainException.class)
  public void testAddPassengerCarToEmptyTrain() throws TrainException {
    final Integer SEATS = 20;
    final Integer GROSS_WEIGHT = 90;
    final PassengerCar PASSENGERCAR_01 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(PASSENGERCAR_01);
  }
Пример #8
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that an exception is thrown if a freight
   *     car is added before a locomotive
   * @throws TrainException
   */
  @Test(expected = TrainException.class)
  public void testAddFreightCarToEmptyTrain() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String GOODS_TYPE = "G";
    final FreightCar FREIGHT_CAR = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(FREIGHT_CAR);
  }
Пример #9
0
 /**
  * Tests Add PassengerCar to Departing Train with Loco, Freight
  *
  * @throws TrainException
  */
 @Test(expected = TrainException.class)
 public void testAddPassengerToLocoFreight() throws TrainException {
   final Locomotive LOCO = new Locomotive(90, "4S");
   final FreightCar FREIGHT = new FreightCar(90, "G");
   final PassengerCar PASSENGER = new PassengerCar(90, 20);
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(LOCO);
   departingTrain.addCarriage(FREIGHT);
   departingTrain.addCarriage(PASSENGER);
 }
Пример #10
0
 /**
  * Tests Add PassengerCar to Departing Train with Loco Only
  *
  * @throws TrainException
  */
 @Test
 public void testAddPassenger() throws TrainException {
   final Locomotive LOCO = new Locomotive(90, "4S");
   final PassengerCar PASSENGER = new PassengerCar(90, 20);
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(LOCO);
   departingTrain.addCarriage(PASSENGER);
   assertEquals(departingTrain.firstCarriage(), LOCO);
   assertEquals(departingTrain.nextCarriage(), PASSENGER);
 }
Пример #11
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that trainCanMove() returns false when
   *     appropriate
   * @throws TrainException
   */
  @Test
  public void testTrainCanMoveFalseOneCarriage() throws TrainException {
    final Integer GROSS_WEIGHT = 590;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    assertFalse(departingTrain.trainCanMove());
  }
Пример #12
0
  /**
   * Test Get First Carriage on a Train with a Single Carriage
   *
   * @throws TrainException
   */
  @Test
  public void testGetFirstCarriage_SingleCarriage() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);

    assertEquals(departingTrain.firstCarriage(), LOCO);
  }
Пример #13
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that a locomotive at the end will be
   *     successfully removed
   * @throws TrainException
   */
  @Test
  public void testRemoveCarriageLastCarriageLoco() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.removeCarriage();
    assertNull(departingTrain.firstCarriage());
  }
Пример #14
0
 /**
  * Tests Add Carriage while Passengers Aboard
  *
  * @throws TrainException
  */
 @Test(expected = TrainException.class)
 public void testAddCarAfterBoarding() throws TrainException {
   final Integer PASSENGERS = 20;
   final Locomotive LOCO = new Locomotive(90, "4S");
   final FreightCar FREIGHT = new FreightCar(90, "G");
   final PassengerCar PASSENGER = new PassengerCar(90, PASSENGERS);
   DepartingTrain departingTrain = new DepartingTrain();
   departingTrain.addCarriage(LOCO);
   departingTrain.addCarriage(PASSENGER);
   departingTrain.board(PASSENGERS);
   departingTrain.addCarriage(FREIGHT);
 }
Пример #15
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that an exception is thrown when two
   *     locomotives are attempted to be added to one train
   * @throws TrainException
   */
  @Test(expected = TrainException.class)
  public void testTwoLocomotivesCannotBeAdded() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";

    final Locomotive LOCOMOTIVE_01 = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final Locomotive LOCOMOTIVE_02 = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE_01);
    departingTrain.addCarriage(LOCOMOTIVE_02);
  }
Пример #16
0
  /**
   * Test single carriage ToString
   *
   * @throws TrainException
   */
  @Test
  public void testToStringSingleCarriage() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final String TO_STRING = "Loco(4S)";

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCO);

    assertEquals(TO_STRING, departingTrain.toString());
  }
Пример #17
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that trainCanMove() returns false when
   *     appropriate with multiple carriages
   * @throws TrainException
   */
  @Test
  public void testTrainCanMoveFalseMultipleCarriages() throws TrainException {
    final Integer SEATS = 20;
    final Integer GROSS_WEIGHT = 290;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final PassengerCar PASSENGERCAR_01 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(PASSENGERCAR_01);

    assertFalse(departingTrain.trainCanMove());
  }
Пример #18
0
  /**
   * Tests numberOfSeats with no PassengerCars
   *
   * @throws TrainException
   */
  @Test
  public void testNumberOfSeats_NoPassengerCars() throws TrainException {
    final Integer EXPECTED_SEATS = 0;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";
    final String GOODS_TYPE = "G";
    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(FREIGHT);

    assertEquals(departingTrain.numberOfSeats(), EXPECTED_SEATS);
  }
Пример #19
0
  /**
   * Test Boarding Passengers to a Valid Train with negative boarding passengers
   *
   * @throws TrainException
   */
  @Test(expected = TrainException.class)
  public void testBoardPassengersValidTrainNegative() throws TrainException {
    final Integer PASSENGERS = -20;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final PassengerCar PASSENGER = new PassengerCar(GROSS_WEIGHT, PASSENGERS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER);
    @SuppressWarnings("unused")
    Integer noSeats = departingTrain.board(PASSENGERS);
  }
Пример #20
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that an exception is thrown if a
   *     carriage is attempted to be removed when there are passengers on the train
   * @throws TrainException
   */
  @Test(expected = TrainException.class)
  public void testRemoveCarriagePassengersOnTrain() throws TrainException {
    final Integer SEATS = 20;
    final Integer PASSENGERS = 19;
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final PassengerCar PASSENGERCAR_01 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(PASSENGERCAR_01);
    departingTrain.board(PASSENGERS);
    departingTrain.removeCarriage();
  }
Пример #21
0
  /**
   * Test Boarding Passengers to a Valid Train
   *
   * @throws TrainException
   */
  @Test
  public void testBoardPassengersValidTrainPositive() throws TrainException {
    final Integer PASSENGERS = 20;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final PassengerCar PASSENGER = new PassengerCar(GROSS_WEIGHT, PASSENGERS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER);
    @SuppressWarnings("unused")
    Integer noSeats = departingTrain.board(PASSENGERS);
    assertEquals(departingTrain.numberOnBoard(), PASSENGERS);
  }
Пример #22
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that a freight car at the end will be
   *     successfully removed
   * @throws TrainException
   */
  @Test
  public void testRemoveCarriageLastCarriageFreight() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";
    final String GOODS_TYPE = "G";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final FreightCar FREIGHTCAR = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(FREIGHTCAR);
    departingTrain.removeCarriage();
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertNull(departingTrain.nextCarriage());
  }
Пример #23
0
  /**
   * Test Boarding Passengers to a Invalid Train
   *
   * @throws TrainException
   */
  @Test
  public void testBoardPassengersInvalidTrain() throws TrainException {
    final Integer PASSENGERS = 20;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";
    final String GOODS_TYPE = "G";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(FREIGHT);
    Integer noSeats = departingTrain.board(PASSENGERS);

    assertEquals(noSeats, PASSENGERS);
  }
Пример #24
0
  /**
   * Test Boarding To Many Passengers to a Valid Train
   *
   * @throws TrainException
   */
  @Test
  public void testBoardTooManyPassengersValidTrain() throws TrainException {
    final Integer SEATS = 20;
    final Integer PASSENGERS = 40;
    final Integer EXPECTED_OVER = PASSENGERS - SEATS;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final PassengerCar PASSENGER = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER);
    Integer noSeats = departingTrain.board(PASSENGERS);
    assertEquals(noSeats, EXPECTED_OVER);
  }
Пример #25
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that firstCarriage() method calls always
   *     returns the correct first carriage
   * @throws TrainException
   */
  @Test
  public void testFirstCarriageAlwaysReturnsFirstCarriage() throws TrainException {
    final Integer SEATS = 20;
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";

    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final PassengerCar PASSENGERCAR_01 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGERCAR_02 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGERCAR_03 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGERCAR_04 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(PASSENGERCAR_01);
    departingTrain.addCarriage(PASSENGERCAR_02);
    departingTrain.addCarriage(PASSENGERCAR_03);
    departingTrain.addCarriage(PASSENGERCAR_04);

    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
  }
Пример #26
0
  /**
   * Test Get First Carriage on a Train with Multiple Carriages
   *
   * @throws TrainException
   */
  @Test
  public void testGetFirstCarriage_MultipleCarriage() throws TrainException {
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";
    final Integer SEATS = 20;
    final String GOODS_TYPE = "G";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final PassengerCar PASSENGER = new PassengerCar(GROSS_WEIGHT, SEATS);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER);
    departingTrain.addCarriage(FREIGHT);

    assertEquals(departingTrain.firstCarriage(), LOCO);
  }
Пример #27
0
  /**
   * Tests numberOfSeats with more than two PassengerCars Verifies code is dynamic to handle
   * multiples
   *
   * @throws TrainException
   */
  @Test
  public void testNumberOfSeats_MultiplePassengerCar() throws TrainException {
    final Integer SEATS = 20;
    final Integer EXPECTED_SEATS = SEATS * 4;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";
    final String GOODS_TYPE = "G";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final PassengerCar PASSENGER01 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER02 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER03 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER04 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER01);
    departingTrain.addCarriage(PASSENGER02);
    departingTrain.addCarriage(PASSENGER03);
    departingTrain.addCarriage(PASSENGER04);
    departingTrain.addCarriage(FREIGHT);

    assertEquals(departingTrain.numberOfSeats(), EXPECTED_SEATS);
  }
Пример #28
0
  /**
   * @author Robert Dempsey, Student Number: N5400872 Tests that a passenger car at the end will be
   *     successfully removed
   * @throws TrainException
   */
  @Test
  public void testRemoveCarriageLastCarriagePassenger() throws TrainException {
    final Integer SEATS = 20;
    final Integer GROSS_WEIGHT = 90;
    final String CLASSIFICATION = "4S";
    final Locomotive LOCOMOTIVE = new Locomotive(GROSS_WEIGHT, CLASSIFICATION);
    final PassengerCar PASSENGERCAR_01 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();

    departingTrain.addCarriage(LOCOMOTIVE);
    departingTrain.addCarriage(PASSENGERCAR_01);
    departingTrain.removeCarriage();
    assertEquals(LOCOMOTIVE, departingTrain.firstCarriage());
    assertNull(departingTrain.nextCarriage());
  }
Пример #29
0
  /**
   * Test Boarding Passengers to a Valid Combo Train with multiple PassengerCar carriages and single
   * FreightCar carriages
   *
   * @throws TrainException
   */
  @Test
  public void testBoardPassengersValidComboTrainPassengerMultiple() throws TrainException {
    final Integer SEATS = 20;
    final Integer PASSENGERS = SEATS * 2;
    final Integer GROSS_WEIGHT = 90;
    final String POWER_CLASS = "4S";
    final String GOODS_TYPE = "G";

    final Locomotive LOCO = new Locomotive(GROSS_WEIGHT, POWER_CLASS);
    final FreightCar FREIGHT = new FreightCar(GROSS_WEIGHT, GOODS_TYPE);
    final PassengerCar PASSENGER01 = new PassengerCar(GROSS_WEIGHT, SEATS);
    final PassengerCar PASSENGER02 = new PassengerCar(GROSS_WEIGHT, SEATS);

    DepartingTrain departingTrain = new DepartingTrain();
    departingTrain.addCarriage(LOCO);
    departingTrain.addCarriage(PASSENGER01);
    departingTrain.addCarriage(PASSENGER02);
    departingTrain.addCarriage(FREIGHT);
    @SuppressWarnings("unused")
    Integer noSeats = departingTrain.board(PASSENGERS);
    assertEquals(departingTrain.numberOnBoard(), PASSENGERS);
  }
Пример #30
0
 /**
  * Tests that an empty train returns nothing
  *
  * @throws TrainException
  */
 @Test
 public void testToStringNull() throws TrainException {
   DepartingTrain departingTrain = new DepartingTrain();
   assertNull(departingTrain.toString());
 }