/*
 * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.orm.hibernate4;

import java.lang.reflect.Proxy;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Filter;
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.JDBCException;
import org.hibernate.NonUniqueResultException;
import org.hibernate.ObjectDeletedException;
import org.hibernate.ObjectNotFoundException;
import org.hibernate.PersistentObjectException;
import org.hibernate.PropertyValueException;
import org.hibernate.Query;
import org.hibernate.QueryException;
import org.hibernate.ReplicationMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.StaleObjectStateException;
import org.hibernate.StaleStateException;
import org.hibernate.TransientObjectException;
import org.hibernate.UnresolvableObjectException;
import org.hibernate.WrongClassException;
import org.hibernate.exception.ConstraintViolationException;
import org.hibernate.exception.DataException;
import org.hibernate.exception.JDBCConnectionException;
import org.hibernate.exception.LockAcquisitionException;
import org.hibernate.exception.SQLGrammarException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.springframework.dao.CannotAcquireLockException;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.dao.InvalidDataAccessResourceUsageException;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;

/**
 * @author Juergen Hoeller
 * @since 4.0.1
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class HibernateTemplateTests {

	private SessionFactory sessionFactory;
	private Session session;
	private HibernateTemplate hibernateTemplate;

	@Before
	public void setUp() {
		this.sessionFactory = mock(SessionFactory.class);
		this.session = mock(Session.class);
		this.hibernateTemplate = new HibernateTemplate(sessionFactory);
		given(sessionFactory.getCurrentSession()).willReturn(session);
	}

	@After
	public void tearDown() {
		assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
		assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
	}

	@Test
	public void testExecuteWithNewSession()  {
		given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
		given(sessionFactory.openSession()).willReturn(session);

		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session)  {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);
		verify(session).close();
	}

	@Test
	public void testExecuteWithNewSessionAndFilter()  {
		given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
		given(sessionFactory.openSession()).willReturn(session);
		hibernateTemplate.setFilterNames("myFilter");

		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session) {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);
		verify(session).enableFilter("myFilter");
		verify(session).close();
	}

	@Test
	public void testExecuteWithNewSessionAndFilters()  {
		given(sessionFactory.getCurrentSession()).willThrow(new HibernateException("no current session"));
		given(sessionFactory.openSession()).willReturn(session);
		hibernateTemplate.setFilterNames("myFilter", "yourFilter");

		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session)  {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);
		InOrder ordered = inOrder(session);
		ordered.verify(session).enableFilter("myFilter");
		ordered.verify(session).enableFilter("yourFilter");
		ordered.verify(session).close();
	}

	@Test
	public void testExecuteWithThreadBound() {
		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session)  {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);
	}

	@Test
	public void testExecuteWithThreadBoundAndFilter() {
		hibernateTemplate.setFilterNames("myFilter");

		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session)  {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);

		InOrder ordered = inOrder(session);
		ordered.verify(session).enableFilter("myFilter");
		ordered.verify(session).disableFilter("myFilter");
	}

	@Test
	public void testExecuteWithThreadBoundAndFilters() {
		hibernateTemplate.setFilterNames("myFilter", "yourFilter");

		final List l = new ArrayList();
		l.add("test");
		List result = hibernateTemplate.execute(new HibernateCallback<List>() {
			@Override
			public List doInHibernate(Session session)  {
				return l;
			}
		});
		assertTrue("Correct result list", result == l);

		InOrder ordered = inOrder(session);
		ordered.verify(session).enableFilter("myFilter");
		ordered.verify(session).enableFilter("yourFilter");
		ordered.verify(session).disableFilter("myFilter");
		ordered.verify(session).disableFilter("yourFilter");
	}

	@Test
	public void testExecuteWithThreadBoundAndParameterizedFilter() {
		Filter filter = mock(Filter.class);
		given(session.enableFilter("myFilter")).willReturn(filter);
		hibernateTemplate.setFilterNames("myFilter");

		final List l = new ArrayList();
		l.add("test");
		Filter f = hibernateTemplate.enableFilter("myFilter");
		assertTrue("Correct filter", f == filter);

		InOrder ordered = inOrder(session);
		ordered.verify(session).getEnabledFilter("myFilter");
		ordered.verify(session).enableFilter("myFilter");
	}

	@Test
	public void testExecuteWithThreadBoundAndParameterizedExistingFilter() {
		Filter filter = mock(Filter.class);
		given(session.enableFilter("myFilter")).willReturn(filter);
		hibernateTemplate.setFilterNames("myFilter");

		final List l = new ArrayList();
		l.add("test");
		Filter f = hibernateTemplate.enableFilter("myFilter");
		assertTrue("Correct filter", f == filter);

		verify(session).getEnabledFilter("myFilter");
	}

	@Test
	public void testExecuteWithCacheQueries()  {
		Query query1 = mock(Query.class);
		Query query2 = mock(Query.class);
		Criteria criteria = mock(Criteria.class);
		given(session.createQuery("some query")).willReturn(query1);
		given(query1.setCacheable(true)).willReturn(query1);
		given(session.getNamedQuery("some query name")).willReturn(query2);
		given(query2.setCacheable(true)).willReturn(query2);
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setCacheable(true)).willReturn(criteria);

		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session sess) {
				assertNotSame(session, sess);
				assertTrue(Proxy.isProxyClass(sess.getClass()));
				sess.createQuery("some query");
				sess.getNamedQuery("some query name");
				sess.createCriteria(TestBean.class);
				// should be ignored
				sess.close();
				return null;
			}
		});
	}

	@Test
	public void testExecuteWithCacheQueriesAndCacheRegion()  {
		Query query1 = mock(Query.class);
		Query query2 = mock(Query.class);
		Criteria criteria = mock(Criteria.class);
		given(session.createQuery("some query")).willReturn(query1);
		given(query1.setCacheable(true)).willReturn(query1);
		given(query1.setCacheRegion("myRegion")).willReturn(query1);
		given(session.getNamedQuery("some query name")).willReturn(query2);
		given(query2.setCacheable(true)).willReturn(query2);
		given(query2.setCacheRegion("myRegion")).willReturn(query2);
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setCacheable(true)).willReturn(criteria);
		given(criteria.setCacheRegion("myRegion")).willReturn(criteria);

		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.setQueryCacheRegion("myRegion");
		hibernateTemplate.execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session sess) {
				assertNotSame(session, sess);
				assertTrue(Proxy.isProxyClass(sess.getClass()));
				sess.createQuery("some query");
				sess.getNamedQuery("some query name");
				sess.createCriteria(TestBean.class);
				// should be ignored
				sess.close();
				return null;
			}
		});
	}

	@Test
	public void testExecuteWithCacheQueriesAndCacheRegionAndNativeSession()  {
		Query query1 = mock(Query.class);
		Query query2 = mock(Query.class);
		Criteria criteria = mock(Criteria.class);

		given(session.createQuery("some query")).willReturn(query1);
		given(session.getNamedQuery("some query name")).willReturn(query2);
		given(session.createCriteria(TestBean.class)).willReturn(criteria);

		hibernateTemplate.setExposeNativeSession(true);
		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.setQueryCacheRegion("myRegion");
		hibernateTemplate.execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session sess)  {
				assertSame(session, sess);
				sess.createQuery("some query");
				sess.getNamedQuery("some query name");
				sess.createCriteria(TestBean.class);
				return null;
			}
		});
	}

	@Test
	public void testExecuteWithFetchSizeAndMaxResults()  {
		Query query1 = mock(Query.class);
		Query query2 = mock(Query.class);
		Criteria criteria = mock(Criteria.class);

		given(session.createQuery("some query")).willReturn(query1);
		given(query1.setFetchSize(10)).willReturn(query1);
		given(query1.setMaxResults(20)).willReturn(query1);
		given(session.getNamedQuery("some query name")).willReturn(query2);
		given(query2.setFetchSize(10)).willReturn(query2);
		given(query2.setMaxResults(20)).willReturn(query2);
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setFetchSize(10)).willReturn(criteria);
		given(criteria.setMaxResults(20)).willReturn(criteria);

		hibernateTemplate.setFetchSize(10);
		hibernateTemplate.setMaxResults(20);
		hibernateTemplate.execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session sess)  {
				sess.createQuery("some query");
				sess.getNamedQuery("some query name");
				sess.createCriteria(TestBean.class);
				return null;
			}
		});
	}

	@Test
	public void testGet()  {
		TestBean tb = new TestBean();
		given(session.get(TestBean.class, "")).willReturn(tb);
		Object result = hibernateTemplate.get(TestBean.class, "");
		assertTrue("Correct result", result == tb);
	}

	@Test
	public void testGetWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.get("myEntity", "")).willReturn(tb);
		Object result = hibernateTemplate.get("myEntity", "");
		assertTrue("Correct result", result == tb);
	}

	@Test
	public void testLoad()  {
		TestBean tb = new TestBean();
		given(session.load(TestBean.class, "")).willReturn(tb);
		Object result = hibernateTemplate.load(TestBean.class, "");
		assertTrue("Correct result", result == tb);
	}

	@Test
	public void testLoadWithNotFound()  {
		ObjectNotFoundException onfex = new ObjectNotFoundException("id", TestBean.class.getName());
		given(session.load(TestBean.class, "id")).willThrow(onfex);
		try {
			hibernateTemplate.load(TestBean.class, "id");
			fail("Should have thrown HibernateObjectRetrievalFailureException");
		}
		catch (HibernateObjectRetrievalFailureException ex) {
			// expected
			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
			assertEquals("id", ex.getIdentifier());
			assertEquals(onfex, ex.getCause());
		}
	}

	@Test
	public void testLoadWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.load("myEntity", "")).willReturn(tb);
		Object result = hibernateTemplate.load("myEntity", "");
		assertTrue("Correct result", result == tb);
	}

	@Test
	public void testLoadWithObject()  {
		TestBean tb = new TestBean();
		hibernateTemplate.load(tb, "");
		verify(session).load(tb, "");
	}

	@Test
	public void testLoadAll()  {
		Criteria criteria = mock(Criteria.class);
		List list = new ArrayList();
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
		given(criteria.list()).willReturn(list);
		List result = hibernateTemplate.loadAll(TestBean.class);
		assertTrue("Correct result", result == list);
	}

	@Test
	public void testLoadAllWithCacheable()  {
		Criteria criteria = mock(Criteria.class);
		List list = new ArrayList();
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
		given(criteria.setCacheable(true)).willReturn(criteria);
		given(criteria.list()).willReturn(list);

		hibernateTemplate.setCacheQueries(true);
		List result = hibernateTemplate.loadAll(TestBean.class);
		assertTrue("Correct result", result == list);
		verify(criteria).setCacheable(true);
	}

	@Test
	public void testLoadAllWithCacheableAndCacheRegion()  {
		Criteria criteria = mock(Criteria.class);
		List list = new ArrayList();
		given(session.createCriteria(TestBean.class)).willReturn(criteria);
		given(criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).willReturn(criteria);
		given(criteria.setCacheable(true)).willReturn(criteria);
		given(criteria.setCacheRegion("myCacheRegion")).willReturn(criteria);
		given(criteria.list()).willReturn(list);

		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.setQueryCacheRegion("myCacheRegion");
		List result = hibernateTemplate.loadAll(TestBean.class);
		assertTrue("Correct result", result == list);
		verify(criteria).setCacheable(true);
		verify(criteria).setCacheRegion("myCacheRegion");
	}

	@Test public void testRefresh()  {
		TestBean tb = new TestBean();
		hibernateTemplate.refresh(tb);
		verify(session).refresh(tb);
	}

	@Test public void testContains()  {
		TestBean tb = new TestBean();
		given(session.contains(tb)).willReturn(true);
		assertTrue(hibernateTemplate.contains(tb));
	}

	@Test
	public void testEvict()  {
		TestBean tb = new TestBean();
		hibernateTemplate.evict(tb);
		verify(session).evict(tb);
	}

	@Test
	public void testSave()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		given(session.save(tb)).willReturn(0);
		assertEquals("Correct return value", hibernateTemplate.save(tb), 0);
	}

	@Test
	public void testSaveWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		given(session.save("myEntity", tb)).willReturn(0);
		assertEquals("Correct return value", hibernateTemplate.save("myEntity", tb), 0);
	}

	@Test
	public void testUpdate()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.update(tb);
		verify(session).update(tb);
	}

	@Test
	public void testUpdateWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.update("myEntity", tb);
		verify(session).update("myEntity", tb);
	}

	@Test
	public void testSaveOrUpdate()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.saveOrUpdate(tb);
		verify(session).saveOrUpdate(tb);
	}

	@Test
	public void testSaveOrUpdateWithFlushModeNever()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.MANUAL);
		try {
			hibernateTemplate.saveOrUpdate(tb);
			fail("Should have thrown InvalidDataAccessApiUsageException");
		}
		catch (InvalidDataAccessApiUsageException ex) {
			// expected
		}
	}

	@Test
	public void testSaveOrUpdateWithEntityName()  {
		TestBean tb = new TestBean();

		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.saveOrUpdate("myEntity", tb);
		verify(session).saveOrUpdate("myEntity", tb);
	}

	@Test
	public void testReplicate()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.replicate(tb, ReplicationMode.LATEST_VERSION);
		verify(session).replicate(tb, ReplicationMode.LATEST_VERSION);
	}

	@Test
	public void testReplicateWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
		verify(session).replicate("myEntity", tb, ReplicationMode.LATEST_VERSION);
	}

	@Test
	public void testPersist()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.persist(tb);
		verify(session).persist(tb);
	}

	@Test
	public void testPersistWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.persist("myEntity", tb);
		verify(session).persist("myEntity", tb);
	}

	@Test
	public void testMerge()  {
		TestBean tb = new TestBean();
		TestBean tbMerged = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		given(session.merge(tb)).willReturn(tbMerged);
		assertSame(tbMerged, hibernateTemplate.merge(tb));
	}

	@Test
	public void testMergeWithEntityName()  {
		TestBean tb = new TestBean();
		TestBean tbMerged = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		given(session.merge("myEntity", tb)).willReturn(tbMerged);
		assertSame(tbMerged, hibernateTemplate.merge("myEntity", tb));
	}

	@Test
	public void testDelete()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.delete(tb);
		verify(session).delete(tb);
	}

	@Test
	public void testDeleteWithEntityName()  {
		TestBean tb = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		hibernateTemplate.delete("myEntity", tb);
		verify(session).delete("myEntity", tb);
	}

	@Test
	public void testDeleteAll()  {
		TestBean tb1 = new TestBean();
		TestBean tb2 = new TestBean();
		given(session.getFlushMode()).willReturn(FlushMode.AUTO);
		List tbs = new ArrayList();
		tbs.add(tb1);
		tbs.add(tb2);
		hibernateTemplate.deleteAll(tbs);
		verify(session).delete(same(tb1));
		verify(session).delete(same(tb2));
	}

	@Test
	public void testFlush()  {
		hibernateTemplate.flush();
		verify(session).flush();
	}

	@Test
	public void testClear()  {
		hibernateTemplate.clear();
		verify(session).clear();
	}

	@Test
	public void testFind()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.find("some query string");
		assertTrue("Correct list", result == list);
	}

	@Test
	public void testFindWithParameter()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.find("some query string", "myvalue");
		assertTrue("Correct list", result == list);
		verify(query).setParameter(0, "myvalue");
	}

	@Test
	public void testFindWithParameters()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue1")).willReturn(query);
		given(query.setParameter(1, 2)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.find("some query string", "myvalue1", 2);
		assertTrue("Correct list", result == list);
		verify(query).setParameter(0, "myvalue1");
		verify(query).setParameter(1, 2);
	}

	@Test
	public void testFindWithNamedParameter()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter("myparam", "myvalue")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedParam("some query string", "myparam", "myvalue");
		assertTrue("Correct list", result == list);
		verify(query).setParameter("myparam", "myvalue");
	}

	@Test
	public void testFindWithNamedParameters()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter("myparam1", "myvalue1")).willReturn(query);
		given(query.setParameter("myparam2", 2)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedParam("some query string",
				new String[]{"myparam1", "myparam2"},
				new Object[]{"myvalue1", 2});
		assertTrue("Correct list", result == list);
		verify(query).setParameter("myparam1", "myvalue1");
		verify(query).setParameter("myparam2", 2);
	}

	@Test
	public void testFindByValueBean()  {
		Query query = mock(Query.class);
		TestBean tb = new TestBean();
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setProperties(tb)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByValueBean("some query string", tb);
		assertTrue("Correct list", result == list);
		verify(query).setProperties(tb);
	}

	@Test
	public void testFindByNamedQuery()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQuery("some query name");
		assertTrue("Correct list", result == list);
	}

	@Test
	public void testFindByNamedQueryWithParameter()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setParameter(0, "myvalue")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQuery("some query name", "myvalue");
		assertTrue("Correct list", result == list);
		verify(query).setParameter(0, "myvalue");
	}

	@Test
	public void testFindByNamedQueryWithParameters()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setParameter(0, "myvalue1")).willReturn(query);
		given(query.setParameter(1, 2)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQuery("some query name", new Object[] {"myvalue1", 2});
		assertTrue("Correct list", result == list);
		verify(query).setParameter(0, "myvalue1");
		verify(query).setParameter(1, 2);
	}

	@Test
	public void testFindByNamedQueryWithNamedParameter()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setParameter("myparam", "myvalue")).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQueryAndNamedParam("some query name", "myparam", "myvalue");
		assertTrue("Correct list", result == list);
		verify(query).setParameter("myparam", "myvalue");
	}

	@Test
	public void testFindByNamedQueryWithNamedParameters()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setParameter("myparam1", "myvalue1")).willReturn(query);
		given(query.setParameter("myparam2", 2)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQueryAndNamedParam("some query name",
				new String[]{"myparam1", "myparam2"},
				new Object[]{"myvalue1", 2});
		assertTrue("Correct list", result == list);
		verify(query).setParameter("myparam1", "myvalue1");
		verify(query).setParameter("myparam2", 2);
	}

	@Test
	public void testFindByNamedQueryAndValueBean()  {
		Query query = mock(Query.class);
		TestBean tb = new TestBean();
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setProperties(tb)).willReturn(query);
		given(query.list()).willReturn(list);
		List result = hibernateTemplate.findByNamedQueryAndValueBean("some query name", tb);
		assertTrue("Correct list", result == list);
		verify(query).setProperties(tb);
	}

	@Test
	public void testFindWithCacheable()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setCacheable(true)).willReturn(query);
		given(query.list()).willReturn(list);
		hibernateTemplate.setCacheQueries(true);
		List result = hibernateTemplate.find("some query string");
		assertTrue("Correct list", result == list);
		verify(query).setCacheable(true);
	}

	@Test
	public void testFindWithCacheableAndCacheRegion()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setCacheable(true)).willReturn(query);
		given(query.setCacheRegion("myCacheRegion")).willReturn(query);
		given(query.list()).willReturn(list);
		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.setQueryCacheRegion("myCacheRegion");
		List result = hibernateTemplate.find("some query string");
		assertTrue("Correct list", result == list);
		verify(query).setCacheable(true);
		verify(query).setCacheRegion("myCacheRegion");
	}

	@Test
	public void testFindByNamedQueryWithCacheable()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setCacheable(true)).willReturn(query);
		given(query.list()).willReturn(list);
		hibernateTemplate.setCacheQueries(true);
		List result = hibernateTemplate.findByNamedQuery("some query name");
		assertTrue("Correct list", result == list);
		verify(query).setCacheable(true);
	}

	@Test
	public void testFindByNamedQueryWithCacheableAndCacheRegion()  {
		Query query = mock(Query.class);
		List list = new ArrayList();
		given(session.getNamedQuery("some query name")).willReturn(query);
		given(query.setCacheable(true)).willReturn(query);
		given(query.setCacheRegion("myCacheRegion")).willReturn(query);
		given(query.list()).willReturn(list);
		hibernateTemplate.setCacheQueries(true);
		hibernateTemplate.setQueryCacheRegion("myCacheRegion");
		List result = hibernateTemplate.findByNamedQuery("some query name");
		assertTrue("Correct list", result == list);
		verify(query).setCacheable(true);
		verify(query).setCacheRegion("myCacheRegion");
	}

	@Test
	public void testIterate()  {
		Query query = mock(Query.class);
		Iterator it = Collections.EMPTY_LIST.iterator();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.iterate()).willReturn(it);
		Iterator result = hibernateTemplate.iterate("some query string");
		assertTrue("Correct list", result == it);
	}

	@Test
	public void testIterateWithParameter()  {
		Query query = mock(Query.class);
		Iterator it = Collections.EMPTY_LIST.iterator();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue")).willReturn(query);
		given(query.iterate()).willReturn(it);
		Iterator result = hibernateTemplate.iterate("some query string", "myvalue");
		assertTrue("Correct list", result == it);
		verify(query).setParameter(0, "myvalue");
	}

	@Test
	public void testIterateWithParameters()  {
		Query query = mock(Query.class);
		Iterator it = Collections.EMPTY_LIST.iterator();
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue1")).willReturn(query);
		given(query.setParameter(1, 2)).willReturn(query);
		given(query.iterate()).willReturn(it);
		Iterator result = hibernateTemplate.iterate("some query string", "myvalue1", 2);
		assertTrue("Correct list", result == it);
		verify(query).setParameter(0, "myvalue1");
		verify(query).setParameter(1, 2);
	}

	@Test
	public void testBulkUpdate()  {
		Query query = mock(Query.class);
		given(session.createQuery("some query string")).willReturn(query);
		given(query.executeUpdate()).willReturn(5);
		int result = hibernateTemplate.bulkUpdate("some query string");
		assertTrue("Correct list", result == 5);
	}

	@Test
	public void testBulkUpdateWithParameter()  {
		Query query = mock(Query.class);
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue")).willReturn(query);
		given(query.executeUpdate()).willReturn(5);
		int result = hibernateTemplate.bulkUpdate("some query string", "myvalue");
		assertTrue("Correct list", result == 5);
		verify(query).setParameter(0, "myvalue");
	}

	@Test
	public void testBulkUpdateWithParameters()  {
		Query query = mock(Query.class);
		given(session.createQuery("some query string")).willReturn(query);
		given(query.setParameter(0, "myvalue1")).willReturn(query);
		given(query.setParameter(1, 2)).willReturn(query);
		given(query.executeUpdate()).willReturn(5);
		int result = hibernateTemplate.bulkUpdate("some query string", "myvalue1", 2);
		assertTrue("Correct list", result == 5);
		verify(query).setParameter(0, "myvalue1");
		verify(query).setParameter(1, 2);
	}

	@Test
	public void testExceptions()  {
		SQLException sqlEx = new SQLException("argh", "27");

		final JDBCConnectionException jcex = new JDBCConnectionException("mymsg", sqlEx);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw jcex;
				}
			});
			fail("Should have thrown DataAccessResourceFailureException");
		}
		catch (DataAccessResourceFailureException ex) {
			// expected
			assertEquals(jcex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final SQLGrammarException sgex = new SQLGrammarException("mymsg", sqlEx);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw sgex;
				}
			});
			fail("Should have thrown InvalidDataAccessResourceUsageException");
		}
		catch (InvalidDataAccessResourceUsageException ex) {
			// expected
			assertEquals(sgex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final LockAcquisitionException laex = new LockAcquisitionException("mymsg", sqlEx);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw laex;
				}
			});
			fail("Should have thrown CannotAcquireLockException");
		}
		catch (CannotAcquireLockException ex) {
			// expected
			assertEquals(laex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final ConstraintViolationException cvex = new ConstraintViolationException("mymsg", sqlEx, "myconstraint");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw cvex;
				}
			});
			fail("Should have thrown DataIntegrityViolationException");
		}
		catch (DataIntegrityViolationException ex) {
			// expected
			assertEquals(cvex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final DataException dex = new DataException("mymsg", sqlEx);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw dex;
				}
			});
			fail("Should have thrown DataIntegrityViolationException");
		}
		catch (DataIntegrityViolationException ex) {
			// expected
			assertEquals(dex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final JDBCException jdex = new JDBCException("mymsg", sqlEx);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw jdex;
				}
			});
			fail("Should have thrown HibernateJdbcException");
		}
		catch (HibernateJdbcException ex) {
			// expected
			assertEquals(jdex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		final PropertyValueException pvex = new PropertyValueException("mymsg", "myentity", "myproperty");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw pvex;
				}
			});
			fail("Should have thrown DataIntegrityViolationException");
		}
		catch (DataIntegrityViolationException ex) {
			// expected
			assertEquals(pvex, ex.getCause());
			assertTrue(ex.getMessage().contains("mymsg"));
		}

		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw new PersistentObjectException("");
				}
			});
			fail("Should have thrown InvalidDataAccessApiUsageException");
		}
		catch (InvalidDataAccessApiUsageException ex) {
			// expected
		}

		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw new TransientObjectException("");
				}
			});
			fail("Should have thrown InvalidDataAccessApiUsageException");
		}
		catch (InvalidDataAccessApiUsageException ex) {
			// expected
		}

		final ObjectDeletedException odex = new ObjectDeletedException("msg", "id", TestBean.class.getName());
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw odex;
				}
			});
			fail("Should have thrown InvalidDataAccessApiUsageException");
		}
		catch (InvalidDataAccessApiUsageException ex) {
			// expected
			assertEquals(odex, ex.getCause());
		}

		final QueryException qex = new QueryException("msg", "query");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw qex;
				}
			});
			fail("Should have thrown InvalidDataAccessResourceUsageException");
		}
		catch (HibernateQueryException ex) {
			// expected
			assertEquals(qex, ex.getCause());
			assertEquals("query", ex.getQueryString());
		}

		final UnresolvableObjectException uoex = new UnresolvableObjectException("id", TestBean.class.getName());
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw uoex;
				}
			});
			fail("Should have thrown HibernateObjectRetrievalFailureException");
		}
		catch (HibernateObjectRetrievalFailureException ex) {
			// expected
			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
			assertEquals("id", ex.getIdentifier());
			assertEquals(uoex, ex.getCause());
		}

		final ObjectNotFoundException onfe = new ObjectNotFoundException("id", TestBean.class.getName());
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw onfe;
				}
			});
			fail("Should have thrown HibernateObjectRetrievalFailureException");
		}
		catch (HibernateObjectRetrievalFailureException ex) {
			// expected
			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
			assertEquals("id", ex.getIdentifier());
			assertEquals(onfe, ex.getCause());
		}

		final WrongClassException wcex = new WrongClassException("msg", "id", TestBean.class.getName());
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw wcex;
				}
			});
			fail("Should have thrown HibernateObjectRetrievalFailureException");
		}
		catch (HibernateObjectRetrievalFailureException ex) {
			// expected
			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
			assertEquals("id", ex.getIdentifier());
			assertEquals(wcex, ex.getCause());
		}

		final NonUniqueResultException nuex = new NonUniqueResultException(2);
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw nuex;
				}
			});
			fail("Should have thrown IncorrectResultSizeDataAccessException");
		}
		catch (IncorrectResultSizeDataAccessException ex) {
			// expected
			assertEquals(1, ex.getExpectedSize());
			assertEquals(-1, ex.getActualSize());
		}

		final StaleObjectStateException sosex = new StaleObjectStateException(TestBean.class.getName(), "id");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw sosex;
				}
			});
			fail("Should have thrown HibernateOptimisticLockingFailureException");
		}
		catch (HibernateOptimisticLockingFailureException ex) {
			// expected
			assertEquals(TestBean.class.getName(), ex.getPersistentClassName());
			assertEquals("id", ex.getIdentifier());
			assertEquals(sosex, ex.getCause());
		}

		final StaleStateException ssex = new StaleStateException("msg");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw ssex;
				}
			});
			fail("Should have thrown HibernateOptimisticLockingFailureException");
		}
		catch (HibernateOptimisticLockingFailureException ex) {
			// expected
			assertNull(ex.getPersistentClassName());
			assertNull(ex.getIdentifier());
			assertEquals(ssex, ex.getCause());
		}

		final HibernateException hex = new HibernateException("msg");
		try {
			hibernateTemplate.execute(new HibernateCallback<Object>() {
				@Override
				public Object doInHibernate(Session session)  {
					throw hex;
				}
			});
			fail("Should have thrown HibernateSystemException");
		}
		catch (HibernateSystemException ex) {
			// expected
			assertEquals(hex, ex.getCause());
		}
	}

}
