1 /*
2  * Copyright 2002-2008 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package org.springframework.orm.hibernate3;
18 
19 import java.lang.reflect.Proxy;
20 import java.sql.Connection;
21 import java.sql.SQLException;
22 import java.util.ArrayList;
23 import java.util.Collections;
24 import java.util.Iterator;
25 import java.util.List;
26 
27 import junit.framework.TestCase;
28 import org.easymock.MockControl;
29 import org.hibernate.Criteria;
30 import org.hibernate.Filter;
31 import org.hibernate.FlushMode;
32 import org.hibernate.HibernateException;
33 import org.hibernate.Interceptor;
34 import org.hibernate.JDBCException;
35 import org.hibernate.LockMode;
36 import org.hibernate.NonUniqueResultException;
37 import org.hibernate.ObjectDeletedException;
38 import org.hibernate.ObjectNotFoundException;
39 import org.hibernate.PersistentObjectException;
40 import org.hibernate.PropertyValueException;
41 import org.hibernate.Query;
42 import org.hibernate.QueryException;
43 import org.hibernate.ReplicationMode;
44 import org.hibernate.SessionFactory;
45 import org.hibernate.StaleObjectStateException;
46 import org.hibernate.StaleStateException;
47 import org.hibernate.TransientObjectException;
48 import org.hibernate.UnresolvableObjectException;
49 import org.hibernate.WrongClassException;
50 import org.hibernate.classic.Session;
51 import org.hibernate.exception.ConstraintViolationException;
52 import org.hibernate.exception.DataException;
53 import org.hibernate.exception.GenericJDBCException;
54 import org.hibernate.exception.JDBCConnectionException;
55 import org.hibernate.exception.LockAcquisitionException;
56 import org.hibernate.exception.SQLGrammarException;
57 
58 import org.springframework.beans.TestBean;
59 import org.springframework.dao.CannotAcquireLockException;
60 import org.springframework.dao.DataAccessResourceFailureException;
61 import org.springframework.dao.DataIntegrityViolationException;
62 import org.springframework.dao.IncorrectResultSizeDataAccessException;
63 import org.springframework.dao.InvalidDataAccessApiUsageException;
64 import org.springframework.dao.InvalidDataAccessResourceUsageException;
65 import org.springframework.transaction.support.TransactionSynchronizationManager;
66 
67 /**
68  * @author Juergen Hoeller
69  * @since 05.03.2005
70  */
71 public class HibernateTemplateTests extends TestCase {
72 
73 	private MockControl sfControl;
74 	private SessionFactory sf;
75 	private MockControl sessionControl;
76 	private Session session;
77 
setUp()78 	protected void setUp() {
79 		sfControl = MockControl.createControl(SessionFactory.class);
80 		sf = (SessionFactory) sfControl.getMock();
81 		sessionControl = MockControl.createControl(Session.class);
82 		session = (Session) sessionControl.getMock();
83 	}
84 
testExecuteWithNewSession()85 	public void testExecuteWithNewSession() throws HibernateException {
86 		sf.openSession();
87 		sfControl.setReturnValue(session, 1);
88 		session.getSessionFactory();
89 		sessionControl.setReturnValue(sf, 1);
90 		session.flush();
91 		sessionControl.setVoidCallable(1);
92 		session.close();
93 		sessionControl.setReturnValue(null, 1);
94 		sfControl.replay();
95 		sessionControl.replay();
96 
97 		HibernateTemplate ht = new HibernateTemplate(sf);
98 		assertTrue("Correct allowCreate default", ht.isAllowCreate());
99 		assertTrue("Correct flushMode default", ht.getFlushMode() == HibernateTemplate.FLUSH_AUTO);
100 		final List l = new ArrayList();
101 		l.add("test");
102 		List result = ht.executeFind(new HibernateCallback() {
103 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
104 				return l;
105 			}
106 		});
107 		assertTrue("Correct result list", result == l);
108 	}
109 
testExecuteWithNewSessionAndFlushNever()110 	public void testExecuteWithNewSessionAndFlushNever() throws HibernateException {
111 		sf.openSession();
112 		sfControl.setReturnValue(session, 1);
113 		session.getSessionFactory();
114 		sessionControl.setReturnValue(sf, 1);
115 		session.setFlushMode(FlushMode.MANUAL);
116 		sessionControl.setVoidCallable(1);
117 		session.close();
118 		sessionControl.setReturnValue(null, 1);
119 		sfControl.replay();
120 		sessionControl.replay();
121 
122 		HibernateTemplate ht = new HibernateTemplate(sf);
123 		ht.setFlushMode(HibernateTemplate.FLUSH_NEVER);
124 		final List l = new ArrayList();
125 		l.add("test");
126 		List result = ht.executeFind(new HibernateCallback() {
127 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
128 				return l;
129 			}
130 		});
131 		assertTrue("Correct result list", result == l);
132 	}
133 
testExecuteWithNewSessionAndFilter()134 	public void testExecuteWithNewSessionAndFilter() throws HibernateException {
135 		sf.openSession();
136 		sfControl.setReturnValue(session, 1);
137 		session.getSessionFactory();
138 		sessionControl.setReturnValue(sf, 1);
139 		session.enableFilter("myFilter");
140 		sessionControl.setReturnValue(null, 1);
141 		session.flush();
142 		sessionControl.setVoidCallable(1);
143 		session.close();
144 		sessionControl.setReturnValue(null, 1);
145 		sfControl.replay();
146 		sessionControl.replay();
147 
148 		HibernateTemplate ht = new HibernateTemplate(sf);
149 		ht.setFilterName("myFilter");
150 		final List l = new ArrayList();
151 		l.add("test");
152 		List result = ht.executeFind(new HibernateCallback() {
153 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
154 				return l;
155 			}
156 		});
157 		assertTrue("Correct result list", result == l);
158 	}
159 
testExecuteWithNewSessionAndFilters()160 	public void testExecuteWithNewSessionAndFilters() throws HibernateException {
161 		sf.openSession();
162 		sfControl.setReturnValue(session, 1);
163 		session.getSessionFactory();
164 		sessionControl.setReturnValue(sf, 1);
165 		session.enableFilter("myFilter");
166 		sessionControl.setReturnValue(null, 1);
167 		session.enableFilter("yourFilter");
168 		sessionControl.setReturnValue(null, 1);
169 		session.flush();
170 		sessionControl.setVoidCallable(1);
171 		session.close();
172 		sessionControl.setReturnValue(null, 1);
173 		sfControl.replay();
174 		sessionControl.replay();
175 
176 		HibernateTemplate ht = new HibernateTemplate(sf);
177 		ht.setFilterNames(new String[] {"myFilter", "yourFilter"});
178 		final List l = new ArrayList();
179 		l.add("test");
180 		List result = ht.executeFind(new HibernateCallback() {
181 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
182 				return l;
183 			}
184 		});
185 		assertTrue("Correct result list", result == l);
186 	}
187 
testExecuteWithNotAllowCreate()188 	public void testExecuteWithNotAllowCreate() {
189 		sf.getCurrentSession();
190 		sfControl.setThrowable(new HibernateException(""));
191 		sfControl.replay();
192 
193 		HibernateTemplate ht = new HibernateTemplate();
194 		ht.setSessionFactory(sf);
195 		ht.setAllowCreate(false);
196 		try {
197 			ht.execute(new HibernateCallback() {
198 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
199 					return null;
200 				}
201 			});
202 			fail("Should have thrown DataAccessException");
203 		}
204 		catch (DataAccessResourceFailureException ex) {
205 			// expected
206 		}
207 	}
208 
testExecuteWithNotAllowCreateAndThreadBound()209 	public void testExecuteWithNotAllowCreateAndThreadBound() {
210 		sf.getCurrentSession();
211 		sfControl.setReturnValue(session);
212 		sfControl.replay();
213 
214 		HibernateTemplate ht = new HibernateTemplate(sf);
215 		ht.setAllowCreate(false);
216 
217 		final List l = new ArrayList();
218 		l.add("test");
219 		List result = ht.executeFind(new HibernateCallback() {
220 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
221 				return l;
222 			}
223 		});
224 		assertTrue("Correct result list", result == l);
225 	}
226 
testExecuteWithThreadBoundAndFlushEager()227 	public void testExecuteWithThreadBoundAndFlushEager() throws HibernateException {
228 		session.getSessionFactory();
229 		sessionControl.setReturnValue(sf, 1);
230 		session.isOpen();
231 		sessionControl.setReturnValue(true, 1);
232 		session.getFlushMode();
233 		sessionControl.setReturnValue(FlushMode.AUTO);
234 		session.flush();
235 		sessionControl.setVoidCallable(1);
236 		sfControl.replay();
237 		sessionControl.replay();
238 
239 		HibernateTemplate ht = new HibernateTemplate(sf);
240 		ht.setFlushModeName("FLUSH_EAGER");
241 
242 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
243 		try {
244 			final List l = new ArrayList();
245 			l.add("test");
246 			List result = ht.executeFind(new HibernateCallback() {
247 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
248 					return l;
249 				}
250 			});
251 			assertTrue("Correct result list", result == l);
252 		}
253 		finally {
254 			TransactionSynchronizationManager.unbindResource(sf);
255 		}
256 	}
257 
testExecuteWithThreadBoundAndFilter()258 	public void testExecuteWithThreadBoundAndFilter() {
259 		session.getSessionFactory();
260 		sessionControl.setReturnValue(sf, 1);
261 		session.isOpen();
262 		sessionControl.setReturnValue(true, 1);
263 		session.enableFilter("myFilter");
264 		sessionControl.setReturnValue(null, 1);
265 		session.disableFilter("myFilter");
266 		sessionControl.setVoidCallable(1);
267 		sfControl.replay();
268 		sessionControl.replay();
269 
270 		HibernateTemplate ht = new HibernateTemplate(sf);
271 		ht.setFilterName("myFilter");
272 
273 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
274 		try {
275 			final List l = new ArrayList();
276 			l.add("test");
277 			List result = ht.executeFind(new HibernateCallback() {
278 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
279 					return l;
280 				}
281 			});
282 			assertTrue("Correct result list", result == l);
283 		}
284 		finally {
285 			TransactionSynchronizationManager.unbindResource(sf);
286 		}
287 	}
288 
testExecuteWithThreadBoundAndFilters()289 	public void testExecuteWithThreadBoundAndFilters() {
290 		session.getSessionFactory();
291 		sessionControl.setReturnValue(sf, 1);
292 		session.isOpen();
293 		sessionControl.setReturnValue(true, 1);
294 		session.enableFilter("myFilter");
295 		sessionControl.setReturnValue(null, 1);
296 		session.enableFilter("yourFilter");
297 		sessionControl.setReturnValue(null, 1);
298 		session.disableFilter("myFilter");
299 		sessionControl.setVoidCallable(1);
300 		session.disableFilter("yourFilter");
301 		sessionControl.setVoidCallable(1);
302 		sfControl.replay();
303 		sessionControl.replay();
304 
305 		HibernateTemplate ht = new HibernateTemplate(sf);
306 		ht.setFilterNames(new String[] {"myFilter", "yourFilter"});
307 
308 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
309 		try {
310 			final List l = new ArrayList();
311 			l.add("test");
312 			List result = ht.executeFind(new HibernateCallback() {
313 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
314 					return l;
315 				}
316 			});
317 			assertTrue("Correct result list", result == l);
318 		}
319 		finally {
320 			TransactionSynchronizationManager.unbindResource(sf);
321 		}
322 	}
323 
testExecuteWithThreadBoundAndParameterizedFilter()324 	public void testExecuteWithThreadBoundAndParameterizedFilter() {
325 		MockControl filterControl = MockControl.createControl(Filter.class);
326 		Filter filter = (Filter) filterControl.getMock();
327 
328 		session.getSessionFactory();
329 		sessionControl.setReturnValue(sf, 1);
330 		session.isOpen();
331 		sessionControl.setReturnValue(true, 1);
332 		session.getEnabledFilter("myFilter");
333 		sessionControl.setReturnValue(null, 1);
334 		session.enableFilter("myFilter");
335 		sessionControl.setReturnValue(filter, 1);
336 		sfControl.replay();
337 		sessionControl.replay();
338 
339 		HibernateTemplate ht = new HibernateTemplate(sf);
340 		ht.setAllowCreate(false);
341 		ht.setFilterName("myFilter");
342 
343 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
344 		try {
345 			final List l = new ArrayList();
346 			l.add("test");
347 			Filter f = ht.enableFilter("myFilter");
348 			assertTrue("Correct filter", f == filter);
349 		}
350 		finally {
351 			TransactionSynchronizationManager.unbindResource(sf);
352 		}
353 	}
354 
testExecuteWithThreadBoundAndParameterizedExistingFilter()355 	public void testExecuteWithThreadBoundAndParameterizedExistingFilter() {
356 		MockControl filterControl = MockControl.createControl(Filter.class);
357 		Filter filter = (Filter) filterControl.getMock();
358 
359 		session.getSessionFactory();
360 		sessionControl.setReturnValue(sf, 1);
361 		session.isOpen();
362 		sessionControl.setReturnValue(true, 1);
363 		session.getEnabledFilter("myFilter");
364 		sessionControl.setReturnValue(filter, 1);
365 		sfControl.replay();
366 		sessionControl.replay();
367 
368 		HibernateTemplate ht = new HibernateTemplate(sf);
369 		ht.setAllowCreate(false);
370 		ht.setFilterName("myFilter");
371 
372 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
373 		try {
374 			final List l = new ArrayList();
375 			l.add("test");
376 			Filter f = ht.enableFilter("myFilter");
377 			assertTrue("Correct filter", f == filter);
378 		}
379 		finally {
380 			TransactionSynchronizationManager.unbindResource(sf);
381 		}
382 	}
383 
testExecuteWithThreadBoundAndNewSession()384 	public void testExecuteWithThreadBoundAndNewSession() throws HibernateException {
385 		MockControl conControl = MockControl.createControl(Connection.class);
386 		Connection con = (Connection) conControl.getMock();
387 		MockControl session2Control = MockControl.createControl(Session.class);
388 		Session session2 = (Session) session2Control.getMock();
389 
390 		session2.connection();
391 		session2Control.setReturnValue(con, 1);
392 		sf.openSession(con);
393 		sfControl.setReturnValue(session, 1);
394 		session.flush();
395 		sessionControl.setVoidCallable(1);
396 		session.close();
397 		sessionControl.setReturnValue(null, 1);
398 		sfControl.replay();
399 		sessionControl.replay();
400 		session2Control.replay();
401 
402 		HibernateTemplate ht = new HibernateTemplate(sf);
403 		ht.setAlwaysUseNewSession(true);
404 
405 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2));
406 		try {
407 			final List l = new ArrayList();
408 			l.add("test");
409 			List result = ht.executeFind(new HibernateCallback() {
410 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
411 					return l;
412 				}
413 			});
414 			assertTrue("Correct result list", result == l);
415 		}
416 		finally {
417 			TransactionSynchronizationManager.unbindResource(sf);
418 		}
419 	}
420 
testExecuteWithThreadBoundAndNewSessionAndEntityInterceptor()421 	public void testExecuteWithThreadBoundAndNewSessionAndEntityInterceptor() throws HibernateException {
422 		MockControl interceptorControl = MockControl.createControl(org.hibernate.Interceptor.class);
423 		Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock();
424 
425 		MockControl conControl = MockControl.createControl(Connection.class);
426 		Connection con = (Connection) conControl.getMock();
427 		MockControl session2Control = MockControl.createControl(Session.class);
428 		Session session2 = (Session) session2Control.getMock();
429 
430 		session2.connection();
431 		session2Control.setReturnValue(con, 1);
432 		sf.openSession(con, entityInterceptor);
433 		sfControl.setReturnValue(session, 1);
434 		session.flush();
435 		sessionControl.setVoidCallable(1);
436 		session.close();
437 		sessionControl.setReturnValue(null, 1);
438 		sfControl.replay();
439 		sessionControl.replay();
440 		session2Control.replay();
441 
442 		HibernateTemplate ht = new HibernateTemplate(sf);
443 		ht.setAlwaysUseNewSession(true);
444 		ht.setEntityInterceptor(entityInterceptor);
445 
446 		TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2));
447 		try {
448 			final List l = new ArrayList();
449 			l.add("test");
450 			List result = ht.executeFind(new HibernateCallback() {
451 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
452 					return l;
453 				}
454 			});
455 			assertTrue("Correct result list", result == l);
456 		}
457 		finally {
458 			TransactionSynchronizationManager.unbindResource(sf);
459 		}
460 	}
461 
testExecuteWithEntityInterceptor()462 	public void testExecuteWithEntityInterceptor() throws HibernateException {
463 		MockControl interceptorControl = MockControl.createControl(org.hibernate.Interceptor.class);
464 		Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock();
465 
466 		sf.openSession(entityInterceptor);
467 		sfControl.setReturnValue(session, 1);
468 		session.getSessionFactory();
469 		sessionControl.setReturnValue(sf, 1);
470 		session.flush();
471 		sessionControl.setVoidCallable(1);
472 		session.close();
473 		sessionControl.setReturnValue(null, 1);
474 		sfControl.replay();
475 		sessionControl.replay();
476 
477 		HibernateTemplate ht = new HibernateTemplate(sf);
478 		ht.setEntityInterceptor(entityInterceptor);
479 		final List l = new ArrayList();
480 		l.add("test");
481 		List result = ht.executeFind(new HibernateCallback() {
482 			public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
483 				return l;
484 			}
485 		});
486 		assertTrue("Correct result list", result == l);
487 	}
488 
testExecuteWithCacheQueries()489 	public void testExecuteWithCacheQueries() throws HibernateException {
490 		MockControl query1Control = MockControl.createControl(Query.class);
491 		Query query1 = (Query) query1Control.getMock();
492 		MockControl query2Control = MockControl.createControl(Query.class);
493 		Query query2 = (Query) query2Control.getMock();
494 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
495 		Criteria criteria = (Criteria) criteriaControl.getMock();
496 
497 		sf.openSession();
498 		sfControl.setReturnValue(session, 1);
499 		session.getSessionFactory();
500 		sessionControl.setReturnValue(sf, 1);
501 		session.createQuery("some query");
502 		sessionControl.setReturnValue(query1);
503 		query1.setCacheable(true);
504 		query1Control.setReturnValue(query1, 1);
505 		session.getNamedQuery("some query name");
506 		sessionControl.setReturnValue(query2);
507 		query2.setCacheable(true);
508 		query2Control.setReturnValue(query2, 1);
509 		session.createCriteria(TestBean.class);
510 		sessionControl.setReturnValue(criteria, 1);
511 		criteria.setCacheable(true);
512 		criteriaControl.setReturnValue(criteria, 1);
513 		session.flush();
514 		sessionControl.setVoidCallable(1);
515 		session.close();
516 		sessionControl.setReturnValue(null, 1);
517 		sfControl.replay();
518 		sessionControl.replay();
519 		query1Control.replay();
520 		query2Control.replay();
521 		criteriaControl.replay();
522 
523 		HibernateTemplate ht = new HibernateTemplate(sf);
524 		ht.setCacheQueries(true);
525 		ht.execute(new HibernateCallback() {
526 			public Object doInHibernate(org.hibernate.Session sess) throws HibernateException {
527 				assertNotSame(session, sess);
528 				assertTrue(Proxy.isProxyClass(sess.getClass()));
529 				sess.createQuery("some query");
530 				sess.getNamedQuery("some query name");
531 				sess.createCriteria(TestBean.class);
532 				// should be ignored
533 				sess.close();
534 				return null;
535 			}
536 		});
537 
538 		query1Control.verify();
539 		query2Control.verify();
540 		criteriaControl.verify();
541 	}
542 
testExecuteWithCacheQueriesAndCacheRegion()543 	public void testExecuteWithCacheQueriesAndCacheRegion() throws HibernateException {
544 		MockControl query1Control = MockControl.createControl(Query.class);
545 		Query query1 = (Query) query1Control.getMock();
546 		MockControl query2Control = MockControl.createControl(Query.class);
547 		Query query2 = (Query) query2Control.getMock();
548 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
549 		Criteria criteria = (Criteria) criteriaControl.getMock();
550 
551 		sf.openSession();
552 		sfControl.setReturnValue(session, 1);
553 		session.getSessionFactory();
554 		sessionControl.setReturnValue(sf, 1);
555 		session.createQuery("some query");
556 		sessionControl.setReturnValue(query1);
557 		query1.setCacheable(true);
558 		query1Control.setReturnValue(query1, 1);
559 		query1.setCacheRegion("myRegion");
560 		query1Control.setReturnValue(query1, 1);
561 		session.getNamedQuery("some query name");
562 		sessionControl.setReturnValue(query2);
563 		query2.setCacheable(true);
564 		query2Control.setReturnValue(query2, 1);
565 		query2.setCacheRegion("myRegion");
566 		query2Control.setReturnValue(query2, 1);
567 		session.createCriteria(TestBean.class);
568 		sessionControl.setReturnValue(criteria, 1);
569 		criteria.setCacheable(true);
570 		criteriaControl.setReturnValue(criteria, 1);
571 		criteria.setCacheRegion("myRegion");
572 		criteriaControl.setReturnValue(criteria, 1);
573 		session.flush();
574 		sessionControl.setVoidCallable(1);
575 		session.close();
576 		sessionControl.setReturnValue(null, 1);
577 		sfControl.replay();
578 		sessionControl.replay();
579 		query1Control.replay();
580 		query2Control.replay();
581 		criteriaControl.replay();
582 
583 		HibernateTemplate ht = new HibernateTemplate(sf);
584 		ht.setCacheQueries(true);
585 		ht.setQueryCacheRegion("myRegion");
586 		ht.execute(new HibernateCallback() {
587 			public Object doInHibernate(org.hibernate.Session sess) throws HibernateException {
588 				assertNotSame(session, sess);
589 				assertTrue(Proxy.isProxyClass(sess.getClass()));
590 				sess.createQuery("some query");
591 				sess.getNamedQuery("some query name");
592 				sess.createCriteria(TestBean.class);
593 				// should be ignored
594 				sess.close();
595 				return null;
596 			}
597 		});
598 
599 		query1Control.verify();
600 		query2Control.verify();
601 		criteriaControl.verify();
602 	}
603 
testExecuteWithCacheQueriesAndCacheRegionAndNativeSession()604 	public void testExecuteWithCacheQueriesAndCacheRegionAndNativeSession() throws HibernateException {
605 		MockControl query1Control = MockControl.createControl(Query.class);
606 		Query query1 = (Query) query1Control.getMock();
607 		MockControl query2Control = MockControl.createControl(Query.class);
608 		Query query2 = (Query) query2Control.getMock();
609 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
610 		Criteria criteria = (Criteria) criteriaControl.getMock();
611 
612 		sf.openSession();
613 		sfControl.setReturnValue(session, 1);
614 		session.getSessionFactory();
615 		sessionControl.setReturnValue(sf, 1);
616 		session.createQuery("some query");
617 		sessionControl.setReturnValue(query1);
618 		session.getNamedQuery("some query name");
619 		sessionControl.setReturnValue(query2);
620 		session.createCriteria(TestBean.class);
621 		sessionControl.setReturnValue(criteria, 1);
622 		session.flush();
623 		sessionControl.setVoidCallable(1);
624 		session.close();
625 		sessionControl.setReturnValue(null, 1);
626 		sfControl.replay();
627 		sessionControl.replay();
628 		query1Control.replay();
629 		query2Control.replay();
630 		criteriaControl.replay();
631 
632 		HibernateTemplate ht = new HibernateTemplate(sf);
633 		ht.setExposeNativeSession(true);
634 		ht.setCacheQueries(true);
635 		ht.setQueryCacheRegion("myRegion");
636 		ht.execute(new HibernateCallback() {
637 			public Object doInHibernate(org.hibernate.Session sess) throws HibernateException {
638 				assertSame(session, sess);
639 				sess.createQuery("some query");
640 				sess.getNamedQuery("some query name");
641 				sess.createCriteria(TestBean.class);
642 				return null;
643 			}
644 		});
645 
646 		query1Control.verify();
647 		query2Control.verify();
648 		criteriaControl.verify();
649 	}
650 
testExecuteWithFetchSizeAndMaxResults()651 	public void testExecuteWithFetchSizeAndMaxResults() throws HibernateException {
652 		MockControl query1Control = MockControl.createControl(Query.class);
653 		Query query1 = (Query) query1Control.getMock();
654 		MockControl query2Control = MockControl.createControl(Query.class);
655 		Query query2 = (Query) query2Control.getMock();
656 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
657 		Criteria criteria = (Criteria) criteriaControl.getMock();
658 
659 		sf.openSession();
660 		sfControl.setReturnValue(session, 1);
661 		session.getSessionFactory();
662 		sessionControl.setReturnValue(sf, 1);
663 		session.createQuery("some query");
664 		sessionControl.setReturnValue(query1);
665 		query1.setFetchSize(10);
666 		query1Control.setReturnValue(query1, 1);
667 		query1.setMaxResults(20);
668 		query1Control.setReturnValue(query1, 1);
669 		session.getNamedQuery("some query name");
670 		sessionControl.setReturnValue(query2);
671 		query2.setFetchSize(10);
672 		query2Control.setReturnValue(query2, 1);
673 		query2.setMaxResults(20);
674 		query2Control.setReturnValue(query2, 1);
675 		session.createCriteria(TestBean.class);
676 		sessionControl.setReturnValue(criteria, 1);
677 		criteria.setFetchSize(10);
678 		criteriaControl.setReturnValue(criteria, 1);
679 		criteria.setMaxResults(20);
680 		criteriaControl.setReturnValue(criteria, 1);
681 		session.flush();
682 		sessionControl.setVoidCallable(1);
683 		session.close();
684 		sessionControl.setReturnValue(null, 1);
685 		sfControl.replay();
686 		sessionControl.replay();
687 		query1Control.replay();
688 		query2Control.replay();
689 		criteriaControl.replay();
690 
691 		HibernateTemplate ht = new HibernateTemplate(sf);
692 		ht.setFetchSize(10);
693 		ht.setMaxResults(20);
694 		ht.execute(new HibernateCallback() {
695 			public Object doInHibernate(org.hibernate.Session sess) throws HibernateException {
696 				sess.createQuery("some query");
697 				sess.getNamedQuery("some query name");
698 				sess.createCriteria(TestBean.class);
699 				return null;
700 			}
701 		});
702 
703 		query1Control.verify();
704 		query2Control.verify();
705 		criteriaControl.verify();
706 	}
707 
testGet()708 	public void testGet() throws HibernateException {
709 		TestBean tb = new TestBean();
710 		sf.openSession();
711 		sfControl.setReturnValue(session, 1);
712 		session.getSessionFactory();
713 		sessionControl.setReturnValue(sf, 1);
714 		session.get(TestBean.class, "");
715 		sessionControl.setReturnValue(tb, 1);
716 		session.flush();
717 		sessionControl.setVoidCallable(1);
718 		session.close();
719 		sessionControl.setReturnValue(null, 1);
720 		sfControl.replay();
721 		sessionControl.replay();
722 
723 		HibernateTemplate ht = new HibernateTemplate(sf);
724 		Object result = ht.get(TestBean.class, "");
725 		assertTrue("Correct result", result == tb);
726 	}
727 
testGetWithLockMode()728 	public void testGetWithLockMode() throws HibernateException {
729 		TestBean tb = new TestBean();
730 		sf.openSession();
731 		sfControl.setReturnValue(session, 1);
732 		session.getSessionFactory();
733 		sessionControl.setReturnValue(sf, 1);
734 		session.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT);
735 		sessionControl.setReturnValue(tb, 1);
736 		session.flush();
737 		sessionControl.setVoidCallable(1);
738 		session.close();
739 		sessionControl.setReturnValue(null, 1);
740 		sfControl.replay();
741 		sessionControl.replay();
742 
743 		HibernateTemplate ht = new HibernateTemplate(sf);
744 		Object result = ht.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT);
745 		assertTrue("Correct result", result == tb);
746 	}
747 
testGetWithEntityName()748 	public void testGetWithEntityName() throws HibernateException {
749 		TestBean tb = new TestBean();
750 		sf.openSession();
751 		sfControl.setReturnValue(session, 1);
752 		session.getSessionFactory();
753 		sessionControl.setReturnValue(sf, 1);
754 		session.get("myEntity", "");
755 		sessionControl.setReturnValue(tb, 1);
756 		session.flush();
757 		sessionControl.setVoidCallable(1);
758 		session.close();
759 		sessionControl.setReturnValue(null, 1);
760 		sfControl.replay();
761 		sessionControl.replay();
762 
763 		HibernateTemplate ht = new HibernateTemplate(sf);
764 		Object result = ht.get("myEntity", "");
765 		assertTrue("Correct result", result == tb);
766 	}
767 
testGetWithEntityNameAndLockMode()768 	public void testGetWithEntityNameAndLockMode() throws HibernateException {
769 		TestBean tb = new TestBean();
770 		sf.openSession();
771 		sfControl.setReturnValue(session, 1);
772 		session.getSessionFactory();
773 		sessionControl.setReturnValue(sf, 1);
774 		session.get("myEntity", "", LockMode.UPGRADE_NOWAIT);
775 		sessionControl.setReturnValue(tb, 1);
776 		session.flush();
777 		sessionControl.setVoidCallable(1);
778 		session.close();
779 		sessionControl.setReturnValue(null, 1);
780 		sfControl.replay();
781 		sessionControl.replay();
782 
783 		HibernateTemplate ht = new HibernateTemplate(sf);
784 		Object result = ht.get("myEntity", "", LockMode.UPGRADE_NOWAIT);
785 		assertTrue("Correct result", result == tb);
786 	}
787 
testLoad()788 	public void testLoad() throws HibernateException {
789 		TestBean tb = new TestBean();
790 
791 		sf.openSession();
792 		sfControl.setReturnValue(session, 1);
793 		session.getSessionFactory();
794 		sessionControl.setReturnValue(sf, 1);
795 		session.load(TestBean.class, "");
796 		sessionControl.setReturnValue(tb, 1);
797 		session.flush();
798 		sessionControl.setVoidCallable(1);
799 		session.close();
800 		sessionControl.setReturnValue(null, 1);
801 		sfControl.replay();
802 		sessionControl.replay();
803 
804 		HibernateTemplate ht = new HibernateTemplate(sf);
805 		Object result = ht.load(TestBean.class, "");
806 		assertTrue("Correct result", result == tb);
807 	}
808 
testLoadWithNotFound()809 	public void testLoadWithNotFound() throws HibernateException {
810 		sf.openSession();
811 		sfControl.setReturnValue(session, 1);
812 		session.getSessionFactory();
813 		sessionControl.setReturnValue(sf, 1);
814 		session.load(TestBean.class, "id");
815 		ObjectNotFoundException onfex = new ObjectNotFoundException("id", TestBean.class.getName());
816 		sessionControl.setThrowable(onfex);
817 		session.close();
818 		sessionControl.setReturnValue(null, 1);
819 		sfControl.replay();
820 		sessionControl.replay();
821 
822 		HibernateTemplate ht = new HibernateTemplate(sf);
823 		try {
824 			ht.load(TestBean.class, "id");
825 			fail("Should have thrown HibernateObjectRetrievalFailureException");
826 		}
827 		catch (HibernateObjectRetrievalFailureException ex) {
828 			// expected
829 			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
830 			assertEquals("id", ex.getIdentifier());
831 			assertEquals(onfex, ex.getCause());
832 		}
833 	}
834 
testLoadWithLockMode()835 	public void testLoadWithLockMode() throws HibernateException {
836 		TestBean tb = new TestBean();
837 
838 		sf.openSession();
839 		sfControl.setReturnValue(session, 1);
840 		session.getSessionFactory();
841 		sessionControl.setReturnValue(sf, 1);
842 		session.load(TestBean.class, "", LockMode.UPGRADE);
843 		sessionControl.setReturnValue(tb, 1);
844 		session.flush();
845 		sessionControl.setVoidCallable(1);
846 		session.close();
847 		sessionControl.setReturnValue(null, 1);
848 		sfControl.replay();
849 		sessionControl.replay();
850 
851 		HibernateTemplate ht = new HibernateTemplate(sf);
852 		Object result = ht.load(TestBean.class, "", LockMode.UPGRADE);
853 		assertTrue("Correct result", result == tb);
854 	}
855 
testLoadWithEntityName()856 	public void testLoadWithEntityName() throws HibernateException {
857 		TestBean tb = new TestBean();
858 
859 		sf.openSession();
860 		sfControl.setReturnValue(session, 1);
861 		session.getSessionFactory();
862 		sessionControl.setReturnValue(sf, 1);
863 		session.load("myEntity", "");
864 		sessionControl.setReturnValue(tb, 1);
865 		session.flush();
866 		sessionControl.setVoidCallable(1);
867 		session.close();
868 		sessionControl.setReturnValue(null, 1);
869 		sfControl.replay();
870 		sessionControl.replay();
871 
872 		HibernateTemplate ht = new HibernateTemplate(sf);
873 		Object result = ht.load("myEntity", "");
874 		assertTrue("Correct result", result == tb);
875 	}
876 
testLoadWithEntityNameLockMode()877 	public void testLoadWithEntityNameLockMode() throws HibernateException {
878 		TestBean tb = new TestBean();
879 
880 		sf.openSession();
881 		sfControl.setReturnValue(session, 1);
882 		session.getSessionFactory();
883 		sessionControl.setReturnValue(sf, 1);
884 		session.load("myEntity", "", LockMode.UPGRADE);
885 		sessionControl.setReturnValue(tb, 1);
886 		session.flush();
887 		sessionControl.setVoidCallable(1);
888 		session.close();
889 		sessionControl.setReturnValue(null, 1);
890 		sfControl.replay();
891 		sessionControl.replay();
892 
893 		HibernateTemplate ht = new HibernateTemplate(sf);
894 		Object result = ht.load("myEntity", "", LockMode.UPGRADE);
895 		assertTrue("Correct result", result == tb);
896 	}
897 
testLoadWithObject()898 	public void testLoadWithObject() throws HibernateException {
899 		TestBean tb = new TestBean();
900 		sf.openSession();
901 		sfControl.setReturnValue(session, 1);
902 		session.getSessionFactory();
903 		sessionControl.setReturnValue(sf, 1);
904 		session.load(tb, "");
905 		sessionControl.setVoidCallable(1);
906 		session.flush();
907 		sessionControl.setVoidCallable(1);
908 		session.close();
909 		sessionControl.setReturnValue(null, 1);
910 		sfControl.replay();
911 		sessionControl.replay();
912 
913 		HibernateTemplate ht = new HibernateTemplate(sf);
914 		ht.load(tb, "");
915 	}
916 
testLoadAll()917 	public void testLoadAll() throws HibernateException {
918 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
919 		Criteria criteria = (Criteria) criteriaControl.getMock();
920 		List list = new ArrayList();
921 
922 		sf.openSession();
923 		sfControl.setReturnValue(session, 1);
924 		session.getSessionFactory();
925 		sessionControl.setReturnValue(sf, 1);
926 		session.createCriteria(TestBean.class);
927 		sessionControl.setReturnValue(criteria, 1);
928 		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
929 		criteriaControl.setReturnValue(criteria);
930 		criteria.list();
931 		criteriaControl.setReturnValue(list, 1);
932 		session.flush();
933 		sessionControl.setVoidCallable(1);
934 		session.close();
935 		sessionControl.setReturnValue(null, 1);
936 		sfControl.replay();
937 		sessionControl.replay();
938 		criteriaControl.replay();
939 
940 		HibernateTemplate ht = new HibernateTemplate(sf);
941 		List result = ht.loadAll(TestBean.class);
942 		assertTrue("Correct result", result == list);
943 
944 		criteriaControl.verify();
945 	}
946 
testLoadAllWithCacheable()947 	public void testLoadAllWithCacheable() throws HibernateException {
948 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
949 		Criteria criteria = (Criteria) criteriaControl.getMock();
950 		List list = new ArrayList();
951 
952 		sf.openSession();
953 		sfControl.setReturnValue(session, 1);
954 		session.getSessionFactory();
955 		sessionControl.setReturnValue(sf, 1);
956 		session.createCriteria(TestBean.class);
957 		sessionControl.setReturnValue(criteria, 1);
958 		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
959 		criteriaControl.setReturnValue(criteria);
960 		criteria.setCacheable(true);
961 		criteriaControl.setReturnValue(criteria, 1);
962 		criteria.list();
963 		criteriaControl.setReturnValue(list, 1);
964 		session.flush();
965 		sessionControl.setVoidCallable(1);
966 		session.close();
967 		sessionControl.setReturnValue(null, 1);
968 		sfControl.replay();
969 		sessionControl.replay();
970 		criteriaControl.replay();
971 
972 		HibernateTemplate ht = new HibernateTemplate(sf);
973 		ht.setCacheQueries(true);
974 		List result = ht.loadAll(TestBean.class);
975 		assertTrue("Correct result", result == list);
976 
977 		criteriaControl.verify();
978 	}
979 
testLoadAllWithCacheableAndCacheRegion()980 	public void testLoadAllWithCacheableAndCacheRegion() throws HibernateException {
981 		MockControl criteriaControl = MockControl.createControl(Criteria.class);
982 		Criteria criteria = (Criteria) criteriaControl.getMock();
983 		List list = new ArrayList();
984 
985 		sf.openSession();
986 		sfControl.setReturnValue(session, 1);
987 		session.getSessionFactory();
988 		sessionControl.setReturnValue(sf, 1);
989 		session.createCriteria(TestBean.class);
990 		sessionControl.setReturnValue(criteria, 1);
991 		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
992 		criteriaControl.setReturnValue(criteria);
993 		criteria.setCacheable(true);
994 		criteriaControl.setReturnValue(criteria, 1);
995 		criteria.setCacheRegion("myCacheRegion");
996 		criteriaControl.setReturnValue(criteria, 1);
997 		criteria.list();
998 		criteriaControl.setReturnValue(list, 1);
999 		session.flush();
1000 		sessionControl.setVoidCallable(1);
1001 		session.close();
1002 		sessionControl.setReturnValue(null, 1);
1003 		sfControl.replay();
1004 		sessionControl.replay();
1005 		criteriaControl.replay();
1006 
1007 		HibernateTemplate ht = new HibernateTemplate(sf);
1008 		ht.setCacheQueries(true);
1009 		ht.setQueryCacheRegion("myCacheRegion");
1010 		List result = ht.loadAll(TestBean.class);
1011 		assertTrue("Correct result", result == list);
1012 
1013 		criteriaControl.verify();
1014 	}
1015 
testRefresh()1016 	public void testRefresh() throws HibernateException {
1017 		TestBean tb = new TestBean();
1018 		sf.openSession();
1019 		sfControl.setReturnValue(session, 1);
1020 		session.getSessionFactory();
1021 		sessionControl.setReturnValue(sf, 1);
1022 		session.refresh(tb);
1023 		sessionControl.setVoidCallable(1);
1024 		session.flush();
1025 		sessionControl.setVoidCallable(1);
1026 		session.close();
1027 		sessionControl.setReturnValue(null, 1);
1028 		sfControl.replay();
1029 		sessionControl.replay();
1030 
1031 		HibernateTemplate ht = new HibernateTemplate(sf);
1032 		ht.refresh(tb);
1033 	}
1034 
testContains()1035 	public void testContains() throws HibernateException {
1036 		TestBean tb = new TestBean();
1037 		sf.openSession();
1038 		sfControl.setReturnValue(session, 1);
1039 		session.getSessionFactory();
1040 		sessionControl.setReturnValue(sf, 1);
1041 		session.contains(tb);
1042 		sessionControl.setReturnValue(true, 1);
1043 		session.flush();
1044 		sessionControl.setVoidCallable(1);
1045 		session.close();
1046 		sessionControl.setReturnValue(null, 1);
1047 		sfControl.replay();
1048 		sessionControl.replay();
1049 
1050 		HibernateTemplate ht = new HibernateTemplate(sf);
1051 		assertTrue(ht.contains(tb));
1052 	}
1053 
testEvict()1054 	public void testEvict() throws HibernateException {
1055 		TestBean tb = new TestBean();
1056 		sf.openSession();
1057 		sfControl.setReturnValue(session, 1);
1058 		session.getSessionFactory();
1059 		sessionControl.setReturnValue(sf, 1);
1060 		session.evict(tb);
1061 		sessionControl.setVoidCallable(1);
1062 		session.flush();
1063 		sessionControl.setVoidCallable(1);
1064 		session.close();
1065 		sessionControl.setReturnValue(null, 1);
1066 		sfControl.replay();
1067 		sessionControl.replay();
1068 
1069 		HibernateTemplate ht = new HibernateTemplate(sf);
1070 		ht.evict(tb);
1071 	}
1072 
testLock()1073 	public void testLock() throws HibernateException {
1074 		TestBean tb = new TestBean();
1075 		sf.openSession();
1076 		sfControl.setReturnValue(session, 1);
1077 		session.getSessionFactory();
1078 		sessionControl.setReturnValue(sf, 1);
1079 		session.lock(tb, LockMode.WRITE);
1080 		sessionControl.setVoidCallable(1);
1081 		session.flush();
1082 		sessionControl.setVoidCallable(1);
1083 		session.close();
1084 			sessionControl.setReturnValue(null, 1);
1085 		sfControl.replay();
1086 		sessionControl.replay();
1087 
1088 		HibernateTemplate ht = new HibernateTemplate(sf);
1089 		ht.lock(tb, LockMode.WRITE);
1090 	}
1091 
testLockWithEntityName()1092 	public void testLockWithEntityName() throws HibernateException {
1093 		TestBean tb = new TestBean();
1094 		sf.openSession();
1095 		sfControl.setReturnValue(session, 1);
1096 		session.getSessionFactory();
1097 		sessionControl.setReturnValue(sf, 1);
1098 		session.lock("myEntity", tb, LockMode.WRITE);
1099 		sessionControl.setVoidCallable(1);
1100 		session.flush();
1101 		sessionControl.setVoidCallable(1);
1102 		session.close();
1103 			sessionControl.setReturnValue(null, 1);
1104 		sfControl.replay();
1105 		sessionControl.replay();
1106 
1107 		HibernateTemplate ht = new HibernateTemplate(sf);
1108 		ht.lock("myEntity", tb, LockMode.WRITE);
1109 	}
1110 
testSave()1111 	public void testSave() throws HibernateException {
1112 		TestBean tb = new TestBean();
1113 		sf.openSession();
1114 		sfControl.setReturnValue(session, 1);
1115 		session.getSessionFactory();
1116 		sessionControl.setReturnValue(sf, 1);
1117 		session.getFlushMode();
1118 		sessionControl.setReturnValue(FlushMode.AUTO);
1119 		session.save(tb);
1120 		sessionControl.setReturnValue(new Integer(0), 1);
1121 		session.flush();
1122 		sessionControl.setVoidCallable(1);
1123 		session.close();
1124 		sessionControl.setReturnValue(null, 1);
1125 		sfControl.replay();
1126 		sessionControl.replay();
1127 
1128 		HibernateTemplate ht = new HibernateTemplate(sf);
1129 		assertEquals("Correct return value", ht.save(tb), new Integer(0));
1130 	}
1131 
testSaveWithEntityName()1132 	public void testSaveWithEntityName() throws HibernateException {
1133 		TestBean tb = new TestBean();
1134 		sf.openSession();
1135 		sfControl.setReturnValue(session, 1);
1136 		session.getSessionFactory();
1137 		sessionControl.setReturnValue(sf, 1);
1138 		session.getFlushMode();
1139 		sessionControl.setReturnValue(FlushMode.AUTO);
1140 		session.save("myEntity", tb);
1141 		sessionControl.setReturnValue(new Integer(0), 1);
1142 		session.flush();
1143 		sessionControl.setVoidCallable(1);
1144 		session.close();
1145 		sessionControl.setReturnValue(null, 1);
1146 		sfControl.replay();
1147 		sessionControl.replay();
1148 
1149 		HibernateTemplate ht = new HibernateTemplate(sf);
1150 		assertEquals("Correct return value", ht.save("myEntity", tb), new Integer(0));
1151 	}
1152 
testUpdate()1153 	public void testUpdate() throws HibernateException {
1154 		TestBean tb = new TestBean();
1155 		sf.openSession();
1156 		sfControl.setReturnValue(session, 1);
1157 		session.getSessionFactory();
1158 		sessionControl.setReturnValue(sf, 1);
1159 		session.getFlushMode();
1160 		sessionControl.setReturnValue(FlushMode.AUTO);
1161 		session.update(tb);
1162 		sessionControl.setVoidCallable(1);
1163 		session.flush();
1164 		sessionControl.setVoidCallable(1);
1165 		session.close();
1166 		sessionControl.setReturnValue(null, 1);
1167 		sfControl.replay();
1168 		sessionControl.replay();
1169 
1170 		HibernateTemplate ht = new HibernateTemplate(sf);
1171 		ht.update(tb);
1172 	}
1173 
testUpdateWithLockMode()1174 	public void testUpdateWithLockMode() throws HibernateException {
1175 		TestBean tb = new TestBean();
1176 		sf.openSession();
1177 		sfControl.setReturnValue(session, 1);
1178 		session.getSessionFactory();
1179 		sessionControl.setReturnValue(sf, 1);
1180 		session.getFlushMode();
1181 		sessionControl.setReturnValue(FlushMode.AUTO);
1182 		session.update(tb);
1183 		sessionControl.setVoidCallable(1);
1184 		session.lock(tb, LockMode.UPGRADE);
1185 		sessionControl.setVoidCallable(1);
1186 		session.flush();
1187 		sessionControl.setVoidCallable(1);
1188 		session.close();
1189 		sessionControl.setReturnValue(null, 1);
1190 		sfControl.replay();
1191 		sessionControl.replay();
1192 
1193 		HibernateTemplate ht = new HibernateTemplate(sf);
1194 		ht.update(tb, LockMode.UPGRADE);
1195 	}
1196 
testUpdateWithEntityName()1197 	public void testUpdateWithEntityName() throws HibernateException {
1198 		TestBean tb = new TestBean();
1199 		sf.openSession();
1200 		sfControl.setReturnValue(session, 1);
1201 		session.getSessionFactory();
1202 		sessionControl.setReturnValue(sf, 1);
1203 		session.getFlushMode();
1204 		sessionControl.setReturnValue(FlushMode.AUTO);
1205 		session.update("myEntity", tb);
1206 		sessionControl.setVoidCallable(1);
1207 		session.flush();
1208 		sessionControl.setVoidCallable(1);
1209 		session.close();
1210 		sessionControl.setReturnValue(null, 1);
1211 		sfControl.replay();
1212 		sessionControl.replay();
1213 
1214 		HibernateTemplate ht = new HibernateTemplate(sf);
1215 		ht.update("myEntity", tb);
1216 	}
1217 
testUpdateWithEntityNameAndLockMode()1218 	public void testUpdateWithEntityNameAndLockMode() throws HibernateException {
1219 		TestBean tb = new TestBean();
1220 		sf.openSession();
1221 		sfControl.setReturnValue(session, 1);
1222 		session.getSessionFactory();
1223 		sessionControl.setReturnValue(sf, 1);
1224 		session.getFlushMode();
1225 		sessionControl.setReturnValue(FlushMode.AUTO);
1226 		session.update("myEntity", tb);
1227 		sessionControl.setVoidCallable(1);
1228 		session.lock(tb, LockMode.UPGRADE);
1229 		sessionControl.setVoidCallable(1);
1230 		session.flush();
1231 		sessionControl.setVoidCallable(1);
1232 		session.close();
1233 		sessionControl.setReturnValue(null, 1);
1234 		sfControl.replay();
1235 		sessionControl.replay();
1236 
1237 		HibernateTemplate ht = new HibernateTemplate(sf);
1238 		ht.update("myEntity", tb, LockMode.UPGRADE);
1239 	}
1240 
testSaveOrUpdate()1241 	public void testSaveOrUpdate() throws HibernateException {
1242 		TestBean tb = new TestBean();
1243 		sf.openSession();
1244 		sfControl.setReturnValue(session, 1);
1245 		session.getSessionFactory();
1246 		sessionControl.setReturnValue(sf, 1);
1247 		session.getFlushMode();
1248 		sessionControl.setReturnValue(FlushMode.AUTO);
1249 		session.saveOrUpdate(tb);
1250 		sessionControl.setVoidCallable(1);
1251 		session.flush();
1252 		sessionControl.setVoidCallable(1);
1253 		session.close();
1254 		sessionControl.setReturnValue(null, 1);
1255 		sfControl.replay();
1256 		sessionControl.replay();
1257 
1258 		HibernateTemplate ht = new HibernateTemplate(sf);
1259 		ht.saveOrUpdate(tb);
1260 	}
1261 
testSaveOrUpdateWithFlushModeNever()1262 	public void testSaveOrUpdateWithFlushModeNever() throws HibernateException {
1263 		TestBean tb = new TestBean();
1264 		sf.openSession();
1265 		sfControl.setReturnValue(session, 1);
1266 		session.getSessionFactory();
1267 		sessionControl.setReturnValue(sf, 1);
1268 		session.getFlushMode();
1269 		sessionControl.setReturnValue(FlushMode.MANUAL);
1270 		session.close();
1271 		sessionControl.setReturnValue(null, 1);
1272 		sfControl.replay();
1273 		sessionControl.replay();
1274 
1275 		HibernateTemplate ht = new HibernateTemplate(sf);
1276 		try {
1277 			ht.saveOrUpdate(tb);
1278 			fail("Should have thrown InvalidDataAccessApiUsageException");
1279 		}
1280 		catch (InvalidDataAccessApiUsageException ex) {
1281 			// expected
1282 		}
1283 	}
1284 
testSaveOrUpdateWithEntityName()1285 	public void testSaveOrUpdateWithEntityName() throws HibernateException {
1286 		TestBean tb = new TestBean();
1287 		sf.openSession();
1288 		sfControl.setReturnValue(session, 1);
1289 		session.getSessionFactory();
1290 		sessionControl.setReturnValue(sf, 1);
1291 		session.getFlushMode();
1292 		sessionControl.setReturnValue(FlushMode.AUTO);
1293 		session.saveOrUpdate("myEntity", tb);
1294 		sessionControl.setVoidCallable(1);
1295 		session.flush();
1296 		sessionControl.setVoidCallable(1);
1297 		session.close();
1298 		sessionControl.setReturnValue(null, 1);
1299 		sfControl.replay();
1300 		sessionControl.replay();
1301 
1302 		HibernateTemplate ht = new HibernateTemplate(sf);
1303 		ht.saveOrUpdate("myEntity", tb);
1304 	}
1305 
testSaveOrUpdateAll()1306 	public void testSaveOrUpdateAll() throws HibernateException {
1307 		TestBean tb1 = new TestBean();
1308 		TestBean tb2 = new TestBean();
1309 		sf.openSession();
1310 		sfControl.setReturnValue(session, 1);
1311 		session.getSessionFactory();
1312 		sessionControl.setReturnValue(sf, 1);
1313 		session.getFlushMode();
1314 		sessionControl.setReturnValue(FlushMode.AUTO);
1315 		session.saveOrUpdate(tb1);
1316 		sessionControl.setVoidCallable(1);
1317 		session.saveOrUpdate(tb2);
1318 		sessionControl.setVoidCallable(1);
1319 		session.flush();
1320 		sessionControl.setVoidCallable(1);
1321 		session.close();
1322 		sessionControl.setReturnValue(null, 1);
1323 		sfControl.replay();
1324 		sessionControl.replay();
1325 
1326 		HibernateTemplate ht = new HibernateTemplate(sf);
1327 		List tbs = new ArrayList();
1328 		tbs.add(tb1);
1329 		tbs.add(tb2);
1330 		ht.saveOrUpdateAll(tbs);
1331 	}
1332 
testReplicate()1333 	public void testReplicate() throws HibernateException {
1334 		TestBean tb = new TestBean();
1335 		sf.openSession();
1336 		sfControl.setReturnValue(session, 1);
1337 		session.getSessionFactory();
1338 		sessionControl.setReturnValue(sf, 1);
1339 		session.getFlushMode();
1340 		sessionControl.setReturnValue(FlushMode.AUTO);
1341 		session.replicate(tb, ReplicationMode.LATEST_VERSION);
1342 		sessionControl.setVoidCallable(1);
1343 		session.flush();
1344 		sessionControl.setVoidCallable(1);
1345 		session.close();
1346 		sessionControl.setReturnValue(null, 1);
1347 		sfControl.replay();
1348 		sessionControl.replay();
1349 
1350 		HibernateTemplate ht = new HibernateTemplate(sf);
1351 		ht.replicate(tb, ReplicationMode.LATEST_VERSION);
1352 	}
1353 
testReplicateWithEntityName()1354 	public void testReplicateWithEntityName() throws HibernateException {
1355 		TestBean tb = new TestBean();
1356 		sf.openSession();
1357 		sfControl.setReturnValue(session, 1);
1358 		session.getSessionFactory();
1359 		sessionControl.setReturnValue(sf, 1);
1360 		session.getFlushMode();
1361 		sessionControl.setReturnValue(FlushMode.AUTO);
1362 		session.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
1363 		sessionControl.setVoidCallable(1);
1364 		session.flush();
1365 		sessionControl.setVoidCallable(1);
1366 		session.close();
1367 		sessionControl.setReturnValue(null, 1);
1368 		sfControl.replay();
1369 		sessionControl.replay();
1370 
1371 		HibernateTemplate ht = new HibernateTemplate(sf);
1372 		ht.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
1373 	}
1374 
testPersist()1375 	public void testPersist() throws HibernateException {
1376 		TestBean tb = new TestBean();
1377 		sf.openSession();
1378 		sfControl.setReturnValue(session, 1);
1379 		session.getSessionFactory();
1380 		sessionControl.setReturnValue(sf, 1);
1381 		session.getFlushMode();
1382 		sessionControl.setReturnValue(FlushMode.AUTO);
1383 		session.persist(tb);
1384 		sessionControl.setVoidCallable(1);
1385 		session.flush();
1386 		sessionControl.setVoidCallable(1);
1387 		session.close();
1388 		sessionControl.setReturnValue(null, 1);
1389 		sfControl.replay();
1390 		sessionControl.replay();
1391 
1392 		HibernateTemplate ht = new HibernateTemplate(sf);
1393 		ht.persist(tb);
1394 	}
1395 
testPersistWithEntityName()1396 	public void testPersistWithEntityName() throws HibernateException {
1397 		TestBean tb = new TestBean();
1398 		sf.openSession();
1399 		sfControl.setReturnValue(session, 1);
1400 		session.getSessionFactory();
1401 		sessionControl.setReturnValue(sf, 1);
1402 		session.getFlushMode();
1403 		sessionControl.setReturnValue(FlushMode.AUTO);
1404 		session.persist("myEntity", tb);
1405 		sessionControl.setVoidCallable(1);
1406 		session.flush();
1407 		sessionControl.setVoidCallable(1);
1408 		session.close();
1409 		sessionControl.setReturnValue(null, 1);
1410 		sfControl.replay();
1411 		sessionControl.replay();
1412 
1413 		HibernateTemplate ht = new HibernateTemplate(sf);
1414 		ht.persist("myEntity", tb);
1415 	}
1416 
testMerge()1417 	public void testMerge() throws HibernateException {
1418 		TestBean tb = new TestBean();
1419 		TestBean tbMerged = new TestBean();
1420 		sf.openSession();
1421 		sfControl.setReturnValue(session, 1);
1422 		session.getSessionFactory();
1423 		sessionControl.setReturnValue(sf, 1);
1424 		session.getFlushMode();
1425 		sessionControl.setReturnValue(FlushMode.AUTO);
1426 		session.merge(tb);
1427 		sessionControl.setReturnValue(tbMerged, 1);
1428 		session.flush();
1429 		sessionControl.setVoidCallable(1);
1430 		session.close();
1431 		sessionControl.setReturnValue(null, 1);
1432 		sfControl.replay();
1433 		sessionControl.replay();
1434 
1435 		HibernateTemplate ht = new HibernateTemplate(sf);
1436 		assertSame(tbMerged, ht.merge(tb));
1437 	}
1438 
testMergeWithEntityName()1439 	public void testMergeWithEntityName() throws HibernateException {
1440 		TestBean tb = new TestBean();
1441 		TestBean tbMerged = new TestBean();
1442 		sf.openSession();
1443 		sfControl.setReturnValue(session, 1);
1444 		session.getSessionFactory();
1445 		sessionControl.setReturnValue(sf, 1);
1446 		session.getFlushMode();
1447 		sessionControl.setReturnValue(FlushMode.AUTO);
1448 		session.merge("myEntity", tb);
1449 		sessionControl.setReturnValue(tbMerged, 1);
1450 		session.flush();
1451 		sessionControl.setVoidCallable(1);
1452 		session.close();
1453 		sessionControl.setReturnValue(null, 1);
1454 		sfControl.replay();
1455 		sessionControl.replay();
1456 
1457 		HibernateTemplate ht = new HibernateTemplate(sf);
1458 		assertSame(tbMerged, ht.merge("myEntity", tb));
1459 	}
1460 
testDelete()1461 	public void testDelete() throws HibernateException {
1462 		TestBean tb = new TestBean();
1463 		sf.openSession();
1464 		sfControl.setReturnValue(session, 1);
1465 		session.getSessionFactory();
1466 		sessionControl.setReturnValue(sf, 1);
1467 		session.getFlushMode();
1468 		sessionControl.setReturnValue(FlushMode.AUTO);
1469 		session.delete(tb);
1470 		sessionControl.setVoidCallable(1);
1471 		session.flush();
1472 		sessionControl.setVoidCallable(1);
1473 		session.close();
1474 		sessionControl.setReturnValue(null, 1);
1475 		sfControl.replay();
1476 		sessionControl.replay();
1477 
1478 		HibernateTemplate ht = new HibernateTemplate(sf);
1479 		ht.delete(tb);
1480 	}
1481 
testDeleteWithLockMode()1482 	public void testDeleteWithLockMode() throws HibernateException {
1483 		TestBean tb = new TestBean();
1484 		sf.openSession();
1485 		sfControl.setReturnValue(session, 1);
1486 		session.getSessionFactory();
1487 		sessionControl.setReturnValue(sf, 1);
1488 		session.getFlushMode();
1489 		sessionControl.setReturnValue(FlushMode.AUTO);
1490 		session.lock(tb, LockMode.UPGRADE);
1491 		sessionControl.setVoidCallable(1);
1492 		session.delete(tb);
1493 		sessionControl.setVoidCallable(1);
1494 		session.flush();
1495 		sessionControl.setVoidCallable(1);
1496 		session.close();
1497 		sessionControl.setReturnValue(null, 1);
1498 		sfControl.replay();
1499 		sessionControl.replay();
1500 
1501 		HibernateTemplate ht = new HibernateTemplate(sf);
1502 		ht.delete(tb, LockMode.UPGRADE);
1503 	}
1504 
testDeleteWithEntityName()1505 	public void testDeleteWithEntityName() throws HibernateException {
1506 		TestBean tb = new TestBean();
1507 		sf.openSession();
1508 		sfControl.setReturnValue(session, 1);
1509 		session.getSessionFactory();
1510 		sessionControl.setReturnValue(sf, 1);
1511 		session.getFlushMode();
1512 		sessionControl.setReturnValue(FlushMode.AUTO);
1513 		session.delete("myEntity", tb);
1514 		sessionControl.setVoidCallable(1);
1515 		session.flush();
1516 		sessionControl.setVoidCallable(1);
1517 		session.close();
1518 		sessionControl.setReturnValue(null, 1);
1519 		sfControl.replay();
1520 		sessionControl.replay();
1521 
1522 		HibernateTemplate ht = new HibernateTemplate(sf);
1523 		ht.delete("myEntity", tb);
1524 	}
1525 
testDeleteWithEntityNameAndLockMode()1526 	public void testDeleteWithEntityNameAndLockMode() throws HibernateException {
1527 		TestBean tb = new TestBean();
1528 		sf.openSession();
1529 		sfControl.setReturnValue(session, 1);
1530 		session.getSessionFactory();
1531 		sessionControl.setReturnValue(sf, 1);
1532 		session.getFlushMode();
1533 		sessionControl.setReturnValue(FlushMode.AUTO);
1534 		session.lock("myEntity", tb, LockMode.UPGRADE);
1535 		sessionControl.setVoidCallable(1);
1536 		session.delete("myEntity", tb);
1537 		sessionControl.setVoidCallable(1);
1538 		session.flush();
1539 		sessionControl.setVoidCallable(1);
1540 		session.close();
1541 		sessionControl.setReturnValue(null, 1);
1542 		sfControl.replay();
1543 		sessionControl.replay();
1544 
1545 		HibernateTemplate ht = new HibernateTemplate(sf);
1546 		ht.delete("myEntity", tb, LockMode.UPGRADE);
1547 	}
1548 
testDeleteAll()1549 	public void testDeleteAll() throws HibernateException {
1550 		TestBean tb1 = new TestBean();
1551 		TestBean tb2 = new TestBean();
1552 		sf.openSession();
1553 		sfControl.setReturnValue(session, 1);
1554 		session.getSessionFactory();
1555 		sessionControl.setReturnValue(sf, 1);
1556 		session.getFlushMode();
1557 		sessionControl.setReturnValue(FlushMode.AUTO);
1558 		session.delete(tb1);
1559 		sessionControl.setVoidCallable(1);
1560 		session.delete(tb2);
1561 		sessionControl.setVoidCallable(1);
1562 		session.flush();
1563 		sessionControl.setVoidCallable(1);
1564 		session.close();
1565 		sessionControl.setReturnValue(null, 1);
1566 		sfControl.replay();
1567 		sessionControl.replay();
1568 
1569 		HibernateTemplate ht = new HibernateTemplate(sf);
1570 		List tbs = new ArrayList();
1571 		tbs.add(tb1);
1572 		tbs.add(tb2);
1573 		ht.deleteAll(tbs);
1574 	}
1575 
testFlush()1576 	public void testFlush() throws HibernateException {
1577 		sf.openSession();
1578 		sfControl.setReturnValue(session, 1);
1579 		session.getSessionFactory();
1580 		sessionControl.setReturnValue(sf, 1);
1581 		session.setFlushMode(FlushMode.MANUAL);
1582 		sessionControl.setVoidCallable(1);
1583 		session.flush();
1584 		sessionControl.setVoidCallable(1);
1585 		session.close();
1586 		sessionControl.setReturnValue(null, 1);
1587 		sfControl.replay();
1588 		sessionControl.replay();
1589 
1590 		HibernateTemplate ht = new HibernateTemplate(sf);
1591 		ht.setFlushMode(HibernateTemplate.FLUSH_NEVER);
1592 		ht.flush();
1593 	}
1594 
testClear()1595 	public void testClear() throws HibernateException {
1596 		sf.openSession();
1597 		sfControl.setReturnValue(session, 1);
1598 		session.getSessionFactory();
1599 		sessionControl.setReturnValue(sf, 1);
1600 		session.clear();
1601 		sessionControl.setVoidCallable(1);
1602 		session.flush();
1603 		sessionControl.setVoidCallable(1);
1604 		session.close();
1605 		sessionControl.setReturnValue(null, 1);
1606 		sfControl.replay();
1607 		sessionControl.replay();
1608 
1609 		HibernateTemplate ht = new HibernateTemplate(sf);
1610 		ht.clear();
1611 	}
1612 
testFind()1613 	public void testFind() throws HibernateException {
1614 		MockControl queryControl = MockControl.createControl(Query.class);
1615 		Query query = (Query) queryControl.getMock();
1616 
1617 		List list = new ArrayList();
1618 		sf.openSession();
1619 		sfControl.setReturnValue(session, 1);
1620 		session.getSessionFactory();
1621 		sessionControl.setReturnValue(sf, 1);
1622 		session.createQuery("some query string");
1623 		sessionControl.setReturnValue(query, 1);
1624 		query.list();
1625 		queryControl.setReturnValue(list, 1);
1626 		session.flush();
1627 		sessionControl.setVoidCallable(1);
1628 		session.close();
1629 		sessionControl.setReturnValue(null, 1);
1630 		sfControl.replay();
1631 		sessionControl.replay();
1632 		queryControl.replay();
1633 
1634 		HibernateTemplate ht = new HibernateTemplate(sf);
1635 		List result = ht.find("some query string");
1636 		assertTrue("Correct list", result == list);
1637 		queryControl.verify();
1638 	}
1639 
testFindWithParameter()1640 	public void testFindWithParameter() throws HibernateException {
1641 		MockControl queryControl = MockControl.createControl(Query.class);
1642 		Query query = (Query) queryControl.getMock();
1643 
1644 		List list = new ArrayList();
1645 		sf.openSession();
1646 		sfControl.setReturnValue(session, 1);
1647 		session.getSessionFactory();
1648 		sessionControl.setReturnValue(sf, 1);
1649 		session.createQuery("some query string");
1650 		sessionControl.setReturnValue(query, 1);
1651 		query.setParameter(0, "myvalue");
1652 		queryControl.setReturnValue(query, 1);
1653 		query.list();
1654 		queryControl.setReturnValue(list, 1);
1655 		session.flush();
1656 		sessionControl.setVoidCallable(1);
1657 		session.close();
1658 		sessionControl.setReturnValue(null, 1);
1659 		sfControl.replay();
1660 		sessionControl.replay();
1661 		queryControl.replay();
1662 
1663 		HibernateTemplate ht = new HibernateTemplate(sf);
1664 		List result = ht.find("some query string", "myvalue");
1665 		assertTrue("Correct list", result == list);
1666 		queryControl.verify();
1667 	}
1668 
testFindWithParameters()1669 	public void testFindWithParameters() throws HibernateException {
1670 		MockControl queryControl = MockControl.createControl(Query.class);
1671 		Query query = (Query) queryControl.getMock();
1672 
1673 		List list = new ArrayList();
1674 		sf.openSession();
1675 		sfControl.setReturnValue(session, 1);
1676 		session.getSessionFactory();
1677 		sessionControl.setReturnValue(sf, 1);
1678 		session.createQuery("some query string");
1679 		sessionControl.setReturnValue(query, 1);
1680 		query.setParameter(0, "myvalue1");
1681 		queryControl.setReturnValue(query, 1);
1682 		query.setParameter(1, new Integer(2));
1683 		queryControl.setReturnValue(query, 1);
1684 		query.list();
1685 		queryControl.setReturnValue(list, 1);
1686 		session.flush();
1687 		sessionControl.setVoidCallable(1);
1688 		session.close();
1689 		sessionControl.setReturnValue(null, 1);
1690 		sfControl.replay();
1691 		sessionControl.replay();
1692 		queryControl.replay();
1693 
1694 		HibernateTemplate ht = new HibernateTemplate(sf);
1695 		List result = ht.find("some query string", new Object[] {"myvalue1", new Integer(2)});
1696 		assertTrue("Correct list", result == list);
1697 		queryControl.verify();
1698 	}
1699 
testFindWithNamedParameter()1700 	public void testFindWithNamedParameter() throws HibernateException {
1701 		MockControl queryControl = MockControl.createControl(Query.class);
1702 		Query query = (Query) queryControl.getMock();
1703 
1704 		List list = new ArrayList();
1705 		sf.openSession();
1706 		sfControl.setReturnValue(session, 1);
1707 		session.getSessionFactory();
1708 		sessionControl.setReturnValue(sf, 1);
1709 		session.createQuery("some query string");
1710 		sessionControl.setReturnValue(query, 1);
1711 		query.setParameter("myparam", "myvalue");
1712 		queryControl.setReturnValue(query, 1);
1713 		query.list();
1714 		queryControl.setReturnValue(list, 1);
1715 		session.flush();
1716 		sessionControl.setVoidCallable(1);
1717 		session.close();
1718 		sessionControl.setReturnValue(null, 1);
1719 		sfControl.replay();
1720 		sessionControl.replay();
1721 		queryControl.replay();
1722 
1723 		HibernateTemplate ht = new HibernateTemplate(sf);
1724 		List result = ht.findByNamedParam("some query string", "myparam", "myvalue");
1725 		assertTrue("Correct list", result == list);
1726 		queryControl.verify();
1727 	}
1728 
testFindWithNamedParameters()1729 	public void testFindWithNamedParameters() throws HibernateException {
1730 		MockControl queryControl = MockControl.createControl(Query.class);
1731 		Query query = (Query) queryControl.getMock();
1732 
1733 		List list = new ArrayList();
1734 		sf.openSession();
1735 		sfControl.setReturnValue(session, 1);
1736 		session.getSessionFactory();
1737 		sessionControl.setReturnValue(sf, 1);
1738 		session.createQuery("some query string");
1739 		sessionControl.setReturnValue(query, 1);
1740 		query.setParameter("myparam1", "myvalue1");
1741 		queryControl.setReturnValue(query, 1);
1742 		query.setParameter("myparam2", new Integer(2));
1743 		queryControl.setReturnValue(query, 1);
1744 		query.list();
1745 		queryControl.setReturnValue(list, 1);
1746 		session.flush();
1747 		sessionControl.setVoidCallable(1);
1748 		session.close();
1749 		sessionControl.setReturnValue(null, 1);
1750 		sfControl.replay();
1751 		sessionControl.replay();
1752 		queryControl.replay();
1753 
1754 		HibernateTemplate ht = new HibernateTemplate(sf);
1755 		List result = ht.findByNamedParam("some query string",
1756 				new String[] {"myparam1", "myparam2"},
1757 				new Object[] {"myvalue1", new Integer(2)});
1758 		assertTrue("Correct list", result == list);
1759 		queryControl.verify();
1760 	}
1761 
testFindByValueBean()1762 	public void testFindByValueBean() throws HibernateException {
1763 		MockControl queryControl = MockControl.createControl(Query.class);
1764 		Query query = (Query) queryControl.getMock();
1765 
1766 		TestBean tb = new TestBean();
1767 		List list = new ArrayList();
1768 		sf.openSession();
1769 		sfControl.setReturnValue(session, 1);
1770 		session.getSessionFactory();
1771 		sessionControl.setReturnValue(sf, 1);
1772 		session.createQuery("some query string");
1773 		sessionControl.setReturnValue(query, 1);
1774 		query.setProperties(tb);
1775 		queryControl.setReturnValue(query, 1);
1776 		query.list();
1777 		queryControl.setReturnValue(list, 1);
1778 		session.flush();
1779 		sessionControl.setVoidCallable(1);
1780 		session.close();
1781 		sessionControl.setReturnValue(null, 1);
1782 		sfControl.replay();
1783 		sessionControl.replay();
1784 		queryControl.replay();
1785 
1786 		HibernateTemplate ht = new HibernateTemplate(sf);
1787 		List result = ht.findByValueBean("some query string", tb);
1788 		assertTrue("Correct list", result == list);
1789 		queryControl.verify();
1790 	}
1791 
testFindByNamedQuery()1792 	public void testFindByNamedQuery() throws HibernateException {
1793 		MockControl queryControl = MockControl.createControl(Query.class);
1794 		Query query = (Query) queryControl.getMock();
1795 
1796 		List list = new ArrayList();
1797 		sf.openSession();
1798 		sfControl.setReturnValue(session, 1);
1799 		session.getSessionFactory();
1800 		sessionControl.setReturnValue(sf, 1);
1801 		session.getNamedQuery("some query name");
1802 		sessionControl.setReturnValue(query, 1);
1803 		query.list();
1804 		queryControl.setReturnValue(list, 1);
1805 		session.flush();
1806 		sessionControl.setVoidCallable(1);
1807 		session.close();
1808 		sessionControl.setReturnValue(null, 1);
1809 		sfControl.replay();
1810 		sessionControl.replay();
1811 		queryControl.replay();
1812 
1813 		HibernateTemplate ht = new HibernateTemplate(sf);
1814 		List result = ht.findByNamedQuery("some query name");
1815 		assertTrue("Correct list", result == list);
1816 		queryControl.verify();
1817 	}
1818 
testFindByNamedQueryWithParameter()1819 	public void testFindByNamedQueryWithParameter() throws HibernateException {
1820 		MockControl queryControl = MockControl.createControl(Query.class);
1821 		Query query = (Query) queryControl.getMock();
1822 
1823 		List list = new ArrayList();
1824 		sf.openSession();
1825 		sfControl.setReturnValue(session, 1);
1826 		session.getSessionFactory();
1827 		sessionControl.setReturnValue(sf, 1);
1828 		session.getNamedQuery("some query name");
1829 		sessionControl.setReturnValue(query, 1);
1830 		query.setParameter(0, "myvalue");
1831 		queryControl.setReturnValue(query, 1);
1832 		query.list();
1833 		queryControl.setReturnValue(list, 1);
1834 		session.flush();
1835 		sessionControl.setVoidCallable(1);
1836 		session.close();
1837 		sessionControl.setReturnValue(null, 1);
1838 		sfControl.replay();
1839 		sessionControl.replay();
1840 		queryControl.replay();
1841 
1842 		HibernateTemplate ht = new HibernateTemplate(sf);
1843 		List result = ht.findByNamedQuery("some query name", "myvalue");
1844 		assertTrue("Correct list", result == list);
1845 		queryControl.verify();
1846 	}
1847 
testFindByNamedQueryWithParameters()1848 	public void testFindByNamedQueryWithParameters() throws HibernateException {
1849 		MockControl queryControl = MockControl.createControl(Query.class);
1850 		Query query = (Query) queryControl.getMock();
1851 
1852 		List list = new ArrayList();
1853 		sf.openSession();
1854 		sfControl.setReturnValue(session, 1);
1855 		session.getSessionFactory();
1856 		sessionControl.setReturnValue(sf, 1);
1857 		session.getNamedQuery("some query name");
1858 		sessionControl.setReturnValue(query, 1);
1859 		query.setParameter(0, "myvalue1");
1860 		queryControl.setReturnValue(query, 1);
1861 		query.setParameter(1, new Integer(2));
1862 		queryControl.setReturnValue(query, 1);
1863 		query.list();
1864 		queryControl.setReturnValue(list, 1);
1865 		session.flush();
1866 		sessionControl.setVoidCallable(1);
1867 		session.close();
1868 		sessionControl.setReturnValue(null, 1);
1869 		sfControl.replay();
1870 		sessionControl.replay();
1871 		queryControl.replay();
1872 
1873 		HibernateTemplate ht = new HibernateTemplate(sf);
1874 		List result = ht.findByNamedQuery("some query name", new Object[] {"myvalue1", new Integer(2)});
1875 		assertTrue("Correct list", result == list);
1876 		queryControl.verify();
1877 	}
1878 
testFindByNamedQueryWithNamedParameter()1879 	public void testFindByNamedQueryWithNamedParameter() throws HibernateException {
1880 		MockControl queryControl = MockControl.createControl(Query.class);
1881 		Query query = (Query) queryControl.getMock();
1882 
1883 		List list = new ArrayList();
1884 		sf.openSession();
1885 		sfControl.setReturnValue(session, 1);
1886 		session.getSessionFactory();
1887 		sessionControl.setReturnValue(sf, 1);
1888 		session.getNamedQuery("some query name");
1889 		sessionControl.setReturnValue(query, 1);
1890 		query.setParameter("myparam", "myvalue");
1891 		queryControl.setReturnValue(query, 1);
1892 		query.list();
1893 		queryControl.setReturnValue(list, 1);
1894 		session.flush();
1895 		sessionControl.setVoidCallable(1);
1896 		session.close();
1897 		sessionControl.setReturnValue(null, 1);
1898 		sfControl.replay();
1899 		sessionControl.replay();
1900 		queryControl.replay();
1901 
1902 		HibernateTemplate ht = new HibernateTemplate(sf);
1903 		List result = ht.findByNamedQueryAndNamedParam("some query name", "myparam", "myvalue");
1904 		assertTrue("Correct list", result == list);
1905 		queryControl.verify();
1906 	}
1907 
testFindByNamedQueryWithNamedParameters()1908 	public void testFindByNamedQueryWithNamedParameters() throws HibernateException {
1909 		MockControl queryControl = MockControl.createControl(Query.class);
1910 		Query query = (Query) queryControl.getMock();
1911 
1912 		List list = new ArrayList();
1913 		sf.openSession();
1914 		sfControl.setReturnValue(session, 1);
1915 		session.getSessionFactory();
1916 		sessionControl.setReturnValue(sf, 1);
1917 		session.getNamedQuery("some query name");
1918 		sessionControl.setReturnValue(query, 1);
1919 		query.setParameter("myparam1", "myvalue1");
1920 		queryControl.setReturnValue(query, 1);
1921 		query.setParameter("myparam2", new Integer(2));
1922 		queryControl.setReturnValue(query, 1);
1923 		query.list();
1924 		queryControl.setReturnValue(list, 1);
1925 		session.flush();
1926 		sessionControl.setVoidCallable(1);
1927 		session.close();
1928 		sessionControl.setReturnValue(null, 1);
1929 		sfControl.replay();
1930 		sessionControl.replay();
1931 		queryControl.replay();
1932 
1933 		HibernateTemplate ht = new HibernateTemplate(sf);
1934 		List result = ht.findByNamedQueryAndNamedParam("some query name",
1935 				new String[] {"myparam1", "myparam2"},
1936 				new Object[] {"myvalue1", new Integer(2)});
1937 		assertTrue("Correct list", result == list);
1938 		queryControl.verify();
1939 	}
1940 
testFindByNamedQueryAndValueBean()1941 	public void testFindByNamedQueryAndValueBean() throws HibernateException {
1942 		MockControl queryControl = MockControl.createControl(Query.class);
1943 		Query query = (Query) queryControl.getMock();
1944 
1945 		TestBean tb = new TestBean();
1946 		List list = new ArrayList();
1947 		sf.openSession();
1948 		sfControl.setReturnValue(session, 1);
1949 		session.getSessionFactory();
1950 		sessionControl.setReturnValue(sf, 1);
1951 		session.getNamedQuery("some query name");
1952 		sessionControl.setReturnValue(query, 1);
1953 		query.setProperties(tb);
1954 		queryControl.setReturnValue(query, 1);
1955 		query.list();
1956 		queryControl.setReturnValue(list, 1);
1957 		session.flush();
1958 		sessionControl.setVoidCallable(1);
1959 		session.close();
1960 		sessionControl.setReturnValue(null, 1);
1961 		sfControl.replay();
1962 		sessionControl.replay();
1963 		queryControl.replay();
1964 
1965 		HibernateTemplate ht = new HibernateTemplate(sf);
1966 		List result = ht.findByNamedQueryAndValueBean("some query name", tb);
1967 		assertTrue("Correct list", result == list);
1968 		queryControl.verify();
1969 	}
1970 
testFindWithCacheable()1971 	public void testFindWithCacheable() throws HibernateException {
1972 		MockControl queryControl = MockControl.createControl(Query.class);
1973 		Query query = (Query) queryControl.getMock();
1974 
1975 		List list = new ArrayList();
1976 		sf.openSession();
1977 		sfControl.setReturnValue(session, 1);
1978 		session.getSessionFactory();
1979 		sessionControl.setReturnValue(sf, 1);
1980 		session.createQuery("some query string");
1981 		sessionControl.setReturnValue(query, 1);
1982 		query.setCacheable(true);
1983 		queryControl.setReturnValue(query, 1);
1984 		query.list();
1985 		queryControl.setReturnValue(list, 1);
1986 		session.flush();
1987 		sessionControl.setVoidCallable(1);
1988 		session.close();
1989 		sessionControl.setReturnValue(null, 1);
1990 		sfControl.replay();
1991 		sessionControl.replay();
1992 		queryControl.replay();
1993 
1994 		HibernateTemplate ht = new HibernateTemplate(sf);
1995 		ht.setCacheQueries(true);
1996 		List result = ht.find("some query string");
1997 		assertTrue("Correct list", result == list);
1998 		sfControl.verify();
1999 	}
2000 
testFindWithCacheableAndCacheRegion()2001 	public void testFindWithCacheableAndCacheRegion() throws HibernateException {
2002 		MockControl queryControl = MockControl.createControl(Query.class);
2003 		Query query = (Query) queryControl.getMock();
2004 
2005 		List list = new ArrayList();
2006 		sf.openSession();
2007 		sfControl.setReturnValue(session, 1);
2008 		session.getSessionFactory();
2009 		sessionControl.setReturnValue(sf, 1);
2010 		session.createQuery("some query string");
2011 		sessionControl.setReturnValue(query, 1);
2012 		query.setCacheable(true);
2013 		queryControl.setReturnValue(query, 1);
2014 		query.setCacheRegion("myCacheRegion");
2015 		queryControl.setReturnValue(query, 1);
2016 		query.list();
2017 		queryControl.setReturnValue(list, 1);
2018 		session.flush();
2019 		sessionControl.setVoidCallable(1);
2020 		session.close();
2021 		sessionControl.setReturnValue(null, 1);
2022 		sfControl.replay();
2023 		sessionControl.replay();
2024 		queryControl.replay();
2025 
2026 		HibernateTemplate ht = new HibernateTemplate(sf);
2027 		ht.setCacheQueries(true);
2028 		ht.setQueryCacheRegion("myCacheRegion");
2029 		List result = ht.find("some query string");
2030 		assertTrue("Correct list", result == list);
2031 		sfControl.verify();
2032 	}
2033 
testFindByNamedQueryWithCacheable()2034 	public void testFindByNamedQueryWithCacheable() throws HibernateException {
2035 		MockControl queryControl = MockControl.createControl(Query.class);
2036 		Query query = (Query) queryControl.getMock();
2037 
2038 		List list = new ArrayList();
2039 		sf.openSession();
2040 		sfControl.setReturnValue(session, 1);
2041 		session.getSessionFactory();
2042 		sessionControl.setReturnValue(sf, 1);
2043 		session.getNamedQuery("some query name");
2044 		sessionControl.setReturnValue(query, 1);
2045 		query.setCacheable(true);
2046 		queryControl.setReturnValue(query, 1);
2047 		query.list();
2048 		queryControl.setReturnValue(list, 1);
2049 		session.flush();
2050 		sessionControl.setVoidCallable(1);
2051 		session.close();
2052 		sessionControl.setReturnValue(null, 1);
2053 		sfControl.replay();
2054 		sessionControl.replay();
2055 		queryControl.replay();
2056 
2057 		HibernateTemplate ht = new HibernateTemplate(sf);
2058 		ht.setCacheQueries(true);
2059 		List result = ht.findByNamedQuery("some query name");
2060 		assertTrue("Correct list", result == list);
2061 		queryControl.verify();
2062 	}
2063 
testFindByNamedQueryWithCacheableAndCacheRegion()2064 	public void testFindByNamedQueryWithCacheableAndCacheRegion() throws HibernateException {
2065 		MockControl queryControl = MockControl.createControl(Query.class);
2066 		Query query = (Query) queryControl.getMock();
2067 
2068 		List list = new ArrayList();
2069 		sf.openSession();
2070 		sfControl.setReturnValue(session, 1);
2071 		session.getSessionFactory();
2072 		sessionControl.setReturnValue(sf, 1);
2073 		session.getNamedQuery("some query name");
2074 		sessionControl.setReturnValue(query, 1);
2075 		query.setCacheable(true);
2076 		queryControl.setReturnValue(query, 1);
2077 		query.setCacheRegion("myCacheRegion");
2078 		queryControl.setReturnValue(query, 1);
2079 		query.list();
2080 		queryControl.setReturnValue(list, 1);
2081 		session.flush();
2082 		sessionControl.setVoidCallable(1);
2083 		session.close();
2084 		sessionControl.setReturnValue(null, 1);
2085 		sfControl.replay();
2086 		sessionControl.replay();
2087 		queryControl.replay();
2088 
2089 		HibernateTemplate ht = new HibernateTemplate(sf);
2090 		ht.setCacheQueries(true);
2091 		ht.setQueryCacheRegion("myCacheRegion");
2092 		List result = ht.findByNamedQuery("some query name");
2093 		assertTrue("Correct list", result == list);
2094 		queryControl.verify();
2095 	}
2096 
testIterate()2097 	public void testIterate() throws HibernateException {
2098 		MockControl queryControl = MockControl.createControl(Query.class);
2099 		Query query = (Query) queryControl.getMock();
2100 
2101 		Iterator it = Collections.EMPTY_LIST.iterator();
2102 		sf.openSession();
2103 		sfControl.setReturnValue(session, 1);
2104 		session.getSessionFactory();
2105 		sessionControl.setReturnValue(sf, 1);
2106 		session.createQuery("some query string");
2107 		sessionControl.setReturnValue(query, 1);
2108 		query.iterate();
2109 		queryControl.setReturnValue(it, 1);
2110 		session.flush();
2111 		sessionControl.setVoidCallable(1);
2112 		session.close();
2113 		sessionControl.setReturnValue(null, 1);
2114 		sfControl.replay();
2115 		sessionControl.replay();
2116 		queryControl.replay();
2117 
2118 		HibernateTemplate ht = new HibernateTemplate(sf);
2119 		Iterator result = ht.iterate("some query string");
2120 		assertTrue("Correct list", result == it);
2121 		queryControl.verify();
2122 	}
2123 
testIterateWithParameter()2124 	public void testIterateWithParameter() throws HibernateException {
2125 		MockControl queryControl = MockControl.createControl(Query.class);
2126 		Query query = (Query) queryControl.getMock();
2127 
2128 		Iterator it = Collections.EMPTY_LIST.iterator();
2129 		sf.openSession();
2130 		sfControl.setReturnValue(session, 1);
2131 		session.getSessionFactory();
2132 		sessionControl.setReturnValue(sf, 1);
2133 		session.createQuery("some query string");
2134 		sessionControl.setReturnValue(query, 1);
2135 		query.setParameter(0, "myvalue");
2136 		queryControl.setReturnValue(query, 1);
2137 		query.iterate();
2138 		queryControl.setReturnValue(it, 1);
2139 		session.flush();
2140 		sessionControl.setVoidCallable(1);
2141 		session.close();
2142 		sessionControl.setReturnValue(null, 1);
2143 		sfControl.replay();
2144 		sessionControl.replay();
2145 		queryControl.replay();
2146 
2147 		HibernateTemplate ht = new HibernateTemplate(sf);
2148 		Iterator result = ht.iterate("some query string", "myvalue");
2149 		assertTrue("Correct list", result == it);
2150 		queryControl.verify();
2151 	}
2152 
testIterateWithParameters()2153 	public void testIterateWithParameters() throws HibernateException {
2154 		MockControl queryControl = MockControl.createControl(Query.class);
2155 		Query query = (Query) queryControl.getMock();
2156 
2157 		Iterator it = Collections.EMPTY_LIST.iterator();
2158 		sf.openSession();
2159 		sfControl.setReturnValue(session, 1);
2160 		session.getSessionFactory();
2161 		sessionControl.setReturnValue(sf, 1);
2162 		session.createQuery("some query string");
2163 		sessionControl.setReturnValue(query, 1);
2164 		query.setParameter(0, "myvalue1");
2165 		queryControl.setReturnValue(query, 1);
2166 		query.setParameter(1, new Integer(2));
2167 		queryControl.setReturnValue(query, 1);
2168 		query.iterate();
2169 		queryControl.setReturnValue(it, 1);
2170 		session.flush();
2171 		sessionControl.setVoidCallable(1);
2172 		session.close();
2173 		sessionControl.setReturnValue(null, 1);
2174 		sfControl.replay();
2175 		sessionControl.replay();
2176 		queryControl.replay();
2177 
2178 		HibernateTemplate ht = new HibernateTemplate(sf);
2179 		Iterator result = ht.iterate("some query string",
2180 				new Object[] {"myvalue1", new Integer(2)});
2181 		assertTrue("Correct list", result == it);
2182 		sfControl.verify();
2183 	}
2184 
testBulkUpdate()2185 	public void testBulkUpdate() throws HibernateException {
2186 		MockControl queryControl = MockControl.createControl(Query.class);
2187 		Query query = (Query) queryControl.getMock();
2188 
2189 		sf.openSession();
2190 		sfControl.setReturnValue(session, 1);
2191 		session.getSessionFactory();
2192 		sessionControl.setReturnValue(sf, 1);
2193 		session.createQuery("some query string");
2194 		sessionControl.setReturnValue(query, 1);
2195 		query.executeUpdate();
2196 		queryControl.setReturnValue(5, 1);
2197 		session.flush();
2198 		sessionControl.setVoidCallable(1);
2199 		session.close();
2200 		sessionControl.setReturnValue(null, 1);
2201 		sfControl.replay();
2202 		sessionControl.replay();
2203 		queryControl.replay();
2204 
2205 		HibernateTemplate ht = new HibernateTemplate(sf);
2206 		int result = ht.bulkUpdate("some query string");
2207 		assertTrue("Correct list", result == 5);
2208 		queryControl.verify();
2209 	}
2210 
testBulkUpdateWithParameter()2211 	public void testBulkUpdateWithParameter() throws HibernateException {
2212 		MockControl queryControl = MockControl.createControl(Query.class);
2213 		Query query = (Query) queryControl.getMock();
2214 
2215 		sf.openSession();
2216 		sfControl.setReturnValue(session, 1);
2217 		session.getSessionFactory();
2218 		sessionControl.setReturnValue(sf, 1);
2219 		session.createQuery("some query string");
2220 		sessionControl.setReturnValue(query, 1);
2221 		query.setParameter(0, "myvalue");
2222 		queryControl.setReturnValue(query, 1);
2223 		query.executeUpdate();
2224 		queryControl.setReturnValue(5, 1);
2225 		session.flush();
2226 		sessionControl.setVoidCallable(1);
2227 		session.close();
2228 		sessionControl.setReturnValue(null, 1);
2229 		sfControl.replay();
2230 		sessionControl.replay();
2231 		queryControl.replay();
2232 
2233 		HibernateTemplate ht = new HibernateTemplate(sf);
2234 		int result = ht.bulkUpdate("some query string", "myvalue");
2235 		assertTrue("Correct list", result == 5);
2236 		queryControl.verify();
2237 	}
2238 
testBulkUpdateWithParameters()2239 	public void testBulkUpdateWithParameters() throws HibernateException {
2240 		MockControl queryControl = MockControl.createControl(Query.class);
2241 		Query query = (Query) queryControl.getMock();
2242 
2243 		sf.openSession();
2244 		sfControl.setReturnValue(session, 1);
2245 		session.getSessionFactory();
2246 		sessionControl.setReturnValue(sf, 1);
2247 		session.createQuery("some query string");
2248 		sessionControl.setReturnValue(query, 1);
2249 		query.setParameter(0, "myvalue1");
2250 		queryControl.setReturnValue(query, 1);
2251 		query.setParameter(1, new Integer(2));
2252 		queryControl.setReturnValue(query, 1);
2253 		query.executeUpdate();
2254 		queryControl.setReturnValue(5, 1);
2255 		session.flush();
2256 		sessionControl.setVoidCallable(1);
2257 		session.close();
2258 		sessionControl.setReturnValue(null, 1);
2259 		sfControl.replay();
2260 		sessionControl.replay();
2261 		queryControl.replay();
2262 
2263 		HibernateTemplate ht = new HibernateTemplate(sf);
2264 		int result = ht.bulkUpdate("some query string",
2265 				new Object[] {"myvalue1", new Integer(2)});
2266 		assertTrue("Correct list", result == 5);
2267 		queryControl.verify();
2268 	}
2269 
testExceptions()2270 	public void testExceptions() throws HibernateException {
2271 		SQLException sqlEx = new SQLException("argh", "27");
2272 
2273 		final JDBCConnectionException jcex = new JDBCConnectionException("mymsg", sqlEx);
2274 		try {
2275 			createTemplate().execute(new HibernateCallback() {
2276 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2277 					throw jcex;
2278 				}
2279 			});
2280 			fail("Should have thrown DataAccessResourceFailureException");
2281 		}
2282 		catch (DataAccessResourceFailureException ex) {
2283 			// expected
2284 			assertEquals(jcex, ex.getCause());
2285 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2286 		}
2287 
2288 		final SQLGrammarException sgex = new SQLGrammarException("mymsg", sqlEx);
2289 		try {
2290 			createTemplate().execute(new HibernateCallback() {
2291 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2292 					throw sgex;
2293 				}
2294 			});
2295 			fail("Should have thrown InvalidDataAccessResourceUsageException");
2296 		}
2297 		catch (InvalidDataAccessResourceUsageException ex) {
2298 			// expected
2299 			assertEquals(sgex, ex.getCause());
2300 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2301 		}
2302 
2303 		final LockAcquisitionException laex = new LockAcquisitionException("mymsg", sqlEx);
2304 		try {
2305 			createTemplate().execute(new HibernateCallback() {
2306 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2307 					throw laex;
2308 				}
2309 			});
2310 			fail("Should have thrown CannotAcquireLockException");
2311 		}
2312 		catch (CannotAcquireLockException ex) {
2313 			// expected
2314 			assertEquals(laex, ex.getCause());
2315 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2316 		}
2317 
2318 		final ConstraintViolationException cvex = new ConstraintViolationException("mymsg", sqlEx, "myconstraint");
2319 		try {
2320 			createTemplate().execute(new HibernateCallback() {
2321 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2322 					throw cvex;
2323 				}
2324 			});
2325 			fail("Should have thrown DataIntegrityViolationException");
2326 		}
2327 		catch (DataIntegrityViolationException ex) {
2328 			// expected
2329 			assertEquals(cvex, ex.getCause());
2330 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2331 		}
2332 
2333 		final DataException dex = new DataException("mymsg", sqlEx);
2334 		try {
2335 			createTemplate().execute(new HibernateCallback() {
2336 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2337 					throw dex;
2338 				}
2339 			});
2340 			fail("Should have thrown DataIntegrityViolationException");
2341 		}
2342 		catch (DataIntegrityViolationException ex) {
2343 			// expected
2344 			assertEquals(dex, ex.getCause());
2345 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2346 		}
2347 
2348 		final JDBCException jdex = new JDBCException("mymsg", sqlEx);
2349 		try {
2350 			createTemplate().execute(new HibernateCallback() {
2351 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2352 					throw jdex;
2353 				}
2354 			});
2355 			fail("Should have thrown HibernateJdbcException");
2356 		}
2357 		catch (HibernateJdbcException ex) {
2358 			// expected
2359 			assertEquals(jdex, ex.getCause());
2360 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2361 		}
2362 
2363 		final PropertyValueException pvex = new PropertyValueException("mymsg", "myentity", "myproperty");
2364 		try {
2365 			createTemplate().execute(new HibernateCallback() {
2366 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2367 					throw pvex;
2368 				}
2369 			});
2370 			fail("Should have thrown DataIntegrityViolationException");
2371 		}
2372 		catch (DataIntegrityViolationException ex) {
2373 			// expected
2374 			assertEquals(pvex, ex.getCause());
2375 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2376 		}
2377 
2378 		try {
2379 			createTemplate().execute(new HibernateCallback() {
2380 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2381 					throw new PersistentObjectException("");
2382 				}
2383 			});
2384 			fail("Should have thrown InvalidDataAccessApiUsageException");
2385 		}
2386 		catch (InvalidDataAccessApiUsageException ex) {
2387 			// expected
2388 		}
2389 
2390 		try {
2391 			createTemplate().execute(new HibernateCallback() {
2392 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2393 					throw new TransientObjectException("");
2394 				}
2395 			});
2396 			fail("Should have thrown InvalidDataAccessApiUsageException");
2397 		}
2398 		catch (InvalidDataAccessApiUsageException ex) {
2399 			// expected
2400 		}
2401 
2402 		final ObjectDeletedException odex = new ObjectDeletedException("msg", "id", TestBean.class.getName());
2403 		try {
2404 			createTemplate().execute(new HibernateCallback() {
2405 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2406 					throw odex;
2407 				}
2408 			});
2409 			fail("Should have thrown InvalidDataAccessApiUsageException");
2410 		}
2411 		catch (InvalidDataAccessApiUsageException ex) {
2412 			// expected
2413 			assertEquals(odex, ex.getCause());
2414 		}
2415 
2416 		final QueryException qex = new QueryException("msg");
2417 		qex.setQueryString("query");
2418 		try {
2419 			createTemplate().execute(new HibernateCallback() {
2420 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2421 					throw qex;
2422 				}
2423 			});
2424 			fail("Should have thrown InvalidDataAccessResourceUsageException");
2425 		}
2426 		catch (HibernateQueryException ex) {
2427 			// expected
2428 			assertEquals(qex, ex.getCause());
2429 			assertEquals("query", ex.getQueryString());
2430 		}
2431 
2432 		final UnresolvableObjectException uoex = new UnresolvableObjectException("id", TestBean.class.getName());
2433 		try {
2434 			createTemplate().execute(new HibernateCallback() {
2435 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2436 					throw uoex;
2437 				}
2438 			});
2439 			fail("Should have thrown HibernateObjectRetrievalFailureException");
2440 		}
2441 		catch (HibernateObjectRetrievalFailureException ex) {
2442 			// expected
2443 			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
2444 			assertEquals("id", ex.getIdentifier());
2445 			assertEquals(uoex, ex.getCause());
2446 		}
2447 
2448 		final ObjectNotFoundException onfe = new ObjectNotFoundException("id", TestBean.class.getName());
2449 		try {
2450 			createTemplate().execute(new HibernateCallback() {
2451 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2452 					throw onfe;
2453 				}
2454 			});
2455 			fail("Should have thrown HibernateObjectRetrievalFailureException");
2456 		}
2457 		catch (HibernateObjectRetrievalFailureException ex) {
2458 			// expected
2459 			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
2460 			assertEquals("id", ex.getIdentifier());
2461 			assertEquals(onfe, ex.getCause());
2462 		}
2463 
2464 		final WrongClassException wcex = new WrongClassException("msg", "id", TestBean.class.getName());
2465 		try {
2466 			createTemplate().execute(new HibernateCallback() {
2467 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2468 					throw wcex;
2469 				}
2470 			});
2471 			fail("Should have thrown HibernateObjectRetrievalFailureException");
2472 		}
2473 		catch (HibernateObjectRetrievalFailureException ex) {
2474 			// expected
2475 			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
2476 			assertEquals("id", ex.getIdentifier());
2477 			assertEquals(wcex, ex.getCause());
2478 		}
2479 
2480 		final NonUniqueResultException nuex = new NonUniqueResultException(2);
2481 		try {
2482 			createTemplate().execute(new HibernateCallback() {
2483 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2484 					throw nuex;
2485 				}
2486 			});
2487 			fail("Should have thrown IncorrectResultSizeDataAccessException");
2488 		}
2489 		catch (IncorrectResultSizeDataAccessException ex) {
2490 			// expected
2491 			assertEquals(1, ex.getExpectedSize());
2492 			assertEquals(-1, ex.getActualSize());
2493 		}
2494 
2495 		final StaleObjectStateException sosex = new StaleObjectStateException(TestBean.class.getName(), "id");
2496 		try {
2497 			createTemplate().execute(new HibernateCallback() {
2498 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2499 					throw sosex;
2500 				}
2501 			});
2502 			fail("Should have thrown HibernateOptimisticLockingFailureException");
2503 		}
2504 		catch (HibernateOptimisticLockingFailureException ex) {
2505 			// expected
2506 			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
2507 			assertEquals("id", ex.getIdentifier());
2508 			assertEquals(sosex, ex.getCause());
2509 		}
2510 
2511 		final StaleStateException ssex = new StaleStateException("msg");
2512 		try {
2513 			createTemplate().execute(new HibernateCallback() {
2514 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2515 					throw ssex;
2516 				}
2517 			});
2518 			fail("Should have thrown HibernateOptimisticLockingFailureException");
2519 		}
2520 		catch (HibernateOptimisticLockingFailureException ex) {
2521 			// expected
2522 			assertNull(ex.getPersistentClassName());
2523 			assertNull(ex.getIdentifier());
2524 			assertEquals(ssex, ex.getCause());
2525 		}
2526 
2527 		final HibernateException hex = new HibernateException("msg");
2528 		try {
2529 			createTemplate().execute(new HibernateCallback() {
2530 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2531 					throw hex;
2532 				}
2533 			});
2534 			fail("Should have thrown HibernateSystemException");
2535 		}
2536 		catch (HibernateSystemException ex) {
2537 			// expected
2538 			assertEquals(hex, ex.getCause());
2539 		}
2540 	}
2541 
testFallbackExceptionTranslation()2542 	public void testFallbackExceptionTranslation() throws HibernateException {
2543 		SQLException sqlEx = new SQLException("argh", "27");
2544 
2545 		final GenericJDBCException gjex = new GenericJDBCException("mymsg", sqlEx);
2546 		try {
2547 			createTemplate().execute(new HibernateCallback() {
2548 				public Object doInHibernate(org.hibernate.Session session) throws HibernateException {
2549 					throw gjex;
2550 				}
2551 			});
2552 			fail("Should have thrown DataIntegrityViolationException");
2553 		}
2554 		catch (DataIntegrityViolationException ex) {
2555 			// expected
2556 			assertEquals(sqlEx, ex.getCause());
2557 			assertTrue(ex.getMessage().indexOf("mymsg") != -1);
2558 		}
2559 	}
2560 
createTemplate()2561 	private HibernateTemplate createTemplate() throws HibernateException {
2562 		sfControl.reset();
2563 		sessionControl.reset();
2564 		sf.openSession();
2565 		sfControl.setReturnValue(session);
2566 		session.getSessionFactory();
2567 		sessionControl.setReturnValue(sf, 1);
2568 		session.close();
2569 		sessionControl.setReturnValue(null, 1);
2570 		sfControl.replay();
2571 		sessionControl.replay();
2572 		return new HibernateTemplate(sf);
2573 	}
2574 
tearDown()2575 	protected void tearDown() {
2576 		try {
2577 			sfControl.verify();
2578 			sessionControl.verify();
2579 		}
2580 		catch (IllegalStateException ex) {
2581 			// ignore: test method didn't call replay
2582 		}
2583 		assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
2584 		assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
2585 	}
2586 
2587 }
2588