Mainly intended for test environments. 

 public static BytecodeProvider buildBytecodeProvider(Properties properties) 
{
		String provider = PropertiesHelper.getString( BYTECODE_PROVIDER, properties, "javassist" );
		log.info( "Bytecode provider name : " + provider );
		return buildBytecodeProvider( provider );
}

 public static BytecodeProvider getBytecodeProvider() 
{
		log.info("Hibernate " + VERSION);
		RENAMED_PROPERTIES.put( "hibernate.cglib.use_reflection_optimizer", USE_REFLECTION_OPTIMIZER );
		ISOLATION_LEVELS.put( new Integer(Connection.TRANSACTION_NONE), "NONE" );
		ISOLATION_LEVELS.put( new Integer(Connection.TRANSACTION_READ_UNCOMMITTED), "READ_UNCOMMITTED" );
		ISOLATION_LEVELS.put( new Integer(Connection.TRANSACTION_READ_COMMITTED), "READ_COMMITTED" );
		ISOLATION_LEVELS.put( new Integer(Connection.TRANSACTION_REPEATABLE_READ), "REPEATABLE_READ" );
		ISOLATION_LEVELS.put( new Integer(Connection.TRANSACTION_SERIALIZABLE), "SERIALIZABLE" );
		GLOBAL_PROPERTIES = new Properties();
		//Set USE_REFLECTION_OPTIMIZER to false to fix HHH-227
		GLOBAL_PROPERTIES.setProperty( USE_REFLECTION_OPTIMIZER, Boolean.FALSE.toString() );
		try {
			InputStream stream = ConfigHelper.getResourceAsStream("/hibernate.properties");
			try {
				GLOBAL_PROPERTIES.load(stream);
				log.info( "loaded properties from resource hibernate.properties: " + PropertiesHelper.maskOut(GLOBAL_PROPERTIES, PASS) );
			}
			catch (Exception e) {
				log.error("problem loading properties from hibernate.properties");
			}
			finally {
				try{
					stream.close();
				}
				catch (IOException ioe){
					log.error("could not close stream on hibernate.properties", ioe);
				}
			}
		}
		catch (HibernateException he) {
			log.info("hibernate.properties not found");
		}
		try {
			GLOBAL_PROPERTIES.putAll( System.getProperties() );
		}
		catch (SecurityException se) {
			log.warn("could not copy system properties, system properties will be ignored");
		}
		verifyProperties(GLOBAL_PROPERTIES);
		ENABLE_BINARY_STREAMS = PropertiesHelper.getBoolean(USE_STREAMS_FOR_BINARY, GLOBAL_PROPERTIES);
		ENABLE_REFLECTION_OPTIMIZER = PropertiesHelper.getBoolean(USE_REFLECTION_OPTIMIZER, GLOBAL_PROPERTIES);
		if (ENABLE_BINARY_STREAMS) {
			log.info("using java.io streams to persist binary types");
		}
		if (ENABLE_REFLECTION_OPTIMIZER) {
			log.info("using bytecode reflection optimizer");
		}
		BYTECODE_PROVIDER_INSTANCE = buildBytecodeProvider( GLOBAL_PROPERTIES );
		boolean getGeneratedKeysSupport;
		try {
			Statement.class.getMethod("getGeneratedKeys", null);
			getGeneratedKeysSupport = true;
		}
		catch (NoSuchMethodException nsme) {
			getGeneratedKeysSupport = false;
		}
		JVM_SUPPORTS_GET_GENERATED_KEYS = getGeneratedKeysSupport;
		if (!JVM_SUPPORTS_GET_GENERATED_KEYS) log.info("JVM does not support Statement.getGeneratedKeys()");
		boolean linkedHashSupport;
		try {
			Class.forName("java.util.LinkedHashSet");
			linkedHashSupport = true;
		}
		catch (ClassNotFoundException cnfe) {
			linkedHashSupport = false;
		}
		JVM_SUPPORTS_LINKED_HASH_COLLECTIONS = linkedHashSupport;
		if (!JVM_SUPPORTS_LINKED_HASH_COLLECTIONS) log.info("JVM does not support LinkedHasMap, LinkedHashSet - ordered maps and sets disabled");
		JVM_HAS_TIMESTAMP_BUG = new Timestamp(123456789).getTime() != 123456789;
		if (JVM_HAS_TIMESTAMP_BUG) log.info("using workaround for JVM bug in java.sql.Timestamp");
		Timestamp t = new Timestamp(0);
		t.setNanos(5 * 1000000);
		JVM_HAS_JDK14_TIMESTAMP = t.getTime() == 5;
		if (JVM_HAS_JDK14_TIMESTAMP) {
			log.info("using JDK 1.4 java.sql.Timestamp handling");
		}
		else {
			log.info("using pre JDK 1.4 java.sql.Timestamp handling");
		}
		return BYTECODE_PROVIDER_INSTANCE;
}

 public static Properties getProperties() 
{
		Properties copy = new Properties();
		copy.putAll(GLOBAL_PROPERTIES);
		return copy;
}

Return System properties, extended by any properties specified in hibernate.properties.

 public static String isolationLevelToString(int isolation) 
{
		return (String) ISOLATION_LEVELS.get( new Integer(isolation) );
}

Get the name of a JDBC transaction isolation level

 public static boolean jvmHasJDK14Timestamp() 
{
		return JVM_HAS_JDK14_TIMESTAMP;
}

Does this JVM handle Timestamp in the JDK 1.4 compliant way?

 public static boolean jvmHasTimestampBug() 
{
		return JVM_HAS_TIMESTAMP_BUG;
}

Does this JVM have the IBM JDK 1.3.1. The bug is new Timestamp(x).getTime()!=x.

 public static boolean jvmSupportsGetGeneratedKeys() 
{
		return JVM_SUPPORTS_GET_GENERATED_KEYS;
}

 public static boolean jvmSupportsLinkedHashCollections() 
{
		return JVM_SUPPORTS_LINKED_HASH_COLLECTIONS;
}

Does this JVM support LinkedHashSet, LinkedHashMap.

 public static boolean useReflectionOptimizer() 
{
		return ENABLE_REFLECTION_OPTIMIZER;
}

Should we use CGLIB reflection optimizer. Property hibernate.jdbc.use_refection_optimizer.

 public static boolean useStreamsForBinary() 
{
		return ENABLE_BINARY_STREAMS;
}

Should we use streams to bind binary types to JDBC IN parameters. Property hibernate.jdbc.use_streams_for_binary.

 public static  void verifyProperties(Properties props) 
{
	            	 
		Iterator iter = props.keySet().iterator();
		Map propertiesToAdd = new HashMap();
		while ( iter.hasNext() ) {
			final Object propertyName = iter.next();
			Object newPropertyName = OBSOLETE_PROPERTIES.get( propertyName );
			if ( newPropertyName != null ) {
				log.warn( "Usage of obsolete property: " + propertyName + " no longer supported, use: " + newPropertyName );
			}
			newPropertyName = RENAMED_PROPERTIES.get( propertyName );
			if ( newPropertyName != null ) {
				log.warn( "Property [" + propertyName + "] has been renamed to [" + newPropertyName + "]; update your properties appropriately" );
				if ( ! props.containsKey( newPropertyName ) ) {
					propertiesToAdd.put( newPropertyName, props.get( propertyName ) );
				}
			}
		}
		props.putAll(propertiesToAdd);
}

Issues warnings to the user when any obsolete property names are used.