<!-- Manuscript.manContactInfos mapping -->
<bag cascade="all-delete-orphan" inverse="true" lazy="true"
            name="manContactInfos" table="MAN_CONTACT_INFO2">
            <key column="MANUSCRIPT_ID"/>
            <one-to-many class="org.aps.eop.model.manuscript.ManContactInfo"/>       
</bag>



public void testIsDirtyDoesFlush() {
       Session session = sessionFactory().openSession();
       session.setFlushMode(FlushMode.COMMIT);
          
       try {
          Manuscript m = (Manuscript)session.createQuery
                    ("from Manuscript m where accode = ?")
                    .setParameter(0, "CNR802").uniqueResult();
             
          int oldNumContactInfos = m.getManContactInfos().size();
             
          ManContactInfo contactInfo = new ManContactInfo();
           contactInfo.setAddress("an address");
           contactInfo.setManuscript(m);
              
           m.getManContactInfos().add(contactInfo);
           
           assertTrue(session.isDirty());
              
           Transaction tx = session.beginTransaction();
              
           m.getManContactInfos().remove(contactInfo);
              
           tx.commit();
           session.clear();
              
           m = (Manuscript)session.createQuery
                    ("from Manuscript m where accode = ?")
         .setParameter(0, "CNR802").uniqueResult();
              
           //this fails but shouldn't, if call to isDirty() is commented out it passes
              assertEquals(oldNumContactInfos, m.getManContactInfos().size());
          
       } finally {
          session.close();
       }
          
}

public void testIsDirtyDoesFlush4() {
      final Set inserted = new HashSet();
      final Set deleted = new HashSet();
      final Set updated = new HashSet();
      final Set postFlush = new HashSet();
      final Set preFlush = new HashSet();
   
      Interceptor interceptor = new EmptyInterceptor() {

         
         public boolean onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types) {
            updated.add(entity);
            return false;
         }

         public void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
            deleted.add(entity);
         }

         public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
             inserted.add(entity);
             return false;
         }

         public void postFlush(Iterator entities) {
            postFlush.add(new Object());
         }

         public void preFlush(Iterator entities) {
            preFlush.add(new Object());
         }

         
      };
      
      Session s = sessionFactory().openSession(interceptor);
      //s.setFlushMode(FlushMode.COMMIT);
      
      Manuscript m = (Manuscript)s.createQuery("from Manuscript m where accode = ?")
      .setParameter(0, "CNR802").uniqueResult();
      
      m.setPageCnt(m.getPageCnt() + 1);
      
      ManContactInfo contactInfo = new ManContactInfo();
      contactInfo.setManuscript(m);
      
      ManContactInfo contactInfo2 = new ManContactInfo();
      contactInfo2.setManuscript(m);

      m.setPageCnt(m.getPageCnt() + 1);
      
      try {
         assertTrue(s.isDirty());
         
         assertFalse(inserted.contains(contactInfo));
         assertFalse(inserted.contains(contactInfo2)); //not consistent with onFlushDirty
         assertTrue(updated.contains(m)); //should onFlushDirty have been called?
         assertEquals(1, preFlush.size()); //should preFlush have been called?
         assertTrue(postFlush.isEmpty());
         
         inserted.clear();
         deleted.clear();
         updated.clear();
         preFlush.clear();
         postFlush.clear();
         
         m.getManContactInfos().remove(contactInfo);
         
         s.flush();
   
         assertFalse(inserted.contains(contactInfo));
         assertFalse(inserted.contains(contactInfo2)); //onSave has been lost
         assertTrue(updated.contains(m));
         assertEquals(1, preFlush.size());
         assertEquals(1, postFlush.size());
         
      } finally {
         s.close();
      }
      
      
    }