Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.j256.ormlite;
  
  import static java.lang.annotation.ElementType.METHOD;
  import static java.lang.annotation.RetentionPolicy.RUNTIME;
  
 import java.util.Set;
 
 import org.junit.Rule;
 
 
 public abstract class BaseJdbcTest {
 
 	private static final String DATASOURCE_ERROR = "Property 'dataSource' is required";
 	@Rule
 
 	protected static final String DEFAULT_DATABASE_URL = "jdbc:h2:mem:ormlite";
 
 	protected String databaseHost = null;
 	protected String userName = null;
 	protected String password = null;
 
 	protected JdbcConnectionSource connectionSource = null;
 	protected boolean isConnectionExpected = false;
 	protected DatabaseType databaseType = null;
 
 	private Set<Class<?>> dropClassSet = new HashSet<Class<?>>();
 
 	public void before() throws Exception {
 		DaoManager.clearCache();
 		if ( != null) {
 			return;
 		}
 		// do this for everyone
 		System.setProperty("derby.stream.error.file""target/derby.log");
 	}
 
 	protected void openConnectionSource() throws Exception {
 		if ( == null) {
 		}
 	}

Set the database parameters for this db type.

Throws:
java.sql.SQLException For sub classes
 
 	protected void setDatabaseParams() throws SQLException {
 		// noop here -- designed to be overridden
 	}
 
 	public void after() throws Exception {
 		if ( != null) {
 			for (Class<?> clazz : ) {
 				dropTable(clazztrue);
 			}
 			for (DatabaseTableConfig<?> tableConfig : ) {
 				dropTable(tableConfigtrue);
 			}
 		}
 		DaoManager.clearCache();
 	}

Return if this test was expecting to be able to load the driver class
 
	protected boolean isDriverClassExpected() {
		return true;
	}

Return if this test was expecting to be able to connect to the database
	protected boolean isConnectionExpected() throws IOException {
		try {
			if ( == null) {
				return true;
else {
				return InetAddress.getByName().isReachable(500);
			}
catch (UnknownHostException e) {
			return false;
catch (IOException e) {
			throw e;
		}
	}
	protected void closeConnectionSource() throws Exception {
		if ( != null) {
		}
	}
	protected <T, ID> Dao<T, ID> createDao(Class<T> clazzboolean createTablethrows Exception {
		if ( == null) {
		}
		@SuppressWarnings("unchecked")
		BaseDaoImpl<T, ID> dao = (BaseDaoImpl<T, ID>) DaoManager.createDao(clazz);
		return configDao(daocreateTable);
	}
	protected <T, ID> Dao<T, ID> createDao(DatabaseTableConfig<T> tableConfigboolean createTablethrows Exception {
		if ( == null) {
		}
		@SuppressWarnings("unchecked")
		BaseDaoImpl<T, ID> dao = (BaseDaoImpl<T, ID>) DaoManager.createDao(tableConfig);
		return configDao(daocreateTable);
	}
	protected <T> void createTable(Class<T> clazzboolean dropAtEndthrows Exception {
		try {
			// first we drop it in case it existed before
			dropTable(clazztrue);
catch (SQLException ignored) {
			// ignore any errors about missing tables
		}
		TableUtils.createTable(clazz);
		if (dropAtEnd) {
		}
	}
	protected <T> void createTable(DatabaseTableConfig<T> tableConfigboolean dropAtEndthrows Exception {
		try {
			// first we drop it in case it existed before
			dropTable(tableConfigtrue);
catch (SQLException ignored) {
			// ignore any errors about missing tables
		}
		TableUtils.createTable(tableConfig);
		if (dropAtEnd) {
			.add(tableConfig);
		}
	}
	protected <T> void dropTable(Class<T> clazzboolean ignoreErrorsthrows Exception {
		// drop the table and ignore any errors along the way
		TableUtils.dropTable(clazzignoreErrors);
	}
	protected <T> void dropTable(DatabaseTableConfig<T> tableConfigboolean ignoreErrorsthrows Exception {
		// drop the table and ignore any errors along the way
		TableUtils.dropTable(tableConfigignoreErrors);
	}
	private void doOpenConnectionSource() throws Exception {
		if ( == null) {
			}
		}
		if ( == null) {
			if ( != null) {
			}
else {
			if ( != null) {
			}
		}
	}
	private <T, ID> Dao<T, ID> configDao(BaseDaoImpl<T, ID> daoboolean createTablethrows Exception {
		if ( == null) {
		}
		if (createTable) {
			DatabaseTableConfig<T> tableConfig = dao.getTableConfig();
			if (tableConfig == null) {
				tableConfig = DatabaseTableConfig.fromClass(dao.getDataClass());
			}
			createTable(tableConfigtrue);
		}
		return dao;
	}

Our own junit rule which adds in an optional exception matcher if the db host is not available.
	public class PossibleExceptionRule implements MethodRule {
		private Class<? extends ThrowabletClass = null;
		public Statement apply(Statement statementFrameworkMethod methodObject junitClassObject) {
			for (Annotation annotation : method.getAnnotations()) {
				if (annotation.annotationType() == ExpectedBehavior.class) {
					ExpectedBehavior test = (ExpectedBehaviorannotation;
					 = test.expected();
					break;
				}
			}
			return new StatementWrapper(statement);
		}

Specify the expected throwable class or you can use the BaseJdbcTest.ExpectedBehavior annotation.
		public void expect(Class<? extends ThrowabletClass) {
			this. = tClass;
		}
		private class StatementWrapper extends Statement {
			private final Statement statement;
			public StatementWrapper(Statement statement) {
				this. = statement;
			}
			public void evaluate() throws Throwable {
				try {
catch (Throwable t) {
					if (t instanceof MultipleFailureException) {
					}
					if (t instanceof InvocationTargetException) {
					}
					String assertMsg;
					if (t instanceof AssertionError) {
						throw t;
else if ((!) && t.getMessage() != null
						// if we throw because of missing data-source and the db server isn't available, ignore it
						return;
else if ( == null) {
						assertMsg = "Test threw unexpected exception: " + t;
else if ( == t.getClass()) {
						// we matched our expected exception
						return;
else {
						assertMsg = "Expected test to throw " +  + " but it threw: " + t;
					}
					Error error = new AssertionError(assertMsg);
					error.initCause(t);
					throw error;
				}
				// can't be in the throw block
				if ( != null) {
					throw new AssertionError("Expected test to throw " + );
				}
			}
		}
	}

We can't use the

Test:
expected) with the BaseJdbcTest.PossibleExceptionRule rule because it masks the exception and doesn't pass it up to our statement wrapper.
	public @interface ExpectedBehavior {
		Class<? extends Throwableexpected();
	}
New to GrepCode? Check out our FAQ X