public void test() {

    TSMaster m0 = new TSMaster();
    m0.setName("m1");

    m0.addDetail(new TSDetail("m1 detail 1"));
    m0.addDetail(new TSDetail("m1 detail 2"));

    Ebean.save(m0);

    TSMaster master = Ebean.find(TSMaster.class, m0.getId());
    List<TSDetail> details = master.getDetails();

    TSDetail removedDetail = details.remove(1);

    BeanCollection<?> bc = (BeanCollection<?>) details;
    Set<?> modifyRemovals = bc.getModifyRemovals();

    Assert.assertNotNull(modifyRemovals);
    Assert.assertTrue(modifyRemovals.size() == 1);
    Assert.assertTrue(modifyRemovals.contains(removedDetail));

    Ebean.save(master);

    TSMaster masterReload = Ebean.find(TSMaster.class, m0.getId());
    List<TSDetail> detailsReload = masterReload.getDetails();

    // the removed bean has really been removed
    Assert.assertTrue(detailsReload.size() == 1);

    TSMaster master3 = Ebean.find(TSMaster.class, m0.getId());
    List<TSDetail> details3 = master3.getDetails();
    details3.clear();
  }
  /** Find a list/map/set of beans. */
  public <T> BeanCollection<T> findMany(OrmQueryRequest<T> request) {

    // flag indicating whether we need to close the resources...
    boolean useBackgroundToContinueFetch = false;

    CQuery<T> cquery = queryBuilder.buildQuery(request);
    request.setCancelableQuery(cquery);

    try {
      if (!cquery.prepareBindExecuteQuery()) {
        // query has been cancelled already
        logger.trace("Future fetch already cancelled");
        return null;
      }

      if (request.isLogSql()) {
        logSql(cquery);
      }

      BeanCollection<T> beanCollection = cquery.readCollection();

      BeanCollectionTouched collectionTouched = request.getQuery().getBeanCollectionTouched();
      if (collectionTouched != null) {
        // register a listener that wants to be notified when the
        // bean collection is first used
        beanCollection.setBeanCollectionTouched(collectionTouched);
      }

      if (cquery.useBackgroundToContinueFetch()) {
        // stop the request from putting connection back into pool
        // before background fetching is finished.
        request.setBackgroundFetching();
        useBackgroundToContinueFetch = true;
        BackgroundFetch fetch = new BackgroundFetch(cquery);

        FutureTask<Integer> future = new FutureTask<Integer>(fetch);
        beanCollection.setBackgroundFetch(future);
        backgroundExecutor.execute(future);
      }

      if (request.isLogSummary()) {
        logFindManySummary(cquery);
      }

      request.executeSecondaryQueries(defaultSecondaryQueryBatchSize);

      return beanCollection;

    } catch (SQLException e) {
      throw cquery.createPersistenceException(e);

    } finally {
      if (useBackgroundToContinueFetch) {
        // left closing resources to BackgroundFetch...
      } else {
        if (cquery != null) {
          cquery.close();
        }
        if (request.getQuery().isFutureFetch()) {
          // end the transaction for futureFindIds
          // as it had it's own transaction
          logger.debug("Future fetch completed!");
          request.getTransaction().end();
        }
      }
    }
  }