@Test
  public void testCheckForInputs() throws Exception {

    assertTrue(crs.checkForInputs()); // the setup has no input need
    crs.getModel()
        .schedule
        .scheduleOnce(
            Schedule.EPOCH,
            new Person(crs.getModel())); // this is to have the steppable not at time -1
    crs.getModel().schedule.step(crs.getModel());

    Blueprint b =
        Blueprint.simpleBlueprint(
            DifferentiatedGoodType.CAPITAL,
            1,
            DifferentiatedGoodType.CAPITAL,
            2); // addSalesDepartmentListener one for input
    crs.setBlueprint(b); // set it as blueprint
    assertFalse(crs.checkForInputs()); // you should miss one
    crs.getOwner()
        .receive(
            Good.getInstanceOfDifferentiatedGood(DifferentiatedGoodType.CAPITAL, drs.getOwner(), 1),
            drs.getOwner()); // receive it
    // this automatically steps production (because it's inventory listener!)

    assertTrue(crs.checkForInputs()); // all good now
  }
  @Test
  public void testStep() throws Exception {

    Blueprint b =
        Blueprint.simpleBlueprint(
            DifferentiatedGoodType.CAPITAL, 1, DifferentiatedGoodType.CAPITAL, 1);
    MacroII localMacroII = new MacroII(1);
    localMacroII.schedule =
        mock(Schedule.class); // put in a fake schedule so we avoid steppables firing at random

    Firm f = new Firm(localMacroII);
    Plant localCRS = new Plant(b, new Firm(localMacroII));
    localCRS.setPlantMachinery(
        new CRSExponentialMachinery(DifferentiatedGoodType.CAPITAL, f, 0, localCRS, 1f, 1f));
    f.addPlant(localCRS);

    SalesDepartmentAllAtOnce stub = mock(SalesDepartmentAllAtOnce.class);
    when(stub.isSelling(any(Good.class))).thenReturn(Boolean.TRUE);
    localCRS.getOwner().registerSaleDepartment(stub, DifferentiatedGoodType.CAPITAL); // fake sales
    // department so that you don't try selling the stuff you build

    localCRS.setCostStrategy(new EmptyCostStrategy());
    try {
      localCRS.getModel();

      localCRS.getModel().getPhaseScheduler().step(localCRS.getModel());

      assertEquals(localCRS.getStatus(), PlantStatus.WAITING_FOR_WORKERS);
      localCRS.addWorker(new Person(localCRS.getModel()));
      localCRS.addWorker(new Person(localCRS.getModel()));

      localCRS.getModel().getPhaseScheduler().step(localCRS.getModel());

      assertEquals(localCRS.getStatus(), PlantStatus.WAITING_FOR_INPUT);
      localCRS
          .getOwner()
          .receive(
              Good.getInstanceOfDifferentiatedGood(
                  DifferentiatedGoodType.CAPITAL, drs.getOwner(), 1),
              drs.getOwner());

      localCRS.getModel().getPhaseScheduler().step(localCRS.getModel());
      assertEquals(
          localCRS.getStatus(), PlantStatus.READY); // you should automatically start production!

    } catch (Exception e) {
      fail("Can't throw exceptions now");
    }
  }
  @Test
  public void testProduce() throws Exception {

    macro.schedule = new Schedule(); // create a real schedule, please.
    assertTrue(crs.getModel().schedule.scheduleComplete()); // the schedule should be empty!
    assertTrue(!crs.getOwner().hasAny(DifferentiatedGoodType.CAPITAL));
    assertTrue(crs.getOwner().hasHowMany(DifferentiatedGoodType.CAPITAL) == 0);

    crs.getModel().schedule.reset();
    crs.getModel()
        .schedule
        .scheduleOnce(
            Schedule.EPOCH,
            new Person(crs.getModel())); // this is to have the steppable not at time -1
    crs.setCostStrategy(new EmptyCostStrategy());
    //    crs.completeProductionRunNow();

    crs.startProductionRun();
    // System.out.println(crs.getModel().schedule.getTime());
    assertEquals(crs.getStatus(), PlantStatus.READY);

    assertTrue(crs.getOwner().hasAny(DifferentiatedGoodType.CAPITAL));
    assertTrue(crs.getOwner().hasHowMany(DifferentiatedGoodType.CAPITAL) == 2);

    // here we produced 2

    crs.setBlueprint(
        Blueprint.simpleBlueprint(
            DifferentiatedGoodType.CAPITAL,
            2,
            DifferentiatedGoodType.CAPITAL,
            1)); // dumb technology to test inputs
    crs.startProductionRun();
    assertEquals(crs.getStatus(), PlantStatus.READY);
    assertTrue(
        crs.getOwner().hasAny(DifferentiatedGoodType.CAPITAL)); // should still have the stuff
    assertTrue(
        crs.getOwner().hasHowMany(DifferentiatedGoodType.CAPITAL) == 1); // burned two, made one
    crs.startProductionRun();
    assertEquals(crs.getStatus(), PlantStatus.WAITING_FOR_INPUT);
    assertTrue(crs.getOwner().hasAny(DifferentiatedGoodType.CAPITAL)); // no change!
    assertTrue(crs.getOwner().hasHowMany(DifferentiatedGoodType.CAPITAL) == 1);

    // check that the counts are right
    Assert.assertEquals(crs.getOwner().getTodayConsumption(DifferentiatedGoodType.CAPITAL), 2);
    Assert.assertEquals(crs.getOwner().getTodayProduction(DifferentiatedGoodType.CAPITAL), 3);
  }
  @Test
  public void testTotalInputs() {

    Blueprint b = Blueprint.simpleBlueprint(DifferentiatedGoodType.CAPITAL, 1, BEEF, 1);
    MacroII localMacroII = mock(MacroII.class);
    PhaseScheduler scheduler = mock(PhaseScheduler.class);
    when(localMacroII.getCurrentPhase()).thenReturn(ActionOrder.PRODUCTION);
    when(localMacroII.getPhaseScheduler()).thenReturn(scheduler);
    when(localMacroII.getWeekLength()).thenReturn(7f);
    Firm f = new Firm(localMacroII);
    Plant localCRS = new Plant(b, new Firm(localMacroII));
    localCRS.setPlantMachinery(
        new LinearConstantMachinery(DifferentiatedGoodType.CAPITAL, f, 0, localCRS));
    f.addPlant(localCRS);
    localCRS.addWorker(new Person(localCRS.getModel()));
    localCRS.addWorker(new Person(localCRS.getModel()));
    localCRS
        .getOwner()
        .registerSaleDepartment(
            mock(SalesDepartmentAllAtOnce.class),
            BEEF); // fake sales department so that you don't sell the stuff you
                   // completeProductionRunNow
    localCRS.setCostStrategy(new InputCostStrategy(localCRS));

    // initially they should be set up to 0
    assertEquals(localCRS.getThisWeekInputCosts(), 0);
    assertEquals(localCRS.getLastWeekInputCosts(), 0);

    // now when I step you, you should  say you are waiting for inputs
    localCRS.getModel();
    localCRS.step(localMacroII);
    assertEquals(localCRS.getStatus(), PlantStatus.WAITING_FOR_INPUT);
    assertEquals(localCRS.getThisWeekInputCosts(), 0); // input costs should still be 0
    assertEquals(localCRS.getLastWeekInputCosts(), 0);

    // now I give you one input that costs 10$
    localCRS
        .getOwner()
        .receive(
            Good.getInstanceOfDifferentiatedGood(
                DifferentiatedGoodType.CAPITAL, drs.getOwner(), 10),
            drs.getOwner());
    localCRS.step(localCRS.getModel());
    assertEquals(localCRS.getThisWeekInputCosts(), 10); // input costs should still now be 10
    assertEquals(localCRS.getLastWeekInputCosts(), 0);

    // I'll give you another and force you to step again
    localCRS
        .getOwner()
        .receive(
            Good.getInstanceOfDifferentiatedGood(
                DifferentiatedGoodType.CAPITAL, drs.getOwner(), 10),
            drs.getOwner());
    localCRS.step(localCRS.getModel());
    assertEquals(localCRS.getThisWeekInputCosts(), 20); // input costs should still now be 20
    assertEquals(localCRS.getLastWeekInputCosts(), 0);

    // with weekend it should reset this week and make lastweekinput costs equal 20
    localCRS.weekEnd(7);
    assertEquals(localCRS.getThisWeekInputCosts(), 0); // reset to 0
    assertEquals(localCRS.getLastWeekInputCosts(), 20); // now it's 20

    // try one more time
    localCRS
        .getOwner()
        .receive(
            Good.getInstanceOfDifferentiatedGood(
                DifferentiatedGoodType.CAPITAL, drs.getOwner(), 10),
            drs.getOwner());
    localCRS.step(localCRS.getModel());
    assertEquals(localCRS.getThisWeekInputCosts(), 10); // input costs should now be 10
    assertEquals(localCRS.getLastWeekInputCosts(), 20); // this should be stuck at 20

    // new weekend, forget 20$ and reset this week
    localCRS.weekEnd(14);
    assertEquals(localCRS.getThisWeekInputCosts(), 0); // reset to 0
    assertEquals(localCRS.getLastWeekInputCosts(), 10); // now it's 10

    // another weekend, everything is at 0
    localCRS.weekEnd(0);
    assertEquals(localCRS.getThisWeekInputCosts(), 0); // reset to 0
    assertEquals(localCRS.getLastWeekInputCosts(), 0); // now it's 10
  }