/*
   * childSpc created in setUp()
   */
  @Test
  public void testGetDispatches() throws Exception {
    String name = "testGetDispatches" + r.nextInt();
    SiteWrapper destSite = SiteHelper.addSite(name);
    ShippingMethodWrapper method = ShippingMethodWrapper.getShippingMethods(appService).get(0);
    DispatchWrapper d = DispatchHelper.addDispatch(site, destSite, method);

    d.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);
    d.persist();
    childSpc.reload();

    List<DispatchWrapper> specimenDispatches = childSpc.getDispatches();
    Assert.assertEquals(1, specimenDispatches.size());
    Assert.assertTrue(specimenDispatches.contains(d));

    Assert.assertTrue(d.isInCreationState());

    // site send specimens
    d.setState(DispatchState.IN_TRANSIT);
    d.persist();
    Assert.assertTrue(d.isInTransitState());

    // dest site receive specimen
    d.setState(DispatchState.RECEIVED);
    d.receiveSpecimens(Arrays.asList(childSpc));
    d.persist();
    Assert.assertTrue(d.isInReceivedState());

    // make sure spc now belongs to destSite
    destSite.reload();
    childSpc.reload();
    Assert.assertEquals(destSite, childSpc.getCurrentCenter());

    // dispatch specimen to second site
    SiteWrapper destSite2 = SiteHelper.addSite(name + "_2");

    DispatchWrapper d2 = DispatchHelper.addDispatch(destSite, destSite2, method);
    d2.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);

    parentSpc.reload();
    // assign a position to this specimen
    ContainerTypeWrapper topType =
        ContainerTypeHelper.addContainerType(destSite, "ct11", "ct11", 1, 5, 6, true);
    ContainerWrapper topCont = ContainerHelper.addContainer("11", "11", destSite, topType);
    ContainerTypeWrapper childType =
        ContainerTypeHelper.addContainerType(destSite, "ct22", "ct22", 2, 4, 7, false);
    topType.addToChildContainerTypeCollection(Arrays.asList(childType));
    topType.persist();
    ContainerWrapper cont =
        ContainerHelper.addContainer("22", "22", topCont, destSite, childType, 4, 5);
    childType.addToSpecimenTypeCollection(Arrays.asList(childSpc.getSpecimenType()));
    childType.persist();
    cont.reload();
    cont.addSpecimen(2, 3, childSpc);
    parentSpc.persist();

    // add to new dispatch
    d2.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);
    d2.persist();

    // make sure spc still belongs to destSite
    destSite2.reload();
    childSpc.reload();
    Assert.assertEquals(destSite2, childSpc.getCurrentCenter());

    childSpc.reload();
    specimenDispatches = childSpc.getDispatches();
    Assert.assertEquals(2, specimenDispatches.size());
    Assert.assertTrue(specimenDispatches.contains(d));
    Assert.assertTrue(specimenDispatches.contains(d2));
  }
  @Test
  public void testDebugRandomMethods() throws Exception {
    System.out.println(parentSpc.getProcessingEvent());
    System.out.println(childSpc.getProcessingEvent());

    ContainerWrapper container = childSpc.getParentContainer();
    ContainerTypeWrapper containerType = container.getContainerType();
    SpecimenTypeWrapper spcType = containerType.getSpecimenTypeCollection(false).get(0);
    Assert.assertNotNull(spcType);

    System.out.println(parentSpc.getProcessingEvent());
    System.out.println(childSpc.getProcessingEvent());

    ProcessingEventWrapper pevent =
        ProcessingEventHelper.addProcessingEvent(
            childSpc.getCurrentCenter(), Utils.getRandomDate());

    // add aliquoted specimen
    SpecimenWrapper specimen =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            3);
    specimen.setInventoryId(Utils.getRandomString(5));
    specimen.persist();

    pevent.addToSpecimenCollection(Arrays.asList(parentSpc));
    pevent.persist();

    SpecimenWrapper s2 =
        SpecimenHelper.newSpecimen(
            childSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            4);
    s2.setParent(null, null);
    s2.setParentSpecimen(null);
    s2.persist();

    try {
      // should find at least one specimen with a parent that is inside a
      // processing event
      Assert.assertTrue(
          DebugUtil.getRandomLinkedAliquotedSpecimens(appService, site.getId()).size() > 0);
      Assert.assertTrue(DebugUtil.getRandomAssignedSpecimens(appService, site.getId()).size() > 0);
      List<SpecimenWrapper> randomNonAssociatedNonDispatchedSpecimens =
          DebugUtil.getRandomNonAssignedNonDispatchedSpecimens(appService, site.getId(), 10);
      Assert.assertTrue(randomNonAssociatedNonDispatchedSpecimens.size() > 0);
    } catch (Exception e) {
      Assert.fail(e.getCause().getMessage());
    }

    try {
      s2.delete();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }