Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate, Relational Persistence for Idiomatic Java
   *
   * Copyright (c) 2011, Red Hat Inc. or third-party contributors as
   * indicated by the @author tags or express copyright attribution
   * statements applied by the authors.  All third-party contributions are
   * distributed under license by Red Hat Inc.
   *
   * This copyrighted material is made available to anyone wishing to use, modify,
  * copy, or redistribute it subject to the terms and conditions of the GNU
  * Lesser General Public License, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  * for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this distribution; if not, write to:
  * Free Software Foundation, Inc.
  * 51 Franklin Street, Fifth Floor
  * Boston, MA  02110-1301  USA
  */
 package org.hibernate.testing.junit4;
 
 import java.sql.Blob;
 import java.sql.Clob;
 import java.util.List;
 import java.util.Map;
 
 
 
 import static org.junit.Assert.fail;

Applies functional testing logic for core Hibernate testing on top of BaseUnitTestCase

Author(s):
Steve Ebersole
 
 @SuppressWarnings( {"deprecation"} )
 public abstract class BaseCoreFunctionalTestCase extends BaseUnitTestCase {
 	public static final String VALIDATE_DATA_CLEANUP = "hibernate.test.validateDataCleanup";
 	public static final String USE_NEW_METADATA_MAPPINGS = "hibernate.test.new_metadata_mappings";
 
 	public static final Dialect DIALECT = Dialect.getDialect();
 
 	private boolean isMetadataUsed;
 
 	protected Session session;
 
 	protected static Dialect getDialect() {
 		return ;
 	}
 
 	protected Configuration configuration() {
 		return ;
	}
	}
	}
	protected Session openSession() throws HibernateException {
		return ;
	}
	protected Session openSession(Interceptor interceptorthrows HibernateException {
		return ;
	}
	// before/after test class ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	@SuppressWarnings( {"UnusedDeclaration"})
	protected void buildSessionFactory() {
		// for now, build the configuration to get all the property settings
					public Boolean convert(Object value) {
						return Boolean.parseBoolean( ( String ) value );
					}
				},
				false
		);
		if (  ) {
			MetadataImplementor metadataImplementor = buildMetadatabootRegistry );
			afterConstructAndConfigureMetadatametadataImplementor );
		}
		else {
			// this is done here because Configuration does not currently support 4.0 xsd
		}
	}
	protected void rebuildSessionFactory() {
		if (  == null ) {
			return;
		}
		try {
		}
		catch (Exception ignore) {
		}
	}
	protected void afterConstructAndConfigureMetadata(MetadataImplementor metadataImplementor) {
	}
			StandardServiceRegistryImpl serviceRegistry) {
		MetadataSources sources = new MetadataSourcesbootRegistry );
		addMappingssources );
		return (MetadataImplementorsources.getMetadataBuilderserviceRegistry ).build();
	}
	// TODO: is this still needed?
		return cfg;
	}
		configurecfg );
		return cfg;
	}
		addMappingscfg );
	}
		Configuration configuration = new Configuration()
		if ( createSchema() ) {
			configuration.setProperty."create-drop" );
			final String secondSchemaName = createSecondSchema();
			if ( StringHelper.isNotEmptysecondSchemaName ) ) {
				if ( !( getDialect() instanceof H2Dialect ) ) {
					throw new UnsupportedOperationException"Only H2 dialect supports creation of second schema." );
				}
				Helper.createH2SchemasecondSchemaNameconfiguration );
			}
		}
		return configuration;
	}
	protected void configure(Configuration configuration) {
	}
	protected void addMappings(Configuration configuration) {
		String[] mappings = getMappings();
		if ( mappings != null ) {
			for ( String mapping : mappings ) {
				configuration.addResource(
						getBaseForMappings() + mapping,
				);
			}
		}
		Class<?>[] annotatedClasses = getAnnotatedClasses();
		if ( annotatedClasses != null ) {
			for ( Class<?> annotatedClass : annotatedClasses ) {
				configuration.addAnnotatedClassannotatedClass );
			}
		}
		String[] annotatedPackages = getAnnotatedPackages();
		if ( annotatedPackages != null ) {
			for ( String annotatedPackage : annotatedPackages ) {
				configuration.addPackageannotatedPackage );
			}
		}
		String[] xmlFiles = getXmlFiles();
		if ( xmlFiles != null ) {
			for ( String xmlFile : xmlFiles ) {
				configuration.addInputStreamis );
			}
		}
	}
	protected void addMappings(MetadataSources sources) {
		String[] mappings = getMappings();
		if ( mappings != null ) {
			for ( String mapping : mappings ) {
				sources.addResource(
						getBaseForMappings() + mapping
				);
			}
		}
		Class<?>[] annotatedClasses = getAnnotatedClasses();
		if ( annotatedClasses != null ) {
			for ( Class<?> annotatedClass : annotatedClasses ) {
				sources.addAnnotatedClassannotatedClass );
			}
		}
		String[] annotatedPackages = getAnnotatedPackages();
		if ( annotatedPackages != null ) {
			for ( String annotatedPackage : annotatedPackages ) {
				sources.addPackageannotatedPackage );
			}
		}
		String[] xmlFiles = getXmlFiles();
		if ( xmlFiles != null ) {
			for ( String xmlFile : xmlFiles ) {
				sources.addInputStreamis );
			}
		}
	}
	protected static final String[] NO_MAPPINGS = new String[0];
	protected String[] getMappings() {
		return ;
	}
	protected String getBaseForMappings() {
		return "org/hibernate/test/";
	}
	protected static final Class<?>[] NO_CLASSES = new Class[0];
	protected Class<?>[] getAnnotatedClasses() {
		return ;
	}
	protected String[] getAnnotatedPackages() {
		return ;
	}
	protected String[] getXmlFiles() {
		// todo : rename to getOrmXmlFiles()
		return ;
	}
	protected void applyCacheSettings(Configuration configuration) {
		if ( getCacheConcurrencyStrategy() != null ) {
			Iterator itr = configuration.getClassMappings();
			while ( itr.hasNext() ) {
				boolean hasLob = false;
				while ( props.hasNext() ) {
					Property prop = (Propertyprops.next();
					if ( prop.getValue().isSimpleValue() ) {
						String type = ( (SimpleValueprop.getValue() ).getTypeName();
						if ( "blob".equals(type) || "clob".equals(type) ) {
							hasLob = true;
						}
						if ( Blob.class.getName().equals(type) || Clob.class.getName().equals(type) ) {
							hasLob = true;
						}
					}
				}
				if ( !hasLob && !clazz.isInherited() && overrideCacheStrategy() ) {
				}
			}
			itr = configuration.getCollectionMappings();
			while ( itr.hasNext() ) {
				Collection coll = (Collectionitr.next();
			}
		}
	}
	protected boolean overrideCacheStrategy() {
		return true;
	}
		return null;
	}
	protected void afterConfigurationBuilt(Configuration configuration) {
	}
	protected void afterConfigurationBuilt(Mappings mappingsDialect dialect) {
	}
		return builder.build();
	}
	}
		Properties properties = new Properties();
		properties.putAllconfiguration.getProperties() );
		Environment.verifyPropertiesproperties );
		ConfigurationHelper.resolvePlaceHoldersproperties );
		StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilderbootRegistry ).applySettingsproperties );
		prepareBasicRegistryBuilderregistryBuilder );
		return (StandardServiceRegistryImplregistryBuilder.build();
	}
	protected void prepareBasicRegistryBuilder(StandardServiceRegistryBuilder serviceRegistryBuilder) {
	}
	protected void afterSessionFactoryBuilt() {
	}
	protected boolean createSchema() {
		return true;
	}

Feature supported only by H2 dialect.

Returns:
Provide not empty name to create second schema.
	protected String createSecondSchema() {
		return null;
	}
	protected boolean rebuildSessionFactoryOnError() {
		return true;
	}
	@SuppressWarnings( {"UnusedDeclaration"})
	protected void releaseSessionFactory() {
		if (  == null ) {
			return;
		}
		 = null;
        if( == null){
            return;
        }
        .destroy();
        =null;
	}
	@SuppressWarnings( {"UnusedDeclaration"})
	public void onFailure() {
		}
	}
	// before/after each test ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public final void beforeTest() throws Exception {
	}
	protected void prepareTest() throws Exception {
	}
	public final void afterTest() throws Exception {
		}
	}
	protected void cleanupCache() {
		if (  != null ) {
		}
	}
	protected boolean isCleanupTestDataRequired() { return false; }
	protected void cleanupTestData() throws Exception {
		s.createQuery"delete from java.lang.Object" ).executeUpdate();
		s.close();
	}
	private void cleanupSession() {
		if (  != null && ! ( (SessionImplementor ).isClosed() ) {
			if ( .isConnected() ) {
			}
		}
		 = null;
	}
	public class RollbackWork implements Work {
		public void execute(Connection connectionthrows SQLException {
			connection.rollback();
		}
	}
	protected void cleanupTest() throws Exception {
	}
	@SuppressWarnings( {"UnnecessaryBoxing""UnnecessaryUnboxing"})
	protected void assertAllDataRemoved() {
		if ( !createSchema() ) {
			return// no tables were created...
		}
		if ( !Boolean.getBoolean ) ) {
			return;
		}
		try {
			List list = tmpSession.createQuery"select o from java.lang.Object o" ).list();
			Map<String,Integeritems = new HashMap<String,Integer>();
			if ( !list.isEmpty() ) {
				for ( Object element : list ) {
					Integer l = items.gettmpSession.getEntityNameelement ) );
					if ( l == null ) {
						l = 0;
					}
					l = l + 1 ;
					items.puttmpSession.getEntityNameelement ), l );
					..println"Data left: " + element );
				}
				fail"Data is left in the database: " + items.toString() );
			}
		}
		finally {
			try {
				tmpSession.close();
			}
			catchThrowable t ) {
				// intentionally empty
			}
		}
	}
	protected boolean readCommittedIsolationMaintained(String scenario) {
		Session testSession = null;
		try {
			testSession = openSession();
			isolation = testSession.doReturningWork(
						public Integer execute(Connection connectionthrows SQLException {
							return connection.getTransactionIsolation();
						}
					}
			);
		}
		catchThrowable ignore ) {
		}
		finally {
			if ( testSession != null ) {
				try {
					testSession.close();
				}
				catchThrowable ignore ) {
				}
			}
		}
		if ( isolation < ... ) {
			SkipLog.reportSkip"environment does not support at least read committed isolation"scenario );
			return false;
		}
		else {
			return true;
		}
	}
New to GrepCode? Check out our FAQ X